Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 | 1x 1x 1x 5883x 5883x 1x 5882x 5882x 5882x 5882x 5882x 5882x 5882x 34x 5848x 121x 5727x 5727x 5727x 5727x 5727x 1746x 14094x 7171x 4221x 4221x 4221x 4221x 13826x 4221x 4221x 4221x 4221x 4221x 4221x 4221x 13826x 13826x 12720x 12720x 5129x 5129x 12720x 1106x 324x 158x 158x 324x 324x 13826x 5189x 3x 5186x 105x 5081x 5189x 4221x 44x 4221x 2096x 2096x 2096x 2096x 2096x 2096x 7146x 4221x 5727x 5727x 5727x 5727x 5727x 18447x 18447x 18447x 18447x 18447x 18447x 18447x 2095x 2095x 2095x 960x 16352x 9620x 9620x 6732x 6732x 6732x 3514x 18447x 18447x 105x 105x 105x 105x 105x 506x 506x 506x 506x 506x 506x 255x 506x 506x 120x 120x 506x 134x 401x 401x 105x | import defined from "../Core/defined.js"; import ManagedArray from "../Core/ManagedArray.js"; import Cesium3DTileRefine from "./Cesium3DTileRefine.js"; import Cesium3DTilesetTraversal from "./Cesium3DTilesetTraversal.js"; /** * Depth-first traversal that traverses all visible tiles and marks tiles for selection. * A tile does not refine until all children are loaded. * This is the traditional replacement refinement approach and is called the base traversal. * * @alias Cesium3DTilesetBaseTraversal * @constructor * * @private */ function Cesium3DTilesetBaseTraversal() {} const traversal = { stack: new ManagedArray(), stackMaximumLength: 0, }; const emptyTraversal = { stack: new ManagedArray(), stackMaximumLength: 0, }; /** * Traverses a {@link Cesium3DTileset} to determine which tiles to load and render. * * @private * @param {Cesium3DTileset} tileset * @param {FrameState} frameState */ Cesium3DTilesetBaseTraversal.selectTiles = function (tileset, frameState) { tileset._requestedTiles.length = 0; if (tileset.debugFreezeFrame) { return; } tileset._selectedTiles.length = 0; tileset._selectedTilesToStyle.length = 0; tileset._emptyTiles.length = 0; tileset.hasMixedContent = false; const root = tileset.root; Cesium3DTilesetTraversal.updateTile(root, frameState); if (!root.isVisible) { return; } if ( root.getScreenSpaceError(frameState, true) <= tileset.memoryAdjustedScreenSpaceError ) { return; } executeTraversal(root, frameState); traversal.stack.trim(traversal.stackMaximumLength); emptyTraversal.stack.trim(emptyTraversal.stackMaximumLength); // Update the priority for any requests found during traversal // Update after traversal so that min and max values can be used to normalize priority values const requestedTiles = tileset._requestedTiles; for (let i = 0; i < requestedTiles.length; ++i) { requestedTiles[i].updatePriority(); } }; /** * Mark a tile as selected if it has content available. * * @private * @param {Cesium3DTile} tile * @param {FrameState} frameState */ function selectDesiredTile(tile, frameState) { if (tile.contentAvailable) { Cesium3DTilesetTraversal.selectTile(tile, frameState); } } /** * @private * @param {Cesium3DTile} tile * @param {ManagedArray} stack * @param {FrameState} frameState * @returns {boolean} */ function updateAndPushChildren(tile, stack, frameState) { const replace = tile.refine === Cesium3DTileRefine.REPLACE; const { tileset, children } = tile; const { updateTile, loadTile, touchTile } = Cesium3DTilesetTraversal; for (let i = 0; i < children.length; ++i) { updateTile(children[i], frameState); } // Sort by distance to take advantage of early Z and reduce artifacts for skipLevelOfDetail children.sort(Cesium3DTilesetTraversal.sortChildrenByDistanceToCamera); // For traditional replacement refinement only refine if all children are loaded. // Empty tiles are exempt since it looks better if children stream in as they are loaded to fill the empty space. const checkRefines = replace && tile.hasRenderableContent; let refines = true; let anyChildrenVisible = false; // Determining min child let minIndex = -1; let minimumPriority = Number.MAX_VALUE; for (let i = 0; i < children.length; ++i) { const child = children[i]; if (child.isVisible) { stack.push(child); if (child._foveatedFactor < minimumPriority) { minIndex = i; minimumPriority = child._foveatedFactor; } anyChildrenVisible = true; } else if (checkRefines || tileset.loadSiblings) { // Keep non-visible children loaded since they are still needed before the parent can refine. // Or loadSiblings is true so always load tiles regardless of visibility. if (child._foveatedFactor < minimumPriority) { minIndex = i; minimumPriority = child._foveatedFactor; } loadTile(child, frameState); touchTile(child, frameState); } if (checkRefines) { let childRefines; if (!child._inRequestVolume) { childRefines = false; } else if (!child.hasRenderableContent) { childRefines = executeEmptyTraversal(child, frameState); } else { childRefines = child.contentAvailable; } refines = refines && childRefines; } } if (!anyChildrenVisible) { refines = false; } if (minIndex !== -1 && replace) { // An ancestor will hold the _foveatedFactor and _distanceToCamera for descendants between itself and its highest priority descendant. Siblings of a min children along the way use this ancestor as their priority holder as well. // Priority of all tiles that refer to the _foveatedFactor and _distanceToCamera stored in the common ancestor will be differentiated based on their _depth. const minPriorityChild = children[minIndex]; minPriorityChild._wasMinPriorityChild = true; const priorityHolder = (tile._wasMinPriorityChild || tile === tileset.root) && minimumPriority <= tile._priorityHolder._foveatedFactor ? tile._priorityHolder : tile; // This is where priority dependency chains are wired up or started anew. priorityHolder._foveatedFactor = Math.min( minPriorityChild._foveatedFactor, priorityHolder._foveatedFactor, ); priorityHolder._distanceToCamera = Math.min( minPriorityChild._distanceToCamera, priorityHolder._distanceToCamera, ); for (let i = 0; i < children.length; ++i) { children[i]._priorityHolder = priorityHolder; } } return refines; } /** * Depth-first traversal that traverses all visible tiles and marks tiles for selection. * A tile does not refine until all children are loaded. * This is the traditional replacement refinement approach and is called the base traversal. * * @private * @param {Cesium3DTile} root * @param {FrameState} frameState */ function executeTraversal(root, frameState) { const { tileset } = root; const { canTraverse, loadTile, visitTile, touchTile } = Cesium3DTilesetTraversal; const stack = traversal.stack; stack.push(root); while (stack.length > 0) { traversal.stackMaximumLength = Math.max( traversal.stackMaximumLength, stack.length, ); const tile = stack.pop(); const parent = tile.parent; const parentRefines = !defined(parent) || parent._refines; tile._refines = canTraverse(tile) ? updateAndPushChildren(tile, stack, frameState) && parentRefines : false; const stoppedRefining = !tile._refines && parentRefines; if (!tile.hasRenderableContent) { // Add empty tile just to show its debug bounding volume // If the tile has tileset content load the external tileset tileset._emptyTiles.push(tile); loadTile(tile, frameState); if (stoppedRefining) { selectDesiredTile(tile, frameState); } } else if (tile.refine === Cesium3DTileRefine.ADD) { // Additive tiles are always loaded and selected selectDesiredTile(tile, frameState); loadTile(tile, frameState); } else Eif (tile.refine === Cesium3DTileRefine.REPLACE) { loadTile(tile, frameState); if (stoppedRefining) { selectDesiredTile(tile, frameState); } } visitTile(tile, frameState); touchTile(tile, frameState); } } /** * Depth-first traversal that checks if all nearest descendants with content are loaded. * Ignores visibility. * * @private * @param {Cesium3DTile} root * @param {FrameState} frameState * @returns {boolean} */ function executeEmptyTraversal(root, frameState) { const { canTraverse, updateTile, loadTile, touchTile } = Cesium3DTilesetTraversal; let allDescendantsLoaded = true; const stack = emptyTraversal.stack; stack.push(root); while (stack.length > 0) { emptyTraversal.stackMaximumLength = Math.max( emptyTraversal.stackMaximumLength, stack.length, ); const tile = stack.pop(); const children = tile.children; const childrenLength = children.length; // Only traverse if the tile is empty - traversal stops at descendants with content const traverse = !tile.hasRenderableContent && canTraverse(tile); // Traversal stops but the tile does not have content yet // There will be holes if the parent tries to refine to its children, so don't refine if (!traverse && !tile.contentAvailable) { allDescendantsLoaded = false; } updateTile(tile, frameState); if (!tile.isVisible) { // Load tiles that aren't visible since they are still needed for the parent to refine loadTile(tile, frameState); touchTile(tile, frameState); } if (traverse) { for (let i = 0; i < childrenLength; ++i) { const child = children[i]; stack.push(child); } } } return root.hasEmptyContent || allDescendantsLoaded; } export default Cesium3DTilesetBaseTraversal; |