@woosh/meep-engine 2.41.0 → 2.42.1

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

@@ -6,17 +6,56 @@ import { sampler2D_scale_down_lanczos } from "./sampler2_d_scale_down_lanczos.js
 import { Sampler2D } from "./Sampler2D.js";
 import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
+import LabelView from "../../../../view/common/LabelView.js";
+import EmptyView from "../../../../view/elements/EmptyView.js";
+import { sampler2d_downsample_mipmap } from "./resize/sampler2d_downsample_mipmap.js";
 
 function grid(engine, input, transforms, size = new Vector2(input.width, input.height)) {
 
+    let draw_index = 0;
+
     for (let i = 0; i < transforms.length; i++) {
         const out = input.clone();
 
         out.resize(size.x, size.y);
 
-        transforms[i](out, input);
+        const params = {
+            label: '',
+            skip: false
+        };
+
+        try {
+            transforms[i](out, input, params);
+        } catch (e) {
+            // error, skip
+        }
+
+        if (params.skip) {
+            continue;
+        }
+
+
+        const view = display(engine, out, draw_index * (size.x + 4), 0);
+
+        if (params.label.length > 0) {
+            view.addChild(new LabelView(params.label, {
+                css: {
+                    position: 'absolute',
+                    fontFamily: 'sans-serif',
+                    fontWeight: 'bold',
+                    top: 0,
+                    left: 0,
+                    zIndex: 1,
+                    color: '#000000',
+                    textShadow: '1px 1px 1px white',
+                    background: 'rgba(255,255,255,0.7)',
+                    padding: '2px'
+                }
+            }));
+        }
+
+        draw_index++;
 
-        display(engine, out, i * (size.x + 4), 0);
     }
 
 }
@@ -30,11 +69,23 @@ function display(engine, sampler, x = 0, y = 0) {
 
     view.css({
         position: 'absolute',
-        top: `${y}px`,
-        left: `${x}px`
+        top: "0",
+        left: "0"
     });
 
-    engine.gameView.addChild(view);
+    const container = new EmptyView({
+        css: {
+            position: 'absolute',
+            top: `${y}px`,
+            left: `${x}px`
+        }
+    });
+    container.size.set(sampler.width, sampler.height);
+    container.addChild(view);
+
+    engine.gameView.addChild(container);
+
+    return container;
 }
 
 
@@ -44,7 +95,13 @@ new EngineHarness().initialize({
     }
 }).then(async engine => {
 
-    const asset = await engine.assetManager.promise("data/textures/utility/Lenna.png", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/utility/Lenna.png", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/utility/uv_map_reference.jpg", 'image');
+    const asset = await engine.assetManager.promise("data/textures/utility/image018.jpg", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/utility/TESTIMAGES/SAMPLING/8BIT/RGB/2448x2448/SRC/img_2448x2448_3x8bit_SRC_RGB_clips.png", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/utility/TESTIMAGES/SAMPLING/8BIT/RGB/2448x2448/SRC/img_2448x2448_3x8bit_SRC_RGB_coins.png", 'image');
+    // const asset = await engine.assetManager.promise("data/models/LowPolyTownshipSet/Small_house/diffuse_512.png", 'image');
+    // const asset = await engine.assetManager.promise("data/models/LowPolyTownshipSet/Barrel/diffuse_256.png", 'image');
     // const asset = await engine.assetManager.promise("data/textures/utility/resolver.jpeg", 'image');
     // const asset = await engine.assetManager.promise("data/textures/icons/500_skill_icons_02/Skill_nobg/skill_492_noBG.png", 'image');
     // const asset = await engine.assetManager.promise("data/textures/utility/sampling-test.png", 'image');
@@ -88,7 +145,9 @@ new EngineHarness().initialize({
 
 function test_sampling(source, engine) {
     grid(engine, source, [
-        (out, input) => {
+        (out, input, params) => {
+            params.label = 'Nearest';
+
             const sample = [];
             for (let y = 0; y < out.height; y++) {
 
@@ -100,7 +159,11 @@ function test_sampling(source, engine) {
                 }
             }
         },
-        (out, input) => {
+        (out, input, params) => {
+
+            params.label = 'Bilinear';
+            params.skip = true;
+
             const sample = new Uint8ClampedArray(4);
             for (let y = 0; y < out.height; y++) {
 
@@ -112,7 +175,10 @@ function test_sampling(source, engine) {
                 }
             }
         },
-        (out, input) => {
+        (out, input, params) => {
+            params.label = 'Bicubic';
+            params.skip = true;
+
             const sample = new Uint8ClampedArray(4);
             for (let y = 0; y < out.height; y++) {
 
@@ -124,7 +190,10 @@ function test_sampling(source, engine) {
                 }
             }
         },
-        (out, input) => {
+        (out, input, params) => {
+            params.label = 'catmull-rom';
+            params.skip = true;
+
             const sample = new Uint8ClampedArray(4);
             for (let y = 0; y < out.height; y++) {
 
@@ -135,9 +204,46 @@ function test_sampling(source, engine) {
                     out.set(x, y, sample);
                 }
             }
+        },
+        (out, input, params) => {
+            params.label = 'mip';
+
+
+            sampler2d_downsample_mipmap(input, out);
+
+        },
+        (out, input, params) => {
+            const lobes = 2;
+            params.label = `lanczos_${lobes}`;
+            params.skip = true;
+
+            return;
+
+            sampler2D_scale_down_lanczos(input, out, lobes);
+
+        },
+        (out, input, params) => {
+            const lobes = 3;
+            params.label = `lanczos_${lobes}`;
+
+
+            sampler2D_scale_down_lanczos(input, out, lobes);
+
+        },
+        (out, input, params) => {
+            const lobes = 5;
+            params.skip = true;
+            params.label = `lanczos_${lobes}`;
+
+            return;
+
+            sampler2D_scale_down_lanczos(input, out, lobes);
+
         }
     ], new Vector2(
-        200, 200
+        // 100, 100
+        1024, 1024
+        // 136, 136
     ));
 }
 

package/engine/graphics/texture/sampler/resize/sampler2d_downsample_mipmap.js

@@ -0,0 +1,66 @@
+import { Sampler2D } from "../Sampler2D.js";
+import { sampler2D_scale_down_linear } from "../sampler2D_scale_down_linear.js";
+import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
+import { lerp } from "../../../../../core/math/lerp.js";
+
+/**
+ * Emulated how downsampling is done in OpenGL using autogenerated mipmaps with LINEAR_MIPMAP_LINEAR parameters
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ */
+export function sampler2d_downsample_mipmap(source, destination) {
+    let current_mip = source;
+    let previous_mip = source;
+
+    const itemSize = current_mip.itemSize;
+
+    const dest_width = destination.width;
+    const dest_height = destination.height;
+
+    while (current_mip.width > dest_width && current_mip.width > 1) {
+        const new_w = Math.floor(current_mip.width * 0.5);
+        const new_h = Math.floor(current_mip.height * 0.5);
+
+
+        const out = new Sampler2D(new current_mip.data.constructor(new_w * new_h * itemSize), itemSize, new_w, new_h);
+
+        sampler2D_scale_down_linear(current_mip, out);
+
+        previous_mip = current_mip;
+        current_mip = out;
+    }
+
+    const mip_mix = inverseLerp(previous_mip.width, current_mip.width, dest_width);
+
+    const m1_hp_x = 0.5 / previous_mip.width;
+    const m1_hp_y = 0.5 / previous_mip.height;
+
+    const m0_hp_x = 0.5 / current_mip.width;
+    const m0_hp_y = 0.5 / current_mip.height;
+
+    const m1_sx = (previous_mip.width + 1) / (previous_mip.width);
+    const m1_sy = (previous_mip.height + 1) / (previous_mip.height);
+
+    const m0_sx = (current_mip.width + 1) / (current_mip.width);
+    const m0_sy = (current_mip.height + 1) / (current_mip.height);
+
+    for (let y = 0; y < dest_height; y++) {
+        const v = y / (dest_height - 1);
+
+        for (let x = 0; x < dest_width; x++) {
+
+            const u = x / (dest_width - 1);
+
+            for (let i = 0; i < itemSize; i++) {
+
+                const c0 = previous_mip.sampleChannelBilinearUV(u * m1_sx - m1_hp_x, v * m1_sy - m1_hp_y, i);
+                const c1 = current_mip.sampleChannelBilinearUV(u * m0_sx - m0_hp_x, v * m0_sy - m0_hp_y, i);
+
+                const c_out = lerp(c0, c1, mip_mix);
+
+                destination.data[(y * dest_width + x) * itemSize + i] = c_out;
+            }
+        }
+    }
+
+}

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

@@ -77,12 +77,12 @@ export function sampler2D_scale_down_lanczos(source, destination, lobes = 3) {
 
     for (v = 0; v < d_h; v++) {
 
-        const center_y = (v) * ratio_y;
+        const center_y = (v) * ratio_y - 0.5;
         const source_y0 = max2(Math.ceil(center_y - range2_y), 0);
         const source_y1 = min2(Math.floor(center_y + range2_y), source_height - 1);
 
         for (u = 0; u < d_w; u++) {
-            const center_x = (u) * ratio_x;
+            const center_x = (u) * ratio_x - 0.5;
 
             const source_x0 = max2(Math.ceil(center_x - range2_x), 0);
             const source_x1 = min2(Math.floor(center_x + range2_x), source_width - 1);

package/engine/intelligence/behavior/util/RotationBehavior.js

@@ -0,0 +1,69 @@
+import { EntityBehavior } from "../ecs/EntityBehavior.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+
+export class RotationBehavior extends EntityBehavior {
+    constructor() {
+        super();
+
+        /**
+         * Rotation per second
+         * @type {Vector3}
+         */
+        this.axis = new Vector3();
+        this.speed = 1;
+
+        this.angle = 0;
+
+        this.__offset = new Quaternion();
+    }
+
+    static fromJSON(j) {
+        const r = new RotationBehavior();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param axis
+     * @param speed
+     * @param angle
+     */
+    fromJSON({ axis = Vector3.up, speed = 1, angle = 0 }) {
+        this.axis.fromJSON(axis);
+        this.speed = speed;
+        this.angle = angle;
+    }
+
+    initialize(context) {
+        super.initialize(context);
+
+
+        const transform = this.ecd.getComponent(this.entity, Transform);
+        this.__offset.copy(transform.rotation);
+    }
+
+    tick(timeDelta) {
+        /**
+         *
+         * @type {Transform}
+         */
+        const transform = this.ecd.getComponent(this.entity, Transform);
+
+        const angleDelta = this.speed * timeDelta;
+
+        this.angle += angleDelta;
+
+        const r = transform.rotation;
+
+        r.fromAxisAngle(this.axis, this.angle);
+        r.multiplyQuaternions(r, this.__offset);
+
+        return BehaviorStatus.Running;
+    }
+}

package/generation/example/filters/SampleGroundMoistureFilter.js

@@ -9,8 +9,8 @@ import { CellFilterMax2 } from "../../filtering/numeric/math/CellFilterMax2.js";
 import { CellFilterSmoothStep } from "../../filtering/numeric/math/CellFilterSmoothStep.js";
 import { MohGridLayers } from "../../../../../generator/MohGridLayers.js";
 import { CellFilterDilate } from "../../filtering/numeric/complex/CellFilterDilate.js";
-import { DEG2RAD } from "three/src/math/MathUtils.js";
 import { CellFilterCache } from "../../filtering/numeric/CellFilterCache.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
 
 const fReadHeight = CellFilterSampleLayerLinear.from(MirGridLayers.Heights);
 
@@ -27,8 +27,8 @@ export const SampleGroundMoistureFilter = CellFilterMax2.from(
             CellFilterMax2.from(
                 // flat areas are more likely to be keep moisture
                 CellFilterSmoothStep.from(
-                    CellFilterLiteralFloat.from(40 * DEG2RAD),
-                    CellFilterLiteralFloat.from(10 * DEG2RAD),
+                    CellFilterLiteralFloat.from(40 * DEG_TO_RAD),
+                    CellFilterLiteralFloat.from(10 * DEG_TO_RAD),
                     SLOPE
                 ),
                 // water accumulates in crevices
@@ -60,8 +60,8 @@ export const SampleGroundMoistureFilter = CellFilterMax2.from(
                      NOTE: we don't have to worry about directly of the slope, as water always starts at 0, so any slope will be positive in effect
                      */
                     CellFilterSmoothStep.from(
-                        CellFilterLiteralFloat.from(35 * DEG2RAD),
-                        CellFilterLiteralFloat.from(10 * DEG2RAD),
+                        CellFilterLiteralFloat.from(35 * DEG_TO_RAD),
+                        CellFilterLiteralFloat.from(10 * DEG_TO_RAD),
                         SLOPE
                     ),
                 )

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