@woosh/meep-engine 2.33.74 → 2.34.1

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

@@ -433,9 +433,10 @@ async function sample_scene_nam(engine) {
         "distanceMax": 1000
     });
 
-    // load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
-    load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
+    load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    // load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
     // load_model('moicon/micron_container/model.gltf', ecd)
+    // load_model('moicon/test_philippe_jan_2022/test/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -30,13 +30,19 @@ export function query_bvh_frustum_from_texture(
     let result = 0;
     let plane_address;
 
+    const binary_node_count = root.getBinaryNodeCount();
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
     stack[0] = 0;
 
-    const binary_node_count = root.getBinaryNodeCount();
     const last_valid_index = binary_node_count + root.getLeafNodeCount();
     const data_view = root.getDataView();
 
@@ -122,8 +128,6 @@ export function query_bvh_frustum_from_texture(
 
             } else if (light_type === 3) {
                 // decal
-                debugger;
-
             } else {
                 throw new Error(`Unsupported light type ${light_type}`);
             }

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -1374,6 +1374,8 @@ Sampler2D.prototype.traverseCircle = function (centerX, centerY, radius, visitor
  * @param {boolean} [preserveData=true]
  */
 Sampler2D.prototype.resize = function (x, y, preserveData = true) {
+    assert.isNonNegativeInteger(x, 'x');
+    assert.isNonNegativeInteger(y, 'y');
 
     const _w = this.width;
     const _h = this.height;

package/engine/graphics/texture/sampler/downsampleSampler2D.js

@@ -56,9 +56,11 @@ export function downsampleSampler2D(input, output) {
 
             // accumulate sample
             for (j = 0; j < sH; j++) {
+                const row_index = (sampleOffsetY + j) * iW;
+
                 for (i = 0; i < sW; i++) {
 
-                    const iAddress = ((sampleOffsetX + i) + (sampleOffsetY + j) * iW) * itemSize;
+                    const iAddress = ((sampleOffsetX + i) + row_index) * itemSize;
 
                     for (k = 0; k < itemSize; k++) {
                         sample[k] += iData[k + iAddress];

package/engine/graphics/texture/sampler/genericResampleSampler2D.js

@@ -0,0 +1,67 @@
+import { max2 } from "../../../../core/math/max2.js";
+
+/**
+ *
+ * @param {Sampler2D} source
+ * @param {Sampler2D} target
+ */
+export function genericResampleSampler2D(source, target) {
+    const target_width = target.width;
+    const target_height = target.height;
+
+    // build kernel
+
+    // TODO add gaussian weights kernel for samples
+
+    const u_scale = source.width / target_width;
+    const v_scale = source.height / target_height;
+
+    const kernel_width = max2(1, Math.ceil(u_scale));
+    const kernel_height = max2(1, Math.ceil(v_scale));
+
+    const kernel_size = kernel_width * kernel_height;
+
+    const itemSize = source.itemSize;
+
+    const sample = new Float32Array(itemSize);
+
+    let column_index;
+    let row_index;
+    let k_y;
+    let k_x;
+    let i;
+
+    for (column_index = 0; column_index < target_height; column_index++) {
+        for (row_index = 0; row_index < target_width; row_index++) {
+
+            // figure out source offset
+            const source_x = row_index * u_scale;
+            const source_y = column_index * v_scale;
+
+            // reset sample
+            for (i = 0; i < itemSize; i++) {
+                sample[i] = 0;
+            }
+
+            // accumulate kernel samples
+            for (k_y = 0; k_y < kernel_height; k_y++) {
+
+                for (k_x = 0; k_x < kernel_width; k_x++) {
+
+                    for (i = 0; i < itemSize; i++) {
+                        sample[i] += source.sampleChannelBilinear(source_x + k_x, source_y + k_y, i);
+                    }
+
+                }
+            }
+
+            for (i = 0; i < itemSize; i++) {
+                // dilute sample
+                const channel_value = sample[i] / kernel_size;
+                // write out
+                target.data[(column_index * target_width + row_index) * itemSize + i] = channel_value;
+            }
+
+        }
+    }
+}

package/engine/graphics/texture/sampler/scaleSampler2D.js

@@ -1,47 +1,41 @@
 import { assert } from "../../../../core/assert.js";
+import { downsampleSampler2D } from "./downsampleSampler2D.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { upsampleSampler2D } from "./upsampleSampler2D.js";
+import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
 
 /**
  *
- * @param {Sampler2D} source
- * @param {Sampler2D} target
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
  */
-export function scaleSampler2D(source, target) {
-    const targetItemSize = target.itemSize;
+export function scaleSampler2D(input, output) {
+    const targetItemSize = output.itemSize;
 
-    assert.equal(source.itemSize, targetItemSize, 'both source and target must have the same number of channels');
+    assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');
 
-    const targetWidth = target.width;
-    const targetHeight = target.height;
-    const sourceWidth = source.width;
-    const sourceHeight = source.height;
-
-
-    const target_data = target.data;
+    const targetWidth = output.width;
+    const targetHeight = output.height;
+    const sourceWidth = input.width;
+    const sourceHeight = input.height;
 
     if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
-        // exact size match, nothing to do
-        target_data.set(source.data);
-        return;
-    }
-
-    const targetRowSize = targetItemSize * targetWidth;
-
-    const source_scale_x = sourceWidth / targetWidth;
-    const source_scale_y = sourceHeight / targetHeight;
-
-    for (let y = 0; y < targetHeight; y++) {
-
-
-        const sample_y = y * source_scale_y;
-        const target_row_address = y * targetRowSize;
-
-        for (let x = 0; x < targetWidth; x++) {
-
-
-            const target_offset = target_row_address + x * targetItemSize;
-
-            source.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
-
+        // same dimensions, copy directly
+        output.data.set(input.data);
+    } else if (sourceWidth > targetWidth && sourceHeight > targetHeight) {
+        // downscaling
+        if (Number.isInteger(sourceWidth / targetWidth) && Number.isInteger(sourceHeight / targetHeight)) {
+            // dimensions are multiples of source/target
+            downsampleSampler2D(input, output);
+        } else {
+            // generic downsample
+            genericResampleSampler2D(input, output);
         }
+    } else if (sourceWidth < targetWidth && sourceHeight < targetHeight) {
+        // upscaling
+        upsampleSampler2D(input, output);
+    } else {
+        // mixed resampling
+        genericResampleSampler2D(input, output);
     }
 }

package/engine/graphics/texture/sampler/upsampleSampler2D.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
+ */
+export function upsampleSampler2D(input, output) {
+    const targetItemSize = output.itemSize;
+
+    assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');
+
+    const targetWidth = output.width;
+    const targetHeight = output.height;
+    const sourceWidth = input.width;
+    const sourceHeight = input.height;
+
+
+    const target_data = output.data;
+
+    if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
+        // exact size match, nothing to do
+        target_data.set(input.data);
+        return;
+    }
+
+    const targetRowSize = targetItemSize * targetWidth;
+
+    const source_scale_x = sourceWidth / targetWidth;
+    const source_scale_y = sourceHeight / targetHeight;
+
+    for (let y = 0; y < targetHeight; y++) {
+
+
+        const sample_y = y * source_scale_y;
+        const target_row_address = y * targetRowSize;
+
+        for (let x = 0; x < targetWidth; x++) {
+
+
+            const target_offset = target_row_address + x * targetItemSize;
+
+            input.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
+
+        }
+    }
+}

package/generation/filtering/numeric/CellFilterReadGridLayer.js

@@ -36,8 +36,8 @@ export class CellFilterReadGridLayer extends CellFilter {
         // cache required values
         this.__sampler = this.__layer.sampler;
 
-        this.__u_scale = grid.width / this.__sampler.width;
-        this.__v_scale = grid.height / this.__sampler.height;
+        this.__u_scale = this.__sampler.width / grid.width;
+        this.__v_scale = this.__sampler.height / grid.height;
     }
 
     /**

package/generation/filtering/numeric/math/CellFilterSaturate.js

@@ -0,0 +1,24 @@
+import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { assert } from "../../../../core/assert.js";
+
+export class CellFilterSaturate extends CellFilterUnaryOperation {
+    operation(v) {
+        return clamp(v, 0, 1);
+    }
+
+    /**
+     *
+     * @param {CellFilter} v
+     * @return {CellFilterUnaryOperation}
+     */
+    static from(v) {
+        assert.equal(v.isCellFilter, true, "v.isCellFilter !== true");
+
+        const r = new CellFilterSaturate();
+
+        r.source = v;
+
+        return r;
+    }
+}

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

package/samples/terrain/from_image.js

@@ -0,0 +1,289 @@
+import { EngineConfiguration } from "../../engine/EngineConfiguration.js";
+import { EngineHarness } from "../../engine/EngineHarness.js";
+import { GameAssetType } from "../../engine/asset/GameAssetType.js";
+import { TextureAssetLoader } from "../../engine/asset/loaders/texture/TextureAssetLoader.js";
+import Vector3 from "../../core/geom/Vector3.js";
+import EntityBuilder from "../../engine/ecs/EntityBuilder.js";
+import Terrain from "../../engine/ecs/terrain/ecs/Terrain.js";
+import { ImageRGBADataLoader } from "../../engine/asset/loaders/image/ImageRGBADataLoader.js";
+import TerrainSystem from "../../engine/ecs/terrain/ecs/TerrainSystem.js";
+import WaterSystem from "../../engine/graphics/ecs/water/WaterSystem.js";
+import Water from "../../engine/graphics/ecs/water/Water.js";
+import { ThemeEngine } from "../../generation/theme/ThemeEngine.js";
+import { Theme } from "../../generation/theme/Theme.js";
+import { TerrainTheme } from "../../generation/theme/TerrainTheme.js";
+import { AreaTheme } from "../../generation/theme/AreaTheme.js";
+import { GridData } from "../../generation/grid/GridData.js";
+import { TerrainLayerRule } from "../../generation/theme/TerrainLayerRule.js";
+import { TerrainLayerDescription } from "../../generation/theme/TerrainLayerDescription.js";
+import Vector2 from "../../core/geom/Vector2.js";
+import { CellFilterLiteralFloat } from "../../generation/filtering/numeric/CellFilterLiteralFloat.js";
+import { GridDataLayer } from "../../generation/grid/layers/GridDataLayer.js";
+import { CellFilterReadGridLayer } from "../../generation/filtering/numeric/CellFilterReadGridLayer.js";
+import { CellFilterSmoothStep } from "../../generation/filtering/numeric/math/CellFilterSmoothStep.js";
+import { CellFilterOneMinus } from "../../generation/filtering/numeric/math/CellFilterOneMinus.js";
+import { CellFilterMultiply } from "../../generation/filtering/numeric/math/algebra/CellFilterMultiply.js";
+import { CellFilterCurvature } from "../../generation/filtering/numeric/complex/CellFilterCurvature.js";
+import { CellFilterMax2 } from "../../generation/filtering/numeric/math/CellFilterMax2.js";
+import { CellFilterMin2 } from "../../generation/filtering/numeric/math/CellFilterMin2.js";
+import { AmbientOcclusionPostProcessEffect } from "../../engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import { CellFilterAngleToNormal } from "../../generation/filtering/numeric/complex/CellFilterAngleToNormal.js";
+import { CellFilterCache } from "../../generation/filtering/numeric/CellFilterCache.js";
+
+const HEIGHT_RANGE = 100;
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {EngineConfiguration}
+ */
+function makeConfig(engine) {
+    const r = new EngineConfiguration();
+
+    // configure engine here, add systems, loaders etc.
+    r.addLoader(GameAssetType.Texture, new TextureAssetLoader());
+    r.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
+
+
+    r.addSystem(new TerrainSystem(engine.graphics, engine.assetManager));
+    r.addSystem(new WaterSystem(engine.graphics));
+
+    r.addPlugin(AmbientOcclusionPostProcessEffect);
+
+    return r;
+}
+
+function makeTheme() {
+    const theme = new Theme();
+
+
+    const terrainTheme = new TerrainTheme();
+
+    const height = CellFilterReadGridLayer.from('height');
+    const curvature = CellFilterCurvature.from(height);
+
+    const slope = CellFilterAngleToNormal.from(height, Vector3.forward);
+
+    const filterNotVerySharpSlope = CellFilterCache.from(
+        CellFilterOneMinus.from(
+            CellFilterSmoothStep.from(
+                CellFilterLiteralFloat.from(Math.PI / 9),
+                CellFilterLiteralFloat.from(Math.PI / 5),
+                slope
+            )
+        )
+    );
+
+    const main_dress_weights = CellFilterMin2.from(
+        CellFilterSmoothStep.from(
+            CellFilterLiteralFloat.from(0.125 * HEIGHT_RANGE),
+            CellFilterLiteralFloat.from(0.175 * HEIGHT_RANGE),
+            height
+        ),
+        CellFilterOneMinus.from(curvature)
+    );
+
+    terrainTheme.rules.push(
+        // RIVER
+        TerrainLayerRule.from(
+            CellFilterOneMinus.from(
+                CellFilterSmoothStep.from(
+                    CellFilterLiteralFloat.from(0.115 * HEIGHT_RANGE),
+                    CellFilterLiteralFloat.from(0.125 * HEIGHT_RANGE),
+                    height
+                )
+            ),
+            TerrainLayerDescription.from({
+                diffuse: "data/textures/materials/water-pool-texture-seamless-and-free.jpg",
+                size: new Vector2(100, 100)
+            })
+        ),
+        // WET AREAS
+        TerrainLayerRule.from(
+            CellFilterMax2.from(
+                CellFilterMultiply.from(
+                    CellFilterSmoothStep.from(
+                        CellFilterLiteralFloat.from(0.125 * HEIGHT_RANGE),
+                        CellFilterLiteralFloat.from(0.15 * HEIGHT_RANGE),
+                        height
+                    ),
+                    CellFilterOneMinus.from(
+                        CellFilterSmoothStep.from(
+                            CellFilterLiteralFloat.from(0.175 * HEIGHT_RANGE),
+                            CellFilterLiteralFloat.from(0.2 * HEIGHT_RANGE),
+                            height
+                        )
+                    )
+                ),
+                CellFilterSmoothStep.from(
+                    CellFilterLiteralFloat.from(0.2),
+                    CellFilterLiteralFloat.from(0.5),
+                    curvature
+                )
+            ),
+            TerrainLayerDescription.from({
+                diffuse: "data/textures/materials/terrain_township_set/512/Ground_1_dark.png",
+                size: new Vector2(40, 40)
+            })
+        ),
+        // TOP SOIL
+        TerrainLayerRule.from(
+            CellFilterMultiply.from(
+                main_dress_weights,
+                filterNotVerySharpSlope
+            ),
+            TerrainLayerDescription.from({
+                diffuse: "data/textures/materials/terrain_township_set/512/Grass_1.png",
+                size: new Vector2(40, 40)
+            })
+        ),
+        // SLOPE SOIL
+        TerrainLayerRule.from(
+            CellFilterMultiply.from(
+                main_dress_weights,
+                CellFilterOneMinus.from(filterNotVerySharpSlope)
+            ),
+            TerrainLayerDescription.from({
+                diffuse: "data/textures/materials/terrain_township_set/512/Grass_3.png",
+                size: new Vector2(40, 40)
+            })
+        )
+    );
+
+    theme.terrain = terrainTheme;
+
+    return theme;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+    const TERRAIN_SIZE = 256;
+
+    await EngineHarness.buildBasics({
+        engine,
+        enableWater: false,
+        enableTerrain: false,
+        focus: new Vector3(250, 0, 250),
+        yaw: -Math.PI,
+        pitch: 0.91,
+        distance: 770
+    });
+
+    /**
+     *
+     * @type {EntityComponentDataset}
+     */
+    const ecd = engine.entityManager.dataset;
+
+
+    const terrain = new Terrain();
+    terrain.size.set(TERRAIN_SIZE, TERRAIN_SIZE);
+    terrain.resolution = 2;
+    terrain.gridScale = 2;
+    terrain.splat.resize(TERRAIN_SIZE, TERRAIN_SIZE, 1);
+    terrain.splat.fillLayerWeights(0, 255);
+
+    // load height map
+    const asset = await engine.assetManager.promise('moicon/heightmap.png', 'image');
+
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    const sampler = asset.create();
+
+    terrain.samplerHeight.resize(sampler.width, sampler.height);
+    const source_height_data = sampler.data;
+    const sampler_pixel_count = source_height_data.length;
+    const terrain_height_data = terrain.samplerHeight.data;
+
+    let divisor;
+    if (source_height_data instanceof Uint8Array) {
+        divisor = 255;
+    } else if (source_height_data instanceof Uint16Array) {
+        divisor = 65536 - 1;
+    }
+
+    for (let i = 0; i < sampler_pixel_count; i++) {
+        const source_v = source_height_data[i];
+
+        const b0 = source_v & 0xFF;
+        const b1 = (source_v >> 8) & 0xFF;
+
+        let rotated_v;
+        rotated_v = b1 | (b0 << 8);
+
+        if (rotated_v <= 7000) {
+            rotated_v = 0;
+        }
+
+        terrain_height_data[i] = (rotated_v / divisor) * HEIGHT_RANGE
+    }
+
+    const grid = new GridData();
+    grid.resize(TERRAIN_SIZE, TERRAIN_SIZE);
+
+    //inject height map into grid layer
+    const layer = new GridDataLayer();
+    layer.id = 'height';
+
+    grid.addLayer(layer);
+
+    layer.sampler = terrain.samplerHeight;
+
+    const theme_engine = new ThemeEngine();
+
+    const areaTheme = new AreaTheme();
+    areaTheme.theme = makeTheme();
+    areaTheme.mask.resize(grid.width, grid.height);
+    areaTheme.mask.mask.data.fill(255);
+    areaTheme.mask.distanceField.data.fill(0);
+    areaTheme.mask.bounds.set(0, 0, grid.width, grid.height);
+
+    theme_engine.add(areaTheme);
+
+
+    terrain.build(engine.assetManager);
+
+    const water = new Water();
+
+    water.level.set(5);
+    water.shoreDepthTransition.set(0.1, 0.3);
+    water.scattering.set(3);
+
+    new EntityBuilder()
+        .add(terrain)
+        // .add(water)
+        .build(ecd);
+
+    const task = theme_engine.apply(grid, ecd);
+
+    const promise_load = engine.loadSlowTask(task);
+
+    engine.executor.runGroup(task);
+
+    await promise_load;
+
+    await terrain.buildLightMap(1);
+}
+
+/**
+ *
+ * @param {EngineHarness} harness
+ */
+async function init(harness) {
+    const engine = eh.engine;
+
+    await makeConfig(engine).apply(engine);
+
+    await eh.initialize();
+
+    main(engine);
+}
+
+init(eh);