@itwin/core-orbitgt 4.0.0-dev.7 → 4.0.0-dev.70

package/lib/esm/pointcloud/render/ViewTree.js

@@ -1,360 +1,361 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module OrbitGT
- */
-import { AList } from "../../system/collection/AList";
-import { Message } from "../../system/runtime/Message";
-import { GridIndex } from "../model/GridIndex";
-import { Block } from "./Block";
-/**
- * Class TileSpatialIndex manages a spatial index of levels, blocks and tiles in pointcloud. The index does not store data, only block and tile indexes.
- *
- * @version 1.0 November 2015
- */
-/** @internal */
-export class ViewTree {
-    /**
-     * Create a new tree.
-     * @param levels the levels.
-     * @param dataBounds the data bounds.
-     */
-    constructor(dataManager, levels, dataBounds) {
-        /* Store the parameters */
-        this._dataManager = dataManager;
-        this._levels = levels;
-        this._dataBounds = dataBounds;
-        /* Find the root blocks */
-        this._rootBlocks = this.findRootBlocks();
-    }
-    /**
-     * Find all root blocks (dropping of single-point tiles during pyramid creation can lead to missing branches).
-     * @return all root blocks.
-     */
-    findRootBlocks() {
-        /* Check some levels below the top */
-        let startLevel = (this._levels.length - 6);
-        if (startLevel < 0)
-            startLevel = 0;
-        Message.print(ViewTree.MODULE, "Finding root blocks starting at level index " + startLevel + " of " + this._levels.length);
-        /* Check the levels */
-        let rootBlocks = new AList();
-        let nextLevelIndex = new GridIndex(0, 0, 0);
-        for (let i = startLevel; i < this._levels.length - 1; i++) {
-            /* Check all blocks in the level */
-            let level = this._levels[i];
-            for (let block of level.getBlocks()) {
-                /* Non-top level? */
-                let isRoot = true;
-                if (i < this._levels.length - 2) {
-                    /* Do we have a parent block in the next level? */
-                    block.getBlockIndex().gridIndex.getNextLevelIndex(nextLevelIndex);
-                    isRoot = (this._levels[i + 1].findBlockGridIndex(nextLevelIndex) == null);
-                    if (isRoot)
-                        Message.print(ViewTree.MODULE, "Block L" + i + " " + block.getBlockIndex().gridIndex + " is non-top root");
-                }
-                /* Add to the list? */
-                if (isRoot)
-                    rootBlocks.add(block);
-            }
-        }
-        /* Return the roots */
-        Message.print(ViewTree.MODULE, "Found " + rootBlocks.size() + " root blocks");
-        return rootBlocks;
-    }
-    /**
-     * Get the number of levels.
-     * @return the number of levels.
-     */
-    getLevelCount() {
-        return this._levels.length;
-    }
-    /**
-     * Get a level.
-     * @param index the index of the level.
-     * @return the level.
-     */
-    getLevel(index) {
-        return this._levels[index];
-    }
-    /**
-     * Get the data bounds.
-     * @return the data bounds.
-     */
-    getDataBounds() {
-        return this._dataBounds;
-    }
-    /**
-     * Set the blocks for a level (after a data load operation).
-     * @param level the level.
-     * @param blockIndexes the indexes of the blocks in the level.
-     */
-    setLevelBlocks(level, blockIndexes) {
-        if (blockIndexes == null)
-            return;
-        let blockList = new Array(blockIndexes.length);
-        for (let i = 0; i < blockIndexes.length; i++)
-            blockList[i] = new Block(blockIndexes[i]);
-        level.setBlockList(blockList);
-        Message.print(ViewTree.MODULE, "Loaded " + blockIndexes.length + " blocks for level " + level.getIndex());
-    }
-    /**
-     * Set the tiles for a block (after a data load operation).
-     * @param blockIndex the index of the block.
-     * @param tileIndexes the indexes of the tiles in the block.
-     */
-    setBlockTiles(blockIndex, tileIndexes) {
-        let level = this._levels[blockIndex.level];
-        let block = level.findBlock(blockIndex);
-        block.setTiles(tileIndexes);
-    }
-    /**
-     * Split a tile into lower-level tiles.
-     * @param level the level of the tile to split.
-     * @param tile the tile to split.
-     * @param childLevel the lower level of the tile.
-     * @param children the list of children to split into.
-     * @param levelsToLoad the list of levels to load.
-     * @param blocksToLoad the list of blocks to load.
-     * @return true if the list of children is complete.
-     */
-    splitTile(level, tile, childLevel, children, levelsToLoad, blocksToLoad) {
-        /* Clear the result */
-        children.clear();
-        /* Already calculated? */
-        let childList = tile.children;
-        if (childList != null) {
-            /* Return */
-            for (let child of childList)
-                children.add(child);
-            return true;
-        }
-        /* Assume we have a complete list of children */
-        let complete = true;
-        /* Unloaded level? */
-        if (childLevel.getBlockCount() == 0) {
-            /* No need to continue, we need the level block list */
-            if (levelsToLoad.contains(childLevel) == false)
-                levelsToLoad.add(childLevel);
-            return false;
-        }
-        /* Check the 8 possible child tiles */
-        let index = tile.gridIndex;
-        let childIndex = new GridIndex(0, 0, 0);
-        for (let z = 0; z < 2; z++)
-            for (let y = 0; y < 2; y++)
-                for (let x = 0; x < 2; x++) {
-                    /* Get the index of the child */
-                    childIndex.x = (2 * index.x + x);
-                    childIndex.y = (2 * index.y + y);
-                    childIndex.z = (2 * index.z + z);
-                    /* Find the block */
-                    let block = childLevel.findBlockForTile(childIndex);
-                    if (block == null) {
-                        /* This should not happen */
-                        Message.printWarning(ViewTree.MODULE, "Unable to find tile block " + childIndex + " in child level " + childLevel.getIndex() + " (" + childLevel.getBlockCount() + " blocks)");
-                        complete = false;
-                        continue;
-                    }
-                    /* No tile info in the block? */
-                    if (block.hasTiles() == false) {
-                        /* Load the block data */
-                        if (blocksToLoad.contains(block.getBlockIndex()) == false)
-                            blocksToLoad.add(block.getBlockIndex());
-                        complete = false;
-                    }
-                    else {
-                        /* Find the child */
-                        let child = block.findTile(childIndex);
-                        if (child != null)
-                            children.add(child);
-                    }
-                }
-        /* Store the result if complete */
-        if (complete) {
-            /* Store */
-            let tileChildren = new Array(children.size());
-            for (let i = 0; i < tileChildren.length; i++)
-                tileChildren[i] = children.get(i);
-            tile.children = tileChildren;
-        }
-        /* Do we have all children? */
-        return complete;
-    }
-    /**
-     * Is all tile data available for rendering?
-     * @param viewRequest the view request.
-     * @param tiles a list of tiles to check.
-     * @param missingTiles the list of tiles whose data is missing.
-     */
-    checkDataAvailable(viewRequest, tiles, missingTiles) {
-        /* Check all tiles */
-        missingTiles.clear();
-        for (let i = 0; i < tiles.size(); i++) {
-            /* Get the next tile */
-            let tile = tiles.get(i);
-            /* Not available? */
-            if (this._dataManager.isTileLoaded(tile) == null) {
-                /* Request to load the block */
-                missingTiles.add(tile);
-            }
-            else {
-                /* Touch the block */
-                tile.accessTime = viewRequest.getFrameTime();
-            }
-        }
-    }
-    /**
-     * Is all tile data available for rendering?
-     * @param viewRequest the view request.
-     * @param tiles a list of tiles to check.
-     * @return true if the tile data is available.
-     */
-    isDataAvailable(viewRequest, tiles) {
-        /* Check all tiles */
-        for (let i = 0; i < tiles.length; i++) {
-            /* Get the next tile */
-            let tile = tiles[i];
-            /* Not available? */
-            if (this._dataManager.isTileLoaded(tile) == null)
-                return false;
-        }
-        /* Available */
-        return true;
-    }
-    /**
-     * Add visible tiles to the view.
-     * @param viewRequest the view request.
-     * @param level the level of the tiles.
-     * @param tiles the tiles to check.
-     * @param visibleTiles the list of visible tiles to add to.
-     */
-    addTilesToView(viewRequest, level, tiles, levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender) {
-        /* No tiles? */
-        if (tiles == null)
-            return;
-        /* Make the lists */
-        let childTiles = new AList();
-        let missingChildTiles = new AList();
-        /* Check all tiles */
-        for (let i = 0; i < tiles.length; i++) {
-            /* Get the next tile */
-            let tile = tiles[i];
-            if (ViewTree.DEBUG)
-                Message.print(ViewTree.MODULE, "Checking tile L" + tile.level + " (" + tile.gridIndex.x + "," + tile.gridIndex.y + "," + tile.gridIndex.z + ")");
-            /* Visible? */
-            let tileBounds = level.getTileGrid().getCellBounds(tile.gridIndex).getIntersection(this._dataBounds);
-            if (ViewTree.DEBUG)
-                Message.print(ViewTree.MODULE, "> level " + tile.level);
-            if (viewRequest.isVisibleBox(tileBounds)) {
-                /* Has the tile been loaded? */
-                let tileData = this._dataManager.isTileLoaded(tile);
-                let tileAvailable = (tileData != null);
-                tile.accessTime = viewRequest.getFrameTime();
-                if (ViewTree.DEBUG)
-                    Message.print(ViewTree.MODULE, " > available? " + tileAvailable);
-                /* We load all intermediate tiles to avoid holes in the coverage */
-                if (tileAvailable == false)
-                    tilesToLoad.add(tile);
-                /* Split the tile? */
-                let shouldSplit = (level.getIndex() > 0) && viewRequest.shouldSplit(level, tile);
-                if (shouldSplit) {
-                    if (ViewTree.DEBUG)
-                        Message.print(ViewTree.MODULE, " > visible, but needs splitting");
-                    /* Find the children at the lower level */
-                    let childLevel = this._levels[level.getIndex() - 1];
-                    let completeChildList = this.splitTile(level, tile, childLevel, childTiles, levelsToLoad, blocksToLoad);
-                    if (completeChildList == false) {
-                        if (ViewTree.DEBUG)
-                            Message.print(ViewTree.MODULE, " > loading child indexes");
-                        /* Display the tile while we wait for the block-tiles to load */
-                        if (tileAvailable)
-                            tilesToRender.add(tileData);
-                    }
-                    else {
-                        /* Are all children available with their data? */
-                        this.checkDataAvailable(viewRequest, childTiles, missingChildTiles);
-                        if (missingChildTiles.size() == 0) {
-                            if (ViewTree.DEBUG)
-                                Message.print(ViewTree.MODULE, " > rendering children");
-                            /* Add the children */
-                            let childTiles2 = new Array(childTiles.size());
-                            for (let j = 0; j < childTiles2.length; j++)
-                                childTiles2[j] = childTiles.get(j);
-                            this.addTilesToView(viewRequest, childLevel, childTiles2, levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender);
-                        }
-                        else {
-                            if (ViewTree.DEBUG)
-                                Message.print(ViewTree.MODULE, " > loading children");
-                            /* Request for the missing children to be loaded */
-                            for (let j = 0; j < missingChildTiles.size(); j++)
-                                tilesToLoad.add(missingChildTiles.get(j));
-                            /* Display the tile while we wait for the child tiles to load */
-                            if (tileAvailable)
-                                tilesToRender.add(tileData);
-                        }
-                    }
-                }
-                else {
-                    /* Display the tile */
-                    if (ViewTree.DEBUG)
-                        Message.print(ViewTree.MODULE, " > visible");
-                    if (tileAvailable)
-                        tilesToRender.add(tileData);
-                }
-            }
-            else {
-                /* Log */
-                if (ViewTree.DEBUG)
-                    Message.print(ViewTree.MODULE, " > not visible");
-            }
-        }
-    }
-    /**
-     * Find tile indexes for a 3D view.
-     * @param viewRequest the request parameters.
-     * @param visibleTiles the list of visible tiles to add to.
-     * @param availableTiles the set of available tiles.
-     * @param visibleAvailableTiles the list if visible and available tiles to add to.
-     */
-    renderView3D(viewRequest, levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender) {
-        /* Log? */
-        if (ViewTree.DEBUG)
-            Message.print(ViewTree.MODULE, "Finding pointcloud tiles to render");
-        if (ViewTree.DEBUG)
-            Message.print(ViewTree.MODULE, " > dataBounds: " + this._dataBounds);
-        //if (DEBUG) Message.print(MODULE," > view: "+viewRequest.getViewProjection());
-        //if (DEBUG) Message.print(MODULE," > distance: "+viewRequest.getDistanceRange());
-        //if (DEBUG) Message.print(MODULE," > model-transform: "+viewRequest.getModelTransform());
-        /* Check all blocks */
-        tilesToRender.clear();
-        if (ViewTree.DEBUG)
-            Message.print(ViewTree.MODULE, "Checking " + this._rootBlocks.size() + " root blocks");
-        for (let i = 0; i < this._rootBlocks.size(); i++) // start from the root tiles
-         {
-            /* Visible? */
-            let block = this._rootBlocks.get(i);
-            let blockIndex = block.getBlockIndex();
-            let level = this._levels[blockIndex.level];
-            /* Visible? */
-            if (ViewTree.DEBUG)
-                Message.print(ViewTree.MODULE, "Checking top-level block L" + blockIndex.level + " (" + blockIndex.gridIndex.x + "," + blockIndex.gridIndex.y + "," + blockIndex.gridIndex.z + ")");
-            let blockBounds = block.getBlockBounds(level).getIntersection(this._dataBounds);
-            if (ViewTree.DEBUG)
-                Message.print(ViewTree.MODULE, " > blockBounds: " + blockBounds);
-            if (viewRequest.isVisibleBox(blockBounds)) {
-                /* Add the tiles */
-                if (ViewTree.DEBUG)
-                    Message.print(ViewTree.MODULE, " > visible");
-                this.addTilesToView(viewRequest, level, block.getTiles(blocksToLoad), levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender);
-            }
-        }
-    }
-}
-/** The name of this module */
-ViewTree.MODULE = "ViewTree";
-/** Debug mode? */
-ViewTree.DEBUG = false;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module OrbitGT
+ */
+import { AList } from "../../system/collection/AList";
+import { Message } from "../../system/runtime/Message";
+import { GridIndex } from "../model/GridIndex";
+import { Block } from "./Block";
+/**
+ * Class TileSpatialIndex manages a spatial index of levels, blocks and tiles in pointcloud. The index does not store data, only block and tile indexes.
+ *
+ * @version 1.0 November 2015
+ */
+/** @internal */
+class ViewTree {
+    /**
+     * Create a new tree.
+     * @param levels the levels.
+     * @param dataBounds the data bounds.
+     */
+    constructor(dataManager, levels, dataBounds) {
+        /* Store the parameters */
+        this._dataManager = dataManager;
+        this._levels = levels;
+        this._dataBounds = dataBounds;
+        /* Find the root blocks */
+        this._rootBlocks = this.findRootBlocks();
+    }
+    /**
+     * Find all root blocks (dropping of single-point tiles during pyramid creation can lead to missing branches).
+     * @return all root blocks.
+     */
+    findRootBlocks() {
+        /* Check some levels below the top */
+        let startLevel = (this._levels.length - 6);
+        if (startLevel < 0)
+            startLevel = 0;
+        Message.print(ViewTree.MODULE, "Finding root blocks starting at level index " + startLevel + " of " + this._levels.length);
+        /* Check the levels */
+        let rootBlocks = new AList();
+        let nextLevelIndex = new GridIndex(0, 0, 0);
+        for (let i = startLevel; i < this._levels.length - 1; i++) {
+            /* Check all blocks in the level */
+            let level = this._levels[i];
+            for (let block of level.getBlocks()) {
+                /* Non-top level? */
+                let isRoot = true;
+                if (i < this._levels.length - 2) {
+                    /* Do we have a parent block in the next level? */
+                    block.getBlockIndex().gridIndex.getNextLevelIndex(nextLevelIndex);
+                    isRoot = (this._levels[i + 1].findBlockGridIndex(nextLevelIndex) == null);
+                    if (isRoot)
+                        Message.print(ViewTree.MODULE, "Block L" + i + " " + block.getBlockIndex().gridIndex + " is non-top root");
+                }
+                /* Add to the list? */
+                if (isRoot)
+                    rootBlocks.add(block);
+            }
+        }
+        /* Return the roots */
+        Message.print(ViewTree.MODULE, "Found " + rootBlocks.size() + " root blocks");
+        return rootBlocks;
+    }
+    /**
+     * Get the number of levels.
+     * @return the number of levels.
+     */
+    getLevelCount() {
+        return this._levels.length;
+    }
+    /**
+     * Get a level.
+     * @param index the index of the level.
+     * @return the level.
+     */
+    getLevel(index) {
+        return this._levels[index];
+    }
+    /**
+     * Get the data bounds.
+     * @return the data bounds.
+     */
+    getDataBounds() {
+        return this._dataBounds;
+    }
+    /**
+     * Set the blocks for a level (after a data load operation).
+     * @param level the level.
+     * @param blockIndexes the indexes of the blocks in the level.
+     */
+    setLevelBlocks(level, blockIndexes) {
+        if (blockIndexes == null)
+            return;
+        let blockList = new Array(blockIndexes.length);
+        for (let i = 0; i < blockIndexes.length; i++)
+            blockList[i] = new Block(blockIndexes[i]);
+        level.setBlockList(blockList);
+        Message.print(ViewTree.MODULE, "Loaded " + blockIndexes.length + " blocks for level " + level.getIndex());
+    }
+    /**
+     * Set the tiles for a block (after a data load operation).
+     * @param blockIndex the index of the block.
+     * @param tileIndexes the indexes of the tiles in the block.
+     */
+    setBlockTiles(blockIndex, tileIndexes) {
+        let level = this._levels[blockIndex.level];
+        let block = level.findBlock(blockIndex);
+        block.setTiles(tileIndexes);
+    }
+    /**
+     * Split a tile into lower-level tiles.
+     * @param level the level of the tile to split.
+     * @param tile the tile to split.
+     * @param childLevel the lower level of the tile.
+     * @param children the list of children to split into.
+     * @param levelsToLoad the list of levels to load.
+     * @param blocksToLoad the list of blocks to load.
+     * @return true if the list of children is complete.
+     */
+    splitTile(level, tile, childLevel, children, levelsToLoad, blocksToLoad) {
+        /* Clear the result */
+        children.clear();
+        /* Already calculated? */
+        let childList = tile.children;
+        if (childList != null) {
+            /* Return */
+            for (let child of childList)
+                children.add(child);
+            return true;
+        }
+        /* Assume we have a complete list of children */
+        let complete = true;
+        /* Unloaded level? */
+        if (childLevel.getBlockCount() == 0) {
+            /* No need to continue, we need the level block list */
+            if (levelsToLoad.contains(childLevel) == false)
+                levelsToLoad.add(childLevel);
+            return false;
+        }
+        /* Check the 8 possible child tiles */
+        let index = tile.gridIndex;
+        let childIndex = new GridIndex(0, 0, 0);
+        for (let z = 0; z < 2; z++)
+            for (let y = 0; y < 2; y++)
+                for (let x = 0; x < 2; x++) {
+                    /* Get the index of the child */
+                    childIndex.x = (2 * index.x + x);
+                    childIndex.y = (2 * index.y + y);
+                    childIndex.z = (2 * index.z + z);
+                    /* Find the block */
+                    let block = childLevel.findBlockForTile(childIndex);
+                    if (block == null) {
+                        /* This should not happen */
+                        Message.printWarning(ViewTree.MODULE, "Unable to find tile block " + childIndex + " in child level " + childLevel.getIndex() + " (" + childLevel.getBlockCount() + " blocks)");
+                        complete = false;
+                        continue;
+                    }
+                    /* No tile info in the block? */
+                    if (block.hasTiles() == false) {
+                        /* Load the block data */
+                        if (blocksToLoad.contains(block.getBlockIndex()) == false)
+                            blocksToLoad.add(block.getBlockIndex());
+                        complete = false;
+                    }
+                    else {
+                        /* Find the child */
+                        let child = block.findTile(childIndex);
+                        if (child != null)
+                            children.add(child);
+                    }
+                }
+        /* Store the result if complete */
+        if (complete) {
+            /* Store */
+            let tileChildren = new Array(children.size());
+            for (let i = 0; i < tileChildren.length; i++)
+                tileChildren[i] = children.get(i);
+            tile.children = tileChildren;
+        }
+        /* Do we have all children? */
+        return complete;
+    }
+    /**
+     * Is all tile data available for rendering?
+     * @param viewRequest the view request.
+     * @param tiles a list of tiles to check.
+     * @param missingTiles the list of tiles whose data is missing.
+     */
+    checkDataAvailable(viewRequest, tiles, missingTiles) {
+        /* Check all tiles */
+        missingTiles.clear();
+        for (let i = 0; i < tiles.size(); i++) {
+            /* Get the next tile */
+            let tile = tiles.get(i);
+            /* Not available? */
+            if (this._dataManager.isTileLoaded(tile) == null) {
+                /* Request to load the block */
+                missingTiles.add(tile);
+            }
+            else {
+                /* Touch the block */
+                tile.accessTime = viewRequest.getFrameTime();
+            }
+        }
+    }
+    /**
+     * Is all tile data available for rendering?
+     * @param viewRequest the view request.
+     * @param tiles a list of tiles to check.
+     * @return true if the tile data is available.
+     */
+    isDataAvailable(viewRequest, tiles) {
+        /* Check all tiles */
+        for (let i = 0; i < tiles.length; i++) {
+            /* Get the next tile */
+            let tile = tiles[i];
+            /* Not available? */
+            if (this._dataManager.isTileLoaded(tile) == null)
+                return false;
+        }
+        /* Available */
+        return true;
+    }
+    /**
+     * Add visible tiles to the view.
+     * @param viewRequest the view request.
+     * @param level the level of the tiles.
+     * @param tiles the tiles to check.
+     * @param visibleTiles the list of visible tiles to add to.
+     */
+    addTilesToView(viewRequest, level, tiles, levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender) {
+        /* No tiles? */
+        if (tiles == null)
+            return;
+        /* Make the lists */
+        let childTiles = new AList();
+        let missingChildTiles = new AList();
+        /* Check all tiles */
+        for (let i = 0; i < tiles.length; i++) {
+            /* Get the next tile */
+            let tile = tiles[i];
+            if (ViewTree.DEBUG)
+                Message.print(ViewTree.MODULE, "Checking tile L" + tile.level + " (" + tile.gridIndex.x + "," + tile.gridIndex.y + "," + tile.gridIndex.z + ")");
+            /* Visible? */
+            let tileBounds = level.getTileGrid().getCellBounds(tile.gridIndex).getIntersection(this._dataBounds);
+            if (ViewTree.DEBUG)
+                Message.print(ViewTree.MODULE, "> level " + tile.level);
+            if (viewRequest.isVisibleBox(tileBounds)) {
+                /* Has the tile been loaded? */
+                let tileData = this._dataManager.isTileLoaded(tile);
+                let tileAvailable = (tileData != null);
+                tile.accessTime = viewRequest.getFrameTime();
+                if (ViewTree.DEBUG)
+                    Message.print(ViewTree.MODULE, " > available? " + tileAvailable);
+                /* We load all intermediate tiles to avoid holes in the coverage */
+                if (tileAvailable == false)
+                    tilesToLoad.add(tile);
+                /* Split the tile? */
+                let shouldSplit = (level.getIndex() > 0) && viewRequest.shouldSplit(level, tile);
+                if (shouldSplit) {
+                    if (ViewTree.DEBUG)
+                        Message.print(ViewTree.MODULE, " > visible, but needs splitting");
+                    /* Find the children at the lower level */
+                    let childLevel = this._levels[level.getIndex() - 1];
+                    let completeChildList = this.splitTile(level, tile, childLevel, childTiles, levelsToLoad, blocksToLoad);
+                    if (completeChildList == false) {
+                        if (ViewTree.DEBUG)
+                            Message.print(ViewTree.MODULE, " > loading child indexes");
+                        /* Display the tile while we wait for the block-tiles to load */
+                        if (tileAvailable)
+                            tilesToRender.add(tileData);
+                    }
+                    else {
+                        /* Are all children available with their data? */
+                        this.checkDataAvailable(viewRequest, childTiles, missingChildTiles);
+                        if (missingChildTiles.size() == 0) {
+                            if (ViewTree.DEBUG)
+                                Message.print(ViewTree.MODULE, " > rendering children");
+                            /* Add the children */
+                            let childTiles2 = new Array(childTiles.size());
+                            for (let j = 0; j < childTiles2.length; j++)
+                                childTiles2[j] = childTiles.get(j);
+                            this.addTilesToView(viewRequest, childLevel, childTiles2, levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender);
+                        }
+                        else {
+                            if (ViewTree.DEBUG)
+                                Message.print(ViewTree.MODULE, " > loading children");
+                            /* Request for the missing children to be loaded */
+                            for (let j = 0; j < missingChildTiles.size(); j++)
+                                tilesToLoad.add(missingChildTiles.get(j));
+                            /* Display the tile while we wait for the child tiles to load */
+                            if (tileAvailable)
+                                tilesToRender.add(tileData);
+                        }
+                    }
+                }
+                else {
+                    /* Display the tile */
+                    if (ViewTree.DEBUG)
+                        Message.print(ViewTree.MODULE, " > visible");
+                    if (tileAvailable)
+                        tilesToRender.add(tileData);
+                }
+            }
+            else {
+                /* Log */
+                if (ViewTree.DEBUG)
+                    Message.print(ViewTree.MODULE, " > not visible");
+            }
+        }
+    }
+    /**
+     * Find tile indexes for a 3D view.
+     * @param viewRequest the request parameters.
+     * @param visibleTiles the list of visible tiles to add to.
+     * @param availableTiles the set of available tiles.
+     * @param visibleAvailableTiles the list if visible and available tiles to add to.
+     */
+    renderView3D(viewRequest, levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender) {
+        /* Log? */
+        if (ViewTree.DEBUG)
+            Message.print(ViewTree.MODULE, "Finding pointcloud tiles to render");
+        if (ViewTree.DEBUG)
+            Message.print(ViewTree.MODULE, " > dataBounds: " + this._dataBounds);
+        //if (DEBUG) Message.print(MODULE," > view: "+viewRequest.getViewProjection());
+        //if (DEBUG) Message.print(MODULE," > distance: "+viewRequest.getDistanceRange());
+        //if (DEBUG) Message.print(MODULE," > model-transform: "+viewRequest.getModelTransform());
+        /* Check all blocks */
+        tilesToRender.clear();
+        if (ViewTree.DEBUG)
+            Message.print(ViewTree.MODULE, "Checking " + this._rootBlocks.size() + " root blocks");
+        for (let i = 0; i < this._rootBlocks.size(); i++) // start from the root tiles
+         {
+            /* Visible? */
+            let block = this._rootBlocks.get(i);
+            let blockIndex = block.getBlockIndex();
+            let level = this._levels[blockIndex.level];
+            /* Visible? */
+            if (ViewTree.DEBUG)
+                Message.print(ViewTree.MODULE, "Checking top-level block L" + blockIndex.level + " (" + blockIndex.gridIndex.x + "," + blockIndex.gridIndex.y + "," + blockIndex.gridIndex.z + ")");
+            let blockBounds = block.getBlockBounds(level).getIntersection(this._dataBounds);
+            if (ViewTree.DEBUG)
+                Message.print(ViewTree.MODULE, " > blockBounds: " + blockBounds);
+            if (viewRequest.isVisibleBox(blockBounds)) {
+                /* Add the tiles */
+                if (ViewTree.DEBUG)
+                    Message.print(ViewTree.MODULE, " > visible");
+                this.addTilesToView(viewRequest, level, block.getTiles(blocksToLoad), levelsToLoad, blocksToLoad, tilesToLoad, tilesToRender);
+            }
+        }
+    }
+}
+/** The name of this module */
+ViewTree.MODULE = "ViewTree";
+/** Debug mode? */
+ViewTree.DEBUG = false;
+export { ViewTree };
 //# sourceMappingURL=ViewTree.js.map