@woosh/meep-engine 2.40.1 → 2.42.0

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

@@ -271,10 +271,10 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRomUV(u, v, channel) {
-        const x = u * (this.width);
-        const y = v * (this.height);
+        const x = u * (this.width - 1);
+        const y = v * (this.height - 1);
 
-        return this.sampleChannelCatmullRom(x - 0.5, y - 0.5, channel);
+        return this.sampleChannelCatmullRom(x, y, channel);
     }
 
     /**
@@ -366,8 +366,8 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelBicubicUV(u, v, channel) {
-        const x = u * (this.width);
-        const y = v * (this.height);
+        const x = u * (this.width - 1);
+        const y = v * (this.height - 1);
 
         return this.sampleChannelBicubic(x - 0.5, y - 0.5, channel);
     }
@@ -511,10 +511,10 @@ export class Sampler2D {
      * @return {number}
      */
     sampleChannelBilinearUV(u, v, channel) {
-        const x = u * (this.width);
-        const y = v * (this.height);
+        const x = u * (this.width - 1);
+        const y = v * (this.height - 1);
 
-        return this.sampleChannelBilinear(x - 0.5, y - 0.5, channel);
+        return this.sampleChannelBilinear(x, y, channel);
     }
 
     /**
@@ -599,8 +599,8 @@ export class Sampler2D {
     }
 
     sampleNearestUV(u, v, result) {
-        const x = Math.round(u * (this.width) - 0.5);
-        const y = Math.round(v * (this.height) - 0.5);
+        const x = Math.round(u * (this.width - 1));
+        const y = Math.round(v * (this.height - 1));
 
         this.read(min2(x, this.width - 1), min2(y, this.height - 1), result);
     }

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/ui/GUIEngine.js

@@ -103,7 +103,14 @@ function GUIEngine() {
         }
     });
 
-    this.view = new EmptyView({ classList: ['gui-engine-root'] });
+    this.view = new EmptyView({
+        classList: ['gui-engine-root'],
+        css: {
+            position: "absolute",
+            left: "0",
+            top: "0"
+        }
+    });
 
     /**
      *

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

package/view/tooltip/gml/parser/readReferenceToken.js

@@ -1,9 +1,9 @@
 import ParserError from "../../../../core/parser/simple/ParserError.js";
-import { skipWhitespace } from "../../../../core/parser/simple/SimpleParser.js";
 import { readReferenceValueToken } from "./readReferenceValueToken.js";
 import { TooltipReferenceValue } from "./TooltipReferenceValue.js";
 import Token from "../../../../core/parser/simple/Token.js";
 import { TooltipTokenType } from "./TooltipTokenType.js";
+import { skipWhitespace } from "../../../../core/parser/simple/skipWhitespace.js";
 
 /**
  *

package/engine/asset/GameAssetManager.js

@@ -1,137 +0,0 @@
-/**
- * Created by Alex on 03/09/2014.
- */
-
-import { sRGBEncoding, TextureLoader as ThreeTextureLoader } from "three";
-
-import { Asset } from "./Asset.js";
-import { computeFileExtension } from "../../core/FilePath.js";
-import { DDSLoader } from "three/examples/jsm/loaders/DDSLoader.js";
-import { ArrayBufferLoader } from "./loaders/ArrayBufferLoader.js";
-import { JsonAssetLoader } from "./loaders/JsonAssetLoader.js";
-import { GameAssetType } from "./GameAssetType.js";
-import { TextAssetLoader } from "./loaders/TextAssetLoader.js";
-import { AnimationGraphDefinitionAssetLoader } from "../graphics/ecs/animation/animator/graph/definition/serialization/AnimationGraphDefinitionAssetLoader.js";
-import { JavascriptAssetLoader } from "./loaders/JavascriptAssetLoader.js";
-import { ImageRGBADataLoader } from "./loaders/image/ImageRGBADataLoader.js";
-import { GLTFAssetLoader } from "./loaders/GLTFAssetLoader.js";
-import { SVGAssetLoader } from "./loaders/SVGAssetLoader.js";
-import { AttachmentSocketsAssetLoader } from "../ecs/sockets/serialization/AttachmentSocketsAssetLoader.js";
-import { FontAssetLoader } from "../../core/font/FontAssetLoader.js";
-import { computeTextureByteSize } from "./loaders/texture/loadStandardImageTexture.js";
-import { TextureAssetLoader } from "./loaders/texture/TextureAssetLoader.js";
-
-
-const textureLoader = new ThreeTextureLoader();
-const ddsLoader = new DDSLoader();
-
-export function deferredTextureLoader(path, success, failure, progress) {
-
-    /**
-     *
-     * @param {Texture} texture
-     */
-    function handleLoad(texture) {
-        const byteSize = computeTextureByteSize(texture);
-
-        asset.byteSize = byteSize;
-
-        pending.forEach(p => {
-            p.image = texture.image;
-            p.mipmaps = texture.mipmaps;
-
-            p.format = texture.format;
-
-            p.needsUpdate = true;
-        });
-
-        isLoaded = true;
-    }
-
-    function loadCompressed() {
-        const texture = ddsLoader.load(path, handleLoad, progress, failure);
-
-        if (texture.mipmaps === undefined) {
-            texture.mipmaps = [];
-        }
-
-        return texture;
-    }
-
-    const pending = [];
-
-    let isLoaded = false;
-
-    //figure out what kind of a texture it is
-    const fileExtension = computeFileExtension(path);
-    if (fileExtension === null) {
-        throw new Error(`no file extension on path '${path}'`);
-    }
-
-    const lowerCaseExtension = fileExtension.toLowerCase();
-
-    let texture;
-
-    switch (lowerCaseExtension) {
-        case  "dds":
-            texture = loadCompressed();
-            break;
-        case "png":
-        case "jpg":
-            texture = textureLoader.load(path, handleLoad, progress, failure);
-            break;
-        default:
-            throw new Error(`Unsupported texture file format: '${lowerCaseExtension}'`);
-
-    }
-
-    texture.encoding = sRGBEncoding;
-
-    const asset = new Asset(function () {
-
-        const clone = texture.clone();
-
-        if (isLoaded) {
-            clone.needsUpdate = true;
-        } else {
-            pending.push(clone);
-        }
-
-        return clone;
-    }, 1);
-
-    success(asset);
-}
-
-
-/**
- *
- * @param {AssetManager} assetManager
- */
-function initAssetManager(assetManager) {
-
-    assetManager.registerLoader(GameAssetType.ModelGLTF, new GLTFAssetLoader());
-    assetManager.registerLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
-    assetManager.registerLoader(GameAssetType.ArrayBuffer, new ArrayBufferLoader());
-    assetManager.registerLoader(GameAssetType.Texture, new TextureAssetLoader());
-    assetManager.registerLoader(GameAssetType.DeferredTexture, deferredTextureLoader);
-
-    assetManager.registerLoader(GameAssetType.JSON, new JsonAssetLoader());
-    assetManager.registerLoader(GameAssetType.Text, new TextAssetLoader());
-
-    assetManager.registerLoader(GameAssetType.JavaScript, new JavascriptAssetLoader());
-
-    assetManager.registerLoader(GameAssetType.Font, new FontAssetLoader());
-
-
-    assetManager.registerLoader(GameAssetType.AnimationGraph, new AnimationGraphDefinitionAssetLoader());
-    assetManager.registerLoader(GameAssetType.AttachmentSockets, new AttachmentSocketsAssetLoader());
-
-    assetManager.registerLoader(GameAssetType.Image, new ImageRGBADataLoader());
-
-    assetManager.registerLoader(GameAssetType.ImageSvg, new SVGAssetLoader());
-}
-
-export {
-    initAssetManager
-};