@woosh/meep-engine 2.75.7 → 2.75.8

package/src/engine/graphics/texture/virtual/page/TilePage.js

@@ -1,148 +0,0 @@
-import Vector2 from "../../../../../core/geom/Vector2.js";
-import { Cache } from "../../../../../core/cache/Cache.js";
-import { TilePageSlot } from "./TilePageSlot.js";
-
-function TilePage() {
-    this.size = new Vector2(0, 0);
-    this.capacity = 0;
-    this.emptySlots = [];
-
-    this.padding = 0;
-
-    this.queueWrite = [];
-
-    const self = this;
-
-    /**
-     *
-     * @type {Cache.<Tile, TilePageSlot>}
-     */
-    this.active = new Cache({
-        keyWeigher: function () {
-            return 0;
-        },
-        valueWeigher: function () {
-            return 1;
-        },
-        removeListener: function (tile, slot) {
-            slot.empty();
-            self.emptySlots.push(slot);
-
-            //remove from write queue
-            const i = self.queueWrite.indexOf(slot);
-            if (i !== -1) {
-                self.queueWrite.splice(i, 1);
-            }
-        }
-    });
-
-}
-
-TilePage.prototype.init = function (pageResolution, tileResolution, padding = 4) {
-    this.padding = padding;
-
-    //compute size of the page in tiles
-    this.size.set(Math.floor(pageResolution.x / (tileResolution.x + padding * 2)), Math.floor(pageResolution.y / (tileResolution.y + padding * 2)));
-
-    //figure out how many tiles we can hold
-    this.capacity = this.size.x * this.size.y;
-
-    //empty out write queue
-    this.queueWrite = [];
-
-    //create slots
-    this.emptySlots = [];
-
-    for (let x = 0; x < this.size.x; x++) {
-        for (let y = 0; y < this.size.y; y++) {
-            const slot = new TilePageSlot();
-            slot.position.set(x, y);
-            this.emptySlots.push(slot);
-        }
-    }
-
-
-    this.active.drop();
-    this.active.setMaxWeight(this.capacity);
-};
-
-
-/**
- * Get a slot with best matching tile, if requested tile is not found, its closest mip ancestor will be returned, if no mip ancestor exists - null will be returned
- * @param {number} x
- * @param {number} y
- * @param {number} mip
- * @returns {TilePageSlot}
- */
-TilePage.prototype.getBestTile = function (x, y, mip) {
-    /**
-     *
-     * @type {TilePageSlot|null}
-     */
-    let best = null;
-
-    for (let [tile, slot] of this.active) {
-        //check if it's a tile we are interested in
-        const address = tile.address;
-        if (address._includes(x, y, mip)) {
-            if (best === null || address.mip < best.tile.address.mip) {
-
-                best = slot;
-
-                if (tile.address.mip === mip) {
-                    //found exact match
-                    break;
-                }
-            }
-        }
-    }
-
-    return best;
-};
-
-/**
- *
- * @param {Tile} tile
- */
-TilePage.prototype.put = function (tile) {
-    if (this.active.contains(tile)) {
-        return false;
-    } else {
-        if (this.emptySlots.length === 0) {
-            this.active.evictOne();
-        }
-
-        //pick free slot
-        const slot = this.emptySlots.pop();
-        if (slot === undefined) {
-            //something went wrong
-            throw new Error(`Failed to obtain a free page slot`);
-        }
-
-        slot.tile = tile;
-
-        this.active.put(tile, slot);
-
-        //add to write queue
-        this.queueWrite.push(slot);
-    }
-};
-
-TilePage.prototype.update = function () {
-    const queueWrite = this.queueWrite;
-
-    const length = queueWrite.length;
-    for (let i = 0; i < length; i++) {
-        const slot = queueWrite[i];
-        //TODO write slot
-
-        this.sampler.copyWithPadding(slot.tile.sampler, x, y, width, height, padding);
-    }
-
-    //drop the queue
-    this.queueWrite.length = 0;
-};
-
-export {
-    TilePage
-};

package/src/engine/graphics/texture/virtual/page/TilePageSlot.js

@@ -1,36 +0,0 @@
-import Vector2 from "../../../../../core/geom/Vector2.js";
-
-export class TilePageSlot {
-    /**
-     *
-     * @param {number} index
-     * @constructor
-     */
-    constructor(index) {
-        /**
-         * @type {number}
-         */
-        this.index = index;
-        /**
-         * Sequential 2D position of the tile slot on the page
-         * @type {Vector2}
-         */
-        this.position = new Vector2();
-
-        /**
-         *
-         * @type {Tile|null}
-         */
-        this.tile = null;
-
-        this.isWritten = false;
-        this.isDirty = false;
-    }
-
-    empty() {
-        this.tile = null;
-        this.isDirty = this.isWritten;
-        this.isWritten = false;
-    }
-}
-

package/src/engine/graphics/texture/virtual/tile/Tile.js

@@ -1,44 +0,0 @@
-/**
- *
- * @constructor
- * @class
- */
-import { TileAddress } from "./TileAddress.js";
-import { TileStatus } from "./TileStatus.js";
-
-
-export class Tile {
-    constructor() {
-        /**
-         *
-         * @type {TileAddress}
-         */
-        this.address = new TileAddress();
-        /**
-         *
-         * @type {Sampler2D|null}
-         */
-        this.sampler = null;
-        /**
-         *
-         * @type {TileStatus}
-         */
-        this.status = TileStatus.Initial;
-        this.referenceCount = 0;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    byteSize() {
-        const sampler = this.sampler;
-
-        if (sampler === null) {
-            return 0;
-        }
-
-        return sampler.computeByteSize();
-    }
-}
-

package/src/engine/graphics/texture/virtual/tile/Tile.spec.js

@@ -1,11 +0,0 @@
-import { Tile } from "./Tile.js";
-import { TileStatus } from "./TileStatus.js";
-
-test("Tile constructor doesn't throw", () => {
-    new Tile();
-});
-
-test("new tile has Initial status", () => {
-    const tile = new Tile();
-    expect(tile.status).toBe(TileStatus.Initial);
-});

package/src/engine/graphics/texture/virtual/tile/TileAddress.js

@@ -1,63 +0,0 @@
-/**
- * Represents address of a tile in the overall texture pyramid
- */
-export class TileAddress {
-    /**
-     *
-     * @constructor
-     */
-    constructor() {
-        /**
-         * Mip level of the tile
-         * @type {number}
-         */
-        this.mip = 0;
-        /**
-         * X address of the tile, this is a sequential integer
-         * @type {number}
-         */
-        this.x = 0;
-        /**
-         * Y address of the tile, this is a sequential integer
-         * @type {number}
-         */
-        this.y = 0;
-    }
-
-    /**
-     *
-     * @param {TileAddress} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.x === other.x && this.y === other.y && this.mip === other.mip;
-    }
-
-    /**
-     * Returns true if this address is a equal or higher mip level of what requested address
-     * @returns {boolean}
-     */
-    _includes(x, y, mip) {
-        if (this.mip < mip) {
-            //lower level mip
-            return false;
-        }
-        const mipDelta = this.mip - mip;
-
-        const expectedX = x << mipDelta;
-
-        if (this.x !== expectedX) {
-            return false;
-        }
-
-        const expectedY = y << mipDelta;
-
-        if (this.y !== expectedY) {
-            return false;
-        }
-
-        //match
-        return true;
-    }
-}
-

package/src/engine/graphics/texture/virtual/tile/TileAddress.spec.js

@@ -1,30 +0,0 @@
-import { TileAddress } from "./TileAddress.js";
-
-test("TileAddress equals works correctly", () => {
-    const a = new TileAddress();
-    const b = new TileAddress();
-
-    expect(a.equals(b)).toBeTruthy();
-
-    a.x = 1;
-    a.y = 3;
-    a.mip = 7;
-
-    expect(a.equals(b)).toBeFalsy();
-    expect(b.equals(a)).toBeFalsy();
-
-    b.x = 1;
-
-    expect(a.equals(b)).toBeFalsy();
-    expect(b.equals(a)).toBeFalsy();
-
-    b.y = 3;
-
-    expect(a.equals(b)).toBeFalsy();
-    expect(b.equals(a)).toBeFalsy();
-
-    b.mip = 7;
-
-    expect(a.equals(b)).toBeTruthy();
-    expect(b.equals(a)).toBeTruthy();
-});

package/src/engine/graphics/texture/virtual/tile/TileLoader.js

@@ -1,178 +0,0 @@
-/**
- *
- * @constructor
- */
-import { Tile } from "./Tile.js";
-import { TileStatus } from "./TileStatus.js";
-import { TileRequest } from "./TileRequest.js";
-import { assert } from "../../../../../core/assert.js";
-
-
-export class TileLoader {
-    /**
-     *
-     * @param {AssetManager} assetManager
-     */
-    constructor(assetManager) {
-        assert.defined(assetManager, 'assetManager');
-        assert.notNull(assetManager, 'assetManager');
-        assert.equal(assetManager.isAssetManager, true, 'assetManager.isAssetManager !== true');
-
-        /**
-         * @type {AssetManager}
-         */
-        this.assetManager = assetManager;
-        /**
-         * number of tiles to be loaded concurrently
-         * @type {number}
-         */
-        this.concurrency = 3;
-
-        /**
-         * Set of tiles that are currently being loaded
-         * @type {Set<TileRequest>}
-         */
-        this.pending = new Set();
-
-        /**
-         * Requested tiles that are not yet being loaded
-         * @type {TileRequest[]}
-         */
-        this.queue = [];
-    }
-
-    /**
-     *
-     * @param {TileAddress} address
-     */
-    promote(address) {
-        const i = this.indexOfQueueRequestByTile(address);
-        if (i === -1) {
-            //couldn't find, nothing to do
-            return;
-        }
-        //cut and put in the front
-        const requests = this.queue.splice(i, 1);
-        this.queue.unshift(requests[0]);
-    }
-
-    /**
-     *
-     * @param {TileAddress} address
-     * @returns {number}
-     */
-    indexOfQueueRequestByTile(address) {
-        const queue = this.queue;
-        const l = queue.length;
-        for (let i = 0; i < l; i++) {
-            const request = queue[i];
-            const tile = request.tile;
-            if (tile.address.equals(address)) {
-                return i;
-            }
-        }
-
-        return -1;
-    }
-
-    /**
-     *
-     * @param {TileAddress} address
-     * @returns {boolean}
-     */
-    remove(address) {
-        const i = this.indexOfQueueRequestByTile(address);
-        if (i !== -1) {
-            this.queue.splice(i, 1);
-            return true;
-        } else {
-            //TODO check pending queue, cancel load
-        }
-    }
-
-    /**
-     *
-     * @param {Tile} tile
-     * @param {function(tile:Tile)} successCallback
-     * @param {function(tile:Tile)} failureCallback
-     */
-    add(tile, successCallback, failureCallback) {
-        for (let request of this.pending) {
-            if (request.tile.address.equals(tile.address)) {
-                //tile is already being loaded
-                request.attach(successCallback, failureCallback);
-                return;
-            }
-        }
-
-        tile.status = TileStatus.Queued;
-
-        const request = new TileRequest(tile, successCallback, failureCallback);
-
-        this.queue.push(request);
-        this.prod();
-    }
-
-    /**
-     * Initialize loading of a tile
-     * @param {TileRequest} request
-     */
-    load(request) {
-        this.pending.add(request);
-
-        const tile = request.tile;
-        const url = tileToURL(tile);
-        tile.status = TileStatus.Loading;
-
-        const self = this;
-
-        function loadFinished() {
-            self.pending.delete(request);
-            self.prod();
-        }
-
-        function success(asset) {
-            tile.status = TileStatus.Loaded;
-            tile.sampler = asset.create();
-
-            request.successCallbacks.forEach(function (cb) {
-                cb(tile);
-            });
-
-            loadFinished();
-        }
-
-        function failure() {
-            //oh well?
-            request.failureCallbacks.forEach(function (cb) {
-                cb(tile);
-            });
-
-            loadFinished();
-        }
-
-        //do load
-        this.assetManager.get({ path: 'image', type: url, callback: success, failure: failure });
-    }
-
-    /**
-     * Attempt to start loading another tile as long as it's within the concurrency limit, otherwise does nothing
-     * @private
-     */
-    prod() {
-        while (this.pending < this.concurrency) {
-            const request = this.queue.shift();
-            this.load(request);
-        }
-    }
-}
-
-/**
- * Constructs a tile URL
- * @param {Tile} tile
- * @returns {string}
- */
-function tileToURL(tile) {
-    const address = tile.address;
-    return `${address.mip}$${address.x}_${address.y}`;
-}

package/src/engine/graphics/texture/virtual/tile/TileRequest.js

@@ -1,40 +0,0 @@
-/**
- * Representation of a load request for a virtual texture tile
- */
-export class TileRequest {
-    /**
-     *
-     * @param {Tile} tile
-     * @param successCallback
-     * @param failureCallback
-     */
-    constructor(tile, successCallback, failureCallback) {
-        /**
-         *
-         * @type {Tile}
-         */
-        this.tile = tile;
-
-        /**
-         *
-         * @type {Function[]}
-         */
-        this.successCallbacks = [successCallback];
-
-        /**
-         *
-         * @type {Function[]}
-         */
-        this.failureCallbacks = [failureCallback];
-    }
-
-    /**
-     *
-     * @param {function} success
-     * @param {function} failure
-     */
-    attach(success, failure) {
-        this.successCallbacks.push(success);
-        this.failureCallbacks.push(failure);
-    }
-}

package/src/engine/graphics/texture/virtual/tile/TileStatus.js

@@ -1,10 +0,0 @@
-/**
- *
- * @enum {number}
- */
-export const TileStatus = {
-    Initial: 0,
-    Queued: 1,
-    Loading: 2,
-    Loaded: 3
-};