@woosh/meep-engine 2.50.2 → 2.51.0

package/src/engine/graphics/texture/sampler/sampler2d_make_array_filler_function.js

@@ -1,65 +0,0 @@
-/**
- *
- * @param {Sampler2D} sampler
- * @param {number} scale
- * @param {number} offset
- * @return {function(index:int, array:ArrayLike, x:int, y:int)}
- */
-export function sampler2d_make_array_filler_function(sampler, scale=255, offset=0){
-
-    const v4 = [1 / scale, 1 / scale, 1 / scale, 1 / scale];
-
-    //
-    function fillDD1(index, array, x, y) {
-        const val = (sampler.sampleChannelBilinear(x, y, 0) + offset) * scale | 0;
-        array[index] = val;
-        array[index + 1] = val;
-        array[index + 2] = val;
-        array[index + 3] = 255;
-    }
-
-    function fillDD2(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4, 0);
-        const val = (v4[0] + offset) * scale | 0;
-        array.fill(val, index, index + 3);
-        array[index + 3] = (v4[1] + offset) * scale | 0;
-    }
-
-    function fillDD3(index, array, x, y) {
-
-        sampler.sampleBilinear(x, y, v4, 0);
-
-        array[index] = (v4[0] + offset) * scale | 0;
-        array[index + 1] = (v4[1] + offset) * scale | 0;
-        array[index + 2] = (v4[2] + offset) * scale | 0;
-        array[index + 3] = 255;
-    }
-
-    function fillDD4(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4, 0);
-        array[index] = (v4[0] + offset) * scale | 0;
-        array[index + 1] = (v4[1] + offset) * scale | 0;
-        array[index + 2] = (v4[2] + offset) * scale | 0;
-        array[index + 3] = (v4[3] + offset) * scale | 0;
-    }
-
-    let fillDD;
-    switch (sampler.itemSize) {
-        case 1:
-            fillDD = fillDD1;
-            break;
-        case 2:
-            fillDD = fillDD2;
-            break;
-        case 3:
-            fillDD = fillDD3;
-            break;
-        case 4:
-            fillDD = fillDD4;
-            break;
-        default :
-            throw new Error("unsupported item size");
-            break;
-    }
-    return fillDD;
-}

package/src/engine/graphics/texture/sampler/sampler2d_scale_down_linear.spec.js

@@ -1,17 +0,0 @@
-import { Sampler2D } from "./Sampler2D.js";
-import { sampler2d_scale_down_linear } from "./sampler2d_scale_down_linear.js";
-
-test('2x2 -> 1x1 2x channel', () => {
-    const input = Sampler2D.float32(2, 2, 2);
-    const output = Sampler2D.float32(2, 1, 1);
-
-    input.set(0, 0, [1, 3]);
-    input.set(1, 0, [5, 7]);
-    input.set(0, 1, [11, 13]);
-    input.set(1, 1, [17, 19]);
-
-    sampler2d_scale_down_linear(input, output);
-
-    expect(output.data[0]).toEqual(8.5);
-    expect(output.data[1]).toEqual(10.5);
-});

package/src/engine/graphics/trail/x/simulator/RibbonState.js

@@ -1,10 +0,0 @@
-export class RibbonState {
-    constructor() {
-
-        /**
-         *
-         * @type {RibbonX}
-         */
-        this.ribbon = null;
-    }
-}

package/src/engine/grid/Grid.js

@@ -1,131 +0,0 @@
-/**
- * Created by Alex on 13/10/2014.
- */
-import GridField from '../navigation/grid/GridField.js';
-import Vector2 from '../../core/geom/Vector2.js';
-import Vector3 from "../../core/geom/Vector3.js";
-
-const Grid = function () {
-    let gridScale = 2;
-    let gridScaleX = gridScale;
-    let gridScaleY = gridScale;
-
-    this.size = new Vector2();
-    this.field = null;
-
-    this.init = function (width, height, worldScale) {
-        if (worldScale === undefined) {
-            worldScale = 2;
-        }
-        gridScale = worldScale;
-        this.field = new GridField(width, height);
-        this.size.set(width, height);
-
-        updateGridScale(width, height);
-    };
-
-    function updateGridScale(width, height) {
-        //scale is not exact as number of points in the mesh will be greater by 1 than number of tiles, for obvious reasons.
-        gridScaleX = gridScale * (width / (width - 1));
-        gridScaleY = gridScale * (height / (height - 1));
-    }
-
-    this.resize = function (width, height) {
-        const oldSize = this.size;
-
-        if (oldSize.x !== width || oldSize.y !== height) {
-            const newField = new GridField(width, height);
-            updateGridScale(width, height);
-            //copy values from old field to new one
-            if (this.field !== null) {
-                this.field.rectTraverse(0, 0, oldSize.x, oldSize.y, function (x, y, value) {
-                    newField.pointSet(x, y, value);
-                });
-            }
-
-            this.field = newField;
-            this.size.set(width, height);
-        }
-    };
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {Vector3} resultV3
-     */
-    function pointGrid2World2(x, y, resultV3) {
-        resultV3.x = (x) * gridScaleX;
-        resultV3.z = (y) * gridScaleY;
-    }
-
-    /**
-     *
-     * @param {Vector3} v3
-     * @param {Vector2} resultV2
-     */
-    function pointWorld2Grid(v3, resultV2) {
-        resultV2.x = v3.x / gridScaleX;
-        resultV2.y = v3.z / gridScaleY;
-    }
-
-    this.pointWorld2Grid = pointWorld2Grid;
-    this.pointGrid2World = pointGrid2World2;
-    const point2 = new Vector2();
-
-    function mapHeightToPath(path, terrain, width, height, callback) {
-        let mappedCount = 0;
-        const l = path.length;
-
-        function mapPoint(p) {
-            terrain.sampleHeight(p.x, p.z, function (y) {
-                p.y = y;
-                if (++mappedCount >= l) {
-                    callback(path);
-                }
-            });
-        }
-
-        for (let i = 0; i < l; i++) {
-            const p = path[i];
-            mapPoint(p);
-        }
-    }
-
-    const self = this;
-    this.findPath = (function () {
-        const start = new Vector2(0, 0);
-        const goal = new Vector2(0, 0);
-
-        /**
-         *
-         * @param {Vector3} from
-         * @param {Vector3} to
-         * @param {number} clearance
-         * @param callback
-         */
-        function findPath(from, to, clearance, callback) {
-            pointWorld2Grid(from, start);
-            start.ceil();
-            pointWorld2Grid(to, goal);
-            goal.ceil();
-            const field = self.field;
-            const indexPath = field.findPath(start, goal, 10000, 0);
-            const path = [];
-            let i, point;
-            for (i = 0; i < indexPath.length; i++) {
-                const index = indexPath[i];
-                field.index2point(index, point2);
-                point = new Vector3(0, 0, 0);
-                pointGrid2World2(point2.x, point2.y, point);
-                path.push(point);
-            }
-            const terrain = self.terrain;
-
-            mapHeightToPath(path, terrain, self.size.x * gridScaleX, self.size.y * gridScaleY, callback);
-        }
-
-        return findPath;
-    })();
-};
-export default Grid;

package/src/engine/navigation/grid/GridField.js

@@ -1,328 +0,0 @@
-import Vector2 from '../../../core/geom/Vector2.js';
-import { clamp } from "../../../core/math/clamp.js";
-import BinaryHeap from '../../../core/collection/heap/BinaryHeap.js';
-import { assert } from "../../../core/assert.js";
-import { gridAStarSearch } from "./AStar.js";
-
-const blockValue = 255;
-
-/**
- * A kind of 2D data texture
- * @deprecated prefer using {@link Sampler2D} instead, as it's more versatile and has wider feature set
- *
- * @param {Number} width
- * @param {Number} height
- * @constructor
- *
- * @property {Number} width
- * @property {Number} height
- * @property {Uint8Array} data
- */
-function GridField(width, height) {
-    this.width = width;
-    this.height = height;
-    this.data = null;
-
-    if (height !== 0 && height !== 0) {
-        const byteSize = height * width;
-        this.data = new Uint8Array(byteSize);
-    }
-
-    const self = this;
-
-    Object.defineProperties(this, {
-        raw: {
-            set: function (val) {
-                console.warn("Deprecated, use .data accessor instead");
-                self.data = val;
-            },
-            get: function () {
-                console.warn("Deprecated, use .data accessor instead");
-                return self.data;
-            }
-        }
-    });
-}
-
-/**
- *
- * @param {Number} value
- */
-GridField.prototype.fill = function (value) {
-    this.data.fill(value);
-};
-
-/**
- *
- * @param {Number} x0
- * @param {Number} y0
- * @param {Number} x1
- * @param {Number} y1
- * @param {function(x:Number,y:Number,value:Number)} callback
- */
-GridField.prototype.rectTraverse = function (x0, y0, x1, y1, callback) {
-    const width = this.width;
-    const height = this.height;
-
-    let x, y;
-
-    x0 = clamp(x0, 0, width - 1);
-    y0 = clamp(y0, 0, height - 1);
-    x1 = clamp(x1, x0, width - 1);
-    y1 = clamp(y1, y0, height - 1);
-
-    for (x = x0; x <= x1; x++) {
-        for (y = y0; y <= y1; y++) {
-            const index = this.point2index(x, y);
-            const value = this.data[index];
-            callback(x, y, value);
-        }
-    }
-};
-
-/**
- *
- * @param {Number} x0
- * @param {Number} y0
- * @param {Number} x1
- * @param {Number} y1
- * @param {Number} value
- */
-GridField.prototype.rectSet = function (x0, y0, x1, y1, value) {
-    let x, y;
-    for (x = x0; x <= x1; x++) {
-        for (y = y0; y <= y1; y++) {
-            this.pointSet(x, y, value);
-        }
-    }
-};
-
-/**
- *
- * @param {Vector2} pos
- */
-GridField.prototype.snapToNearestFreeCell = function (pos) {
-    const self = this;
-    const p = new Vector2().copy(pos).floor();
-    const target = p.clone();
-    const closed = [];
-
-    function score(index) {
-        self.index2point(index, p);
-        return p.distanceSqrTo(target);
-    }
-
-    const open = new BinaryHeap(score);
-    let current = this.point2index(p.x, p.y);
-    open.push(current);
-    const neighbors = [];
-    while (open.size() > 0) {
-        current = open.pop();
-        closed[current] = true;
-        if (this.data[current] !== blockValue) {
-            break;
-        }
-        //add neighbours
-        neighbors.length = 0; //reset
-        this.calcNeighbors(current, neighbors);
-        const numNeighbors = neighbors.length;
-        for (let i = 0; i < numNeighbors; i++) {
-            const n = neighbors[i];
-            if (closed[n] !== void 0) {
-                continue;
-            }
-            open.push(n);
-        }
-    }
-    this.index2point(current, pos);
-};
-
-/**
- *
- * @param {Number} index
- * @param {function(index:Number, x:Number, y:Number)} visitor
- */
-GridField.prototype.traverseNeighbors = function traverseNeighbors(index, visitor) {
-    const width = this.width;
-    const height = this.height;
-
-    const x = index % width;
-    const y = (index / width) | 0;
-
-    if (x > 0) {
-        visitor(index - 1, x, y);
-    }
-    if (x < width - 1) {
-        visitor(index + 1, x, y);
-    }
-    if (y > 0) {
-        visitor(index - width, x, y);
-    }
-    if (y < height - 1) {
-        visitor(index + width, x, y);
-    }
-};
-
-/**
- *
- * @param {Number} x
- * @param {Number} y
- * @returns {Number}
- */
-GridField.prototype.read = function (x, y) {
-    const index = this.point2index(x, y);
-    return this.data[index];
-};
-
-/**
- *
- * @param {Number} x
- * @param {Number} y
- * @param {Number} value
- */
-GridField.prototype.pointAdd = function (x, y, value) {
-    const index = this.point2index(x, y);
-    this.data[index] += value;
-};
-
-/**
- *
- * @param {Number} x
- * @param {Number} y
- * @param {Number} value
- */
-GridField.prototype.pointSet = function (x, y, value) {
-    const index = this.point2index(x, y);
-    this.data[index] = value;
-};
-
-
-/**
- *
- * @param {Number} x
- * @param {Number} y
- * @returns {Number}
- */
-GridField.prototype.point2index = function (x, y) {
-    return x + y * this.width;
-};
-
-/**
- * Paints with additive brush
- * @param {Array.<Number>} bendPointIndexList
- * @param {Number} value
- */
-GridField.prototype.pathAdd = function pathAdd(bendPointIndexList, value) {
-    const indices = bendPointIndexList;
-    const length = indices.length;
-
-    //
-    if (length > 0) {
-        const pCurrent = new Vector2();
-        const pTarget = new Vector2();
-        let dx, dy;
-        this.index2point(indices[0], pCurrent);
-        this.pointAdd(pCurrent.x, pCurrent.y, value);
-        for (let i = 1; i < length; i++) {
-            this.index2point(indices[i], pTarget);
-            dx = pTarget.x - pCurrent.x;
-            dy = pTarget.y - pCurrent.y;
-            if (dx !== 0) {
-                //drop values to multiple of 1
-                dx /= Math.abs(dx);
-                while (pCurrent.x !== pTarget.x) {
-                    pCurrent.x += dx;
-                    this.pointAdd(pCurrent.x, pCurrent.y, value);
-                }
-            }
-            if (dy !== 0) {
-                //drop values to multiple of 1
-                dy /= Math.abs(dy);
-                while (pCurrent.y !== pTarget.y) {
-                    pCurrent.y += dy;
-                    this.pointAdd(pCurrent.x, pCurrent.y, value);
-                }
-            }
-        }
-    }
-};
-
-/**
- *
- * @param {Number} index
- * @param {Vector2} point
- */
-GridField.prototype.index2point = function (index, point) {
-    const width = this.width;
-
-    point.set(index % width, Math.floor(index / width));
-};
-
-/**
- *
- * @param {Number} index
- * @param {Array.<Number>} result
- */
-GridField.prototype.calcNeighbors = function (index, result) {
-    const width = this.width;
-    const height = this.height;
-
-    const x = index % width;
-    const y = (index / width) | 0;
-    if (x > 0) {
-        result.push(index - 1);
-    }
-    if (x < width - 1) {
-        result.push(index + 1);
-    }
-    if (y > 0) {
-        result.push(index - width);
-    }
-    if (y < height - 1) {
-        result.push(index + width);
-    }
-};
-
-
-/**
- *
- * @param {Number} index1
- * @param {Number} index2
- * @returns {Number}
- */
-GridField.prototype.manhattanDistanceByIndices = function (index1, index2) {
-    const width = this.width;
-
-    const x1 = index1 % width;
-    const y1 = Math.floor(index1 / width);
-    //
-    const x2 = index2 % width;
-    const y2 = Math.floor(index2 / width);
-    //
-    const dx = Math.abs(x1 - x2);
-    const dy = Math.abs(y1 - y2);
-    return dx + dy;
-};
-
-/**
- *
- * @param {Vector2} start
- * @param {Vector2} goal
- * @param {Number} crossingPenalty
- * @param {Number} bendPenalty
- * @returns {Number[]} path of indices
- */
-GridField.prototype.findPath = function (start, goal, crossingPenalty, bendPenalty) {
-    assert.notEqual(start, null, 'start is null');
-    assert.notEqual(start, undefined, 'start is undefined');
-
-    assert.notEqual(goal, null, 'goal is null');
-    assert.notEqual(goal, undefined, 'goal is undefined');
-
-    const startIndex = this.point2index(start.x, start.y);
-    const goalIndex = this.point2index(goal.x, goal.y);
-
-    return gridAStarSearch(this.field, this.width, this.height, startIndex, goalIndex, crossingPenalty, bendPenalty, 255);
-};
-
-export default GridField;