All files / engine/Source/Scene Cesium3DTilesetMostDetailedTraversal.js

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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1x
 
 
 
 
 
 
 
 
 
 
 
 
1x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
import Intersect from "../Core/Intersect.js";
import ManagedArray from "../Core/ManagedArray.js";
import Cesium3DTileRefine from "./Cesium3DTileRefine.js";
import Cesium3DTilesetTraversal from "./Cesium3DTilesetTraversal.js";
 
/**
 * Traversal that loads all leaves that intersect the camera frustum.
 * Used to determine ray-tileset intersections during a pickFromRayMostDetailed call.
 *
 * @alias Cesium3DTilesetMostDetailedTraversal
 * @constructor
 *
 * @private
 */
function Cesium3DTilesetMostDetailedTraversal() {}
 
const traversal = {
  stack: new ManagedArray(),
  stackMaximumLength: 0,
};
 
/**
 * Traverses a {@link Cesium3DTileset} to determine which tiles to load and render.
 *
 * @private
 * @param {Cesium3DTileset} tileset
 * @param {FrameState} frameState
 * @returns {boolean} Whether the appropriate tile is ready for picking
 */
Cesium3DTilesetMostDetailedTraversal.selectTiles = function (
  tileset,
  frameState,
) {
  tileset._selectedTiles.length = 0;
  tileset._requestedTiles.length = 0;
  tileset.hasMixedContent = false;
 
  let ready = true;
 
  const root = tileset.root;
  root.updateVisibility(frameState);
 
  if (!root.isVisible) {
    return ready;
  }
 
  const { touchTile, visitTile } = 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 add = tile.refine === Cesium3DTileRefine.ADD;
    const replace = tile.refine === Cesium3DTileRefine.REPLACE;
    const traverse = canTraverse(tile);
 
    if (traverse) {
      updateAndPushChildren(tile, stack, frameState);
    }
 
    if (add || (replace && !traverse)) {
      loadTile(tileset, tile);
      touchTile(tile, frameState);
      selectDesiredTile(tile, frameState);
 
      if (tile.hasRenderableContent && !tile.contentAvailable) {
        ready = false;
      }
    }
 
    visitTile(tile, frameState);
  }
 
  traversal.stack.trim(traversal.stackMaximumLength);
 
  return ready;
};
 
function canTraverse(tile) {
  if (tile.children.length === 0) {
    return false;
  }
 
  if (tile.hasTilesetContent || tile.hasImplicitContent) {
    // Traverse external tileset to visit its root tile
    // Don't traverse if the subtree is expired because it will be destroyed
    return !tile.contentExpired;
  }
 
  if (tile.hasEmptyContent) {
    return true;
  }
 
  return true; // Keep traversing until a leaf is hit
}
 
function updateAndPushChildren(tile, stack, frameState) {
  const { children } = tile;
 
  for (let i = 0; i < children.length; ++i) {
    const child = children[i];
    child.updateVisibility(frameState);
    if (child.isVisible) {
      stack.push(child);
    }
  }
}
 
function loadTile(tileset, tile) {
  if (tile.hasUnloadedRenderableContent || tile.contentExpired) {
    tile._priority = 0.0; // Highest priority
    tileset._requestedTiles.push(tile);
  }
}
 
function selectDesiredTile(tile, frameState) {
  if (
    tile.contentAvailable &&
    tile.contentVisibility(frameState) !== Intersect.OUTSIDE
  ) {
    tile.tileset._selectedTiles.push(tile);
  }
}
 
export default Cesium3DTilesetMostDetailedTraversal;