@woosh/meep-engine 2.75.6 → 2.75.8

package/src/engine/graphics/texture/virtual/TileTree.js

@@ -1,150 +0,0 @@
-/*
-This is a state representation of virtual texture tiles
- */
-
-
-import { Tile } from "./tile/Tile.js";
-import { TileAddress } from "./tile/TileAddress.js";
-
-class TileTreeNode {
-    /**
-     *
-     * @param {Tile} tile
-     */
-    constructor(tile) {
-        /**
-         *
-         * @type {Tile}
-         */
-        this.tile = tile;
-
-        /**
-         *
-         * @type {TileTreeNode|null}
-         */
-        this.parent = null;
-    }
-}
-
-class TileTreeQuadNode extends TileTreeNode {
-    /**
-     *
-     * @param {Tile} tile
-     */
-    constructor(tile) {
-        super(tile);
-
-        /**
-         *
-         * @type {TileTreeNode|null}
-         */
-        this.topLeft = null;
-
-        /**
-         *
-         * @type {TileTreeNode|null}
-         */
-        this.topRight = null;
-
-        /**
-         *
-         * @type {TileTreeNode|null}
-         */
-        this.bottomLeft = null;
-
-        /**
-         *
-         * @type {TileTreeNode|null}
-         */
-        this.bottomRight = null;
-    }
-}
-
-/**
- *
- * @param {number} mip
- * @param {number} x
- * @param {number} y
- * @returns {Tile}
- */
-function buildEmptyTile(mip, x, y) {
-    const tileAddress = new TileAddress();
-
-    tileAddress.mip = mip;
-    tileAddress.x = x;
-    tileAddress.y = y;
-
-    const tile = new Tile();
-
-    tile.address = tileAddress;
-
-    return tile;
-}
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} mip
- * @param {number} maxMip
- * @param {Vector2} size
- * @returns {TileTreeNode}
- */
-function buildTree(x, y, mip, maxMip,size) {
-    const tile = buildEmptyTile(mip, x, y);
-
-    if (mip === maxMip) {
-        return new TileTreeNode(tile);
-    } else {
-        const node = new TileTreeQuadNode(tile);
-        const childX = x * 2;
-        const childY = y * 2;
-
-        const childMip = mip + 1;
-
-        node.topLeft = buildTree(childX, childY, childMip, maxMip, size);
-        node.topLeft.parent = node;
-
-        if (childX < size.x) {
-            node.topRight = buildTree(childX + 1, childY, childMip, maxMip, size);
-            node.topRight.parent = node;
-
-            if (childY < size.y) {
-                node.bottomLeft = buildTree(childX, childY + 1, childMip, maxMip, size);
-                node.bottomLeft.parent = node;
-
-                node.bottomRight = buildTree(childX + 1, childY + 1, childMip, maxMip, size);
-                node.bottomRight.parent = node;
-            }
-        } else if (childY < size.y) {
-            node.bottomLeft = buildTree(childX, childY + 1, childMip, maxMip, size);
-            node.bottomLeft.parent = node;
-        }
-
-        return node;
-    }
-}
-
-/**
- *
- * @param {Vector2} size
- * @returns {TileTreeQuadNode|TileTreeNode}
- */
-export function buildTileTree(size) {
-
-    const maxMipLevel = Math.ceil(Math.log2(Math.max(size.x, size.y)));
-
-    if (size.x < 1 || size.y < 1) {
-        throw  new Error(`Can't build a tree, size must be at least 1x1, was ${size.x}x${size.y}`);
-    }
-
-    return buildTree(0, 0, 0, maxMipLevel, size);
-}
-
-
-export {
-    TileTreeNode,
-    TileTreeQuadNode
-};
-
-

package/src/engine/graphics/texture/virtual/TileTree.spec.js

@@ -1,58 +0,0 @@
-import { buildTileTree, TileTreeQuadNode } from "./TileTree.js";
-import Vector2 from "../../../../core/geom/Vector2.js";
-
-test("Building a tree with size 0x0 fails", () => {
-    expect(() => buildTileTree(new Vector2(0, 0))).toThrow();
-});
-
-test("Building a tree with size 1x1 produces a single leaf node", () => {
-    const node = buildTileTree(new Vector2(1, 1));
-
-    expect(node instanceof TileTreeQuadNode).toBe(false);
-
-    expect(node.tile).toBeDefined();
-
-    expect(node.tile.address).toBeDefined();
-
-    expect(node.tile.address.x).toBe(0);
-    expect(node.tile.address.y).toBe(0);
-
-    expect(node.tile.address.mip).toBe(0);
-});
-
-test("Building a tree with size 2x2 produced correct tree", () => {
-    const node = buildTileTree(new Vector2(2, 2));
-
-    expect(node instanceof TileTreeQuadNode).toBe(true);
-
-    expect(node.topLeft).toBeDefined();
-    expect(node.topRight).toBeDefined();
-    expect(node.bottomLeft).toBeDefined();
-    expect(node.bottomRight).toBeDefined();
-
-    expect(node.topLeft instanceof TileTreeQuadNode).toBe(false);
-    expect(node.topRight instanceof TileTreeQuadNode).toBe(false);
-    expect(node.bottomLeft instanceof TileTreeQuadNode).toBe(false);
-    expect(node.bottomRight instanceof TileTreeQuadNode).toBe(false);
-
-    expect(node.topLeft.parent).toBe(node);
-    expect(node.topRight.parent).toBe(node);
-    expect(node.bottomLeft.parent).toBe(node);
-    expect(node.bottomRight.parent).toBe(node);
-
-    expect(node.topLeft.tile.address.mip).toEqual(1);
-    expect(node.topLeft.tile.address.x).toEqual(0);
-    expect(node.topLeft.tile.address.y).toEqual(0);
-
-    expect(node.topRight.tile.address.mip).toEqual(1);
-    expect(node.topRight.tile.address.x).toEqual(1);
-    expect(node.topRight.tile.address.y).toEqual(0);
-
-    expect(node.bottomLeft.tile.address.mip).toEqual(1);
-    expect(node.bottomLeft.tile.address.x).toEqual(0);
-    expect(node.bottomLeft.tile.address.y).toEqual(1);
-
-    expect(node.bottomRight.tile.address.mip).toEqual(1);
-    expect(node.bottomRight.tile.address.x).toEqual(1);
-    expect(node.bottomRight.tile.address.y).toEqual(1);
-});

package/src/engine/graphics/texture/virtual/TileUsage.js

@@ -1,137 +0,0 @@
-/**
- * Accelerated Datastructure to track tile usage
- * @constructor
- */
-function TileUsage() {
-    this.data = [];
-}
-
-/**
- *
- * @returns {TileUsage}
- */
-TileUsage.prototype.clone = function () {
-    const result = new TileUsage();
-    result.data = this.data.slice();
-    return result;
-};
-
-/**
- *
- * @param {TileAddress} tileAddress
- * @returns {number}
- */
-TileUsage.prototype.find = function (tileAddress) {
-    let offset = -1;
-    do {
-        offset = this.data.indexOf(tileAddress, offset);
-    } while (offset !== -1 && offset % 2 !== 0);
-
-    return offset;
-};
-
-
-/**
- *
- * @param {TileAddress} tileAddress
- * @returns {number}
- */
-TileUsage.prototype.obtain = function (tileAddress) {
-    const i = this.find(tileAddress);
-    if (i !== -1) {
-        return i;
-    } else {
-        const data = this.data;
-        const result = data.length;
-        data.push(tileAddress, 0);
-        return result;
-    }
-};
-
-TileUsage.prototype.sort = function () {
-    const arr = this.data;
-
-    function quickSort(left, right) {
-        if (left < right) {
-            const pivot = right;
-            const partitionIndex = partition(pivot, left, right);
-
-            //sort left and right
-            quickSort(left, partitionIndex - 1);
-            quickSort(partitionIndex + 1, right);
-        }
-        return arr;
-    }
-
-    function partition(pivot, left, right) {
-        const pivotValue = arr[pivot * 2 + 1];
-        let partitionIndex = left;
-
-        for (let i = left; i < right; i++) {
-            if (arr[i * 2 + 1] < pivotValue) {
-                swap(arr, i, partitionIndex);
-                partitionIndex++;
-            }
-        }
-        swap(arr, right, partitionIndex);
-        return partitionIndex;
-    }
-
-    function swap(arr, i, j) {
-        const i2 = i * 2;
-        const j2 = j * 2;
-
-        const temp0 = arr[i2];
-        const temp1 = arr[i2 + 1];
-
-        arr[i2] = arr[j2];
-        arr[i2 + 1] = arr[j2 + 1];
-
-        arr[j2] = temp0;
-        arr[j2 + 1] = temp1;
-    }
-
-    quickSort(0, this.data.length / 2);
-};
-
-/**
- *
- * @param {function} visitor
- */
-TileUsage.prototype.traverseReverse = function (visitor) {
-    const data = this.data;
-    const length = data.length;
-    for (let i = length - 1; i >= 0; i -= 2) {
-        const continueFlag = visitor(data[i], data[i + 1]);
-        if (continueFlag === false) {
-            return;
-        }
-    }
-};
-
-/**
- *
- * @param {function} visitor
- */
-TileUsage.prototype.traverse = function (visitor) {
-    const data = this.data;
-    const length = data.length;
-    for (let i = 0; i < length; i += 2) {
-        const continueFlag = visitor(data[i], data[i + 1]);
-        if (continueFlag === false) {
-            return;
-        }
-    }
-};
-
-/**
- *
- * @param {TileAddress} tileAddress
- * @param {number} count
- */
-TileUsage.prototype.add = function (tileAddress, count) {
-    const i = this.obtain(tileAddress);
-    this.data[i + 1] += count;
-};
-
-export { TileUsage };

package/src/engine/graphics/texture/virtual/VirtualTexture.js

@@ -1,238 +0,0 @@
-import { Tile } from "./tile/Tile.js";
-import { TileLoader } from "./tile/TileLoader.js";
-import { Cache } from "../../../../core/cache/Cache.js";
-import Vector2 from "../../../../core/geom/Vector2.js";
-import { TilePage } from "./page/TilePage.js";
-import { create32BitCodec } from "../../../../core/binary/32BitEncoder.js";
-import { TileStatus } from "./tile/TileStatus.js";
-import { assert } from "../../../../core/assert.js";
-
-/**
- *
- * @param tileSize
- * @param textureSize
- * @returns {{encode: (function(..value:number): number), decode: (function(number, number[]): void)}}
- */
-function buildAddressEncoder(tileSize, textureSize) {
-    assert.isNumber(tileSize,'tileSize');
-    assert.notNaN(tileSize,'tileSize');
-    assert.isNonNegativeInteger(tileSize,'tileSize');
-
-    assert.isNumber(textureSize,'textureSize');
-    assert.notNaN(textureSize,'textureSize');
-    assert.isNonNegativeInteger(textureSize,'textureSize');
-
-    const numberOfTiles = Math.ceil(textureSize / tileSize);
-    const numberOfMips = Math.ceil(Math.log2(numberOfTiles));
-
-    const bitsPerMip = Math.ceil(Math.log2(numberOfMips));
-    const bitsPerCoordinate = Math.ceil(Math.log2(numberOfTiles));
-
-    return create32BitCodec([bitsPerCoordinate, bitsPerCoordinate, bitsPerMip]);
-}
-
-const BYTES_PER_MEGABYTE = 1024 * 1024;
-
-const DEFAULT_CACHE_SIZE = 100 * BYTES_PER_MEGABYTE;
-
-const DEFAULT_PAGE_SIZE = new Vector2(2048, 2048);
-
-const DEFAULT_PADDING = 4;
-
-export class VirtualTexture {
-    /**
-     *
-     * @param {AssetManager} assetManager
-     * @constructor
-     */
-    constructor(assetManager) {
-        this.addressCodec = null;
-
-
-        /**
-         * Active page cache texture
-         * @type {TilePage}
-         */
-        this.page = new TilePage();
-
-        const loader = this.loader = new TileLoader(assetManager);
-
-        /**
-         *
-         * @type {Cache.<number, Tile>}
-         */
-        this.cache = new Cache({
-            keyWeigher: function (key) {
-                return 8;
-            },
-            valueWeigher: function (tile) {
-                return 1;
-            },
-            removeListener: function (key, value) {
-                loader.remove(value.address);
-            }
-        });
-
-        /**
-         * When a tile is loaded, this bias is used to add portion of tile's usage count to coarser mip level tile.
-         * In effect, it controls likelihood fetching lower resolution mip for a tile. Value should be between 0 and 1, value of 0 means - no bias, value of 1 means - making lower resolution mip at least as likely to get fetched
-         * @type {number}
-         * @private
-         */
-        this.__settingMipBias = 0.7;
-
-        this.maxMipLevel = 0;
-        this.tileResolution = new Vector2(0, 0);
-        this.resolution = new Vector2(0, 0);
-        this.sizeInTiles = new Vector2(0, 0);
-    }
-
-    /**
-     *
-     * @param {number} address
-     * @returns {Tile}
-     */
-    getTile(address) {
-        const cachedTile = this.cache.get(address);
-        if (cachedTile !== null) {
-            return cachedTile;
-        }
-
-        const decodedAddress = [];
-
-        this.addressCodec.decode(address, decodedAddress);
-
-        const [x, y, mip] = decodedAddress;
-
-        //tile is not cached
-        const tile = new Tile();
-        tile.address.x = x;
-        tile.address.y = y;
-        tile.address.mip = mip;
-
-        this.cache.put(address, tile);
-        this.loader.add(tile);
-    }
-
-    /**
-     *
-     * @param {number} [cacheSize] resolution of the cache for tiles
-     * @param {Vector2} [pageSize] size of the texture page
-     * @param {number} [padding]
-     * @param {Vector2} resolution maximum mip-level resolution fo the texture
-     * @param {Vector2} tileResolution resolution or a single tile
-     */
-    init({
-                                                  cacheSize = DEFAULT_CACHE_SIZE,
-                                                  pageSize = DEFAULT_PAGE_SIZE,
-                                                  padding = DEFAULT_PADDING,
-                                                  resolution,
-                                                  tileResolution
-                                              }) {
-        this.resolution.copy(resolution);
-        this.tileResolution.copy(tileResolution);
-
-        //build address codec
-        this.addressCodec = buildAddressEncoder(tileResolution, resolution);
-
-        //initialize cache
-        this.cache.drop();
-        this.cache.setMaxWeight(cacheSize);
-
-        const tileByteSize = tileResolution.x * tileResolution.y * 4;
-        const cacheValueWeigher = new Function('tile', `return ${tileByteSize};`);
-
-        this.cache.setValueWeigher(cacheValueWeigher);
-
-        //initialize page
-        this.page.init(pageSize, tileResolution, padding);
-
-        const sizeInTiles = resolution.clone().divide(tileResolution);
-
-        if (sizeInTiles.x % 1 !== 0 || sizeInTiles.y % 1 !== 0) {
-            throw new Error(`Texture resolution must be a multiple of tile resolution, instead multiples were ${JSON.stringify(sizeInTiles.toJSON())}`);
-        }
-
-        this.sizeInTiles.copy(sizeInTiles);
-        this.maxMipLevel = Math.ceil(Math.log2(Math.max(sizeInTiles.x, sizeInTiles.y)));
-    }
-
-    /**
-     *
-     * @param {TileUsage} input
-     */
-    updateUsage(input) {
-        const usage = input.clone();
-
-        const addressCodec = this.addressCodec;
-
-        const settingMipBias = this.__settingMipBias;
-
-        const maxMipLevel = this.maxMipLevel;
-
-        /**
-         *
-         * @param {number} x
-         * @param {number} y
-         * @param {number} mip
-         * @param {number} count
-         */
-        function registerUsage(x, y, mip, count) {
-            if (mip > maxMipLevel) {
-                //invalid mip, do nothing
-                return;
-            }
-
-            const address = addressCodec.encode(x, y, mip);
-            usage.add(address, count);
-
-            //include earlier levels
-            const x1 = Math.floor(x / 2);
-            const y1 = Math.floor(y / 2);
-            registerUsage(x1, y1, mip + 1, count * settingMipBias);
-        }
-
-        const decodedAddress = [0, 0, 0];
-        input.traverse(function (address, count) {
-
-            //decode address
-            addressCodec.decode(address, decodedAddress);
-
-            const x = decodedAddress[0];
-            const y = decodedAddress[1];
-            const mip = decodedAddress[2];
-
-            //include earlier levels
-            registerUsage(x, y, mip + 1, count * settingMipBias);
-        });
-
-        //we have a collection of pages with usage count at this point
-
-        usage.sort();
-
-
-        let remainingPageSlots = this.page.capacity;
-        const self = this;
-        const page = this.page;
-        usage.traverse(function (address, count) {
-            const tile = self.getTile(address);
-            if (remainingPageSlots > 0 && tile.status === TileStatus.Loaded) {
-                //tile is loaded, put it into page
-                if (page.put(tile)) {
-                    //tile was added into the page
-                    remainingPageSlots--;
-                }
-            }
-        });
-
-        if (remainingPageSlots !== this.page.capacity) {
-            //page was modified
-            this.page.update();
-        }
-
-        //reorder loading queue, put used tiles at the front with most used being foremost
-        usage.traverseReverse(function (address, count) {
-            self.loader.promote(address);
-        });
-    }
-}

package/src/engine/graphics/texture/virtual/VirtualTexture.spec.js

@@ -1,39 +0,0 @@
-import { VirtualTexture } from "./VirtualTexture.js";
-import Vector2 from "../../../../core/geom/Vector2.js";
-
-function mockAssetManager() {
-    const assetManager = {
-        get: function ({ path, type, success, failure }) {
-            const delay = Math.random() * 100;
-            setTimeout(function () {
-                success({
-                    create: function () {
-                        return null;
-                    }
-                });
-            }, delay);
-        },
-        isAssetManager: true
-    };
-
-    return assetManager;
-}
-
-test("constructor doesn't throw", () => {
-    const assetManager = mockAssetManager();
-
-    new VirtualTexture(assetManager)
-});
-
-test.skip("init computes sizes correctly", () => {
-    const assetManager = mockAssetManager();
-
-    const sut = new VirtualTexture(assetManager);
-
-    sut.init({ padding: 4, resolution: new Vector2(16, 3), tileResolution: new Vector2(1, 1) });
-
-    expect(sut.maxMipLevel).toBe(4);
-
-    expect(sut.sizeInTiles.x).toBe(16);
-    expect(sut.sizeInTiles.y).toBe(3);
-});