#pragma once #include "Library.h" #include #include #include #include #include #include #include namespace Cesium3DTilesSelection { class ITileExcluder; class TilesetLoadFailureDetails; /** * @brief Options for configuring the parsing of a {@link Tileset}'s content * and construction of Gltf models. */ struct CESIUM3DTILESSELECTION_API TilesetContentOptions { /** * @brief Whether to include a water mask within the Gltf extras. * * Currently only applicable for quantized-mesh tilesets that support the * water mask extension. */ bool enableWaterMask = false; /** * @brief Whether to generate smooth normals when normals are missing in the * original Gltf. * * According to the Gltf spec: "When normals are not specified, client * implementations should calculate flat normals." However, calculating flat * normals requires duplicating vertices. This option allows the gltfs to be * sent with explicit smooth normals when the original gltf was missing * normals. */ bool generateMissingNormalsSmooth = false; /** * @brief For each possible input transmission format, this struct names * the ideal target gpu-compressed pixel format to transcode to. */ CesiumGltf::Ktx2TranscodeTargets ktx2TranscodeTargets; /** * @brief Whether or not to transform texture coordinates during load when * textures have the `KHR_texture_transform` extension. Set this to false if * texture coordinates will be transformed another way, such as in a vertex * shader. */ bool applyTextureTransform = true; }; /** * @brief Defines the fog density at a certain height. * * @see TilesetOptions::fogDensityTable */ struct CESIUM3DTILESSELECTION_API FogDensityAtHeight { /** @brief The height. */ double cameraHeight; /** @brief The fog density. */ double fogDensity; }; /** * @brief Additional options for configuring a {@link Tileset}. */ struct CESIUM3DTILESSELECTION_API TilesetOptions { /** * @brief A credit text for this tileset, if needed. */ std::optional credit; /** * @brief Whether or not to display tileset's credits on the screen. */ bool showCreditsOnScreen = false; /** * @brief The maximum number of pixels of error when rendering this tileset. * This is used to select an appropriate level-of-detail. * * When a tileset uses the older layer.json / quantized-mesh format rather * than 3D Tiles, this value is effectively divided by 8.0. So the default * value of 16.0 corresponds to the standard value for quantized-mesh terrain * of 2.0. */ double maximumScreenSpaceError = 16.0; /** * @brief The maximum number of tiles that may simultaneously be in the * process of loading. */ uint32_t maximumSimultaneousTileLoads = 20; /** * @brief The maximum number of subtrees that may simultaneously be in the * process of loading. */ uint32_t maximumSimultaneousSubtreeLoads = 20; /** * @brief Indicates whether the ancestors of rendered tiles should be * preloaded. Setting this to true optimizes the zoom-out experience and * provides more detail in newly-exposed areas when panning. The down side is * that it requires loading more tiles. */ bool preloadAncestors = true; /** * @brief Indicates whether the siblings of rendered tiles should be * preloaded. Setting this to true causes tiles with the same parent as a * rendered tile to be loaded, even if they are culled. Setting this to true * may provide a better panning experience at the cost of loading more tiles. */ bool preloadSiblings = true; /** * @brief The number of loading descendant tiles that is considered "too * many". If a tile has too many loading descendants, that tile will be loaded * and rendered before any of its descendants are loaded and rendered. This * means more feedback for the user that something is happening at the cost of * a longer overall load time. Setting this to 0 will cause each tile level to * be loaded successively, significantly increasing load time. Setting it to a * large number (e.g. 1000) will minimize the number of tiles that are loaded * but tend to make detail appear all at once after a long wait. */ uint32_t loadingDescendantLimit = 20; /** * @brief Never render a tileset with missing tiles. * * When true, the tileset will guarantee that the tileset will never be * rendered with holes in place of tiles that are not yet loaded. It does this * by refusing to refine a parent tile until all of its child tiles are ready * to render. Thus, when the camera moves, we will always have something - * even if it's low resolution - to render any part of the tileset that * becomes visible. When false, overall loading will be faster, but * newly-visible parts of the tileset may initially be blank. */ bool forbidHoles = false; /** * @brief Enable culling of tiles against the frustum. */ bool enableFrustumCulling = true; /** * @brief Enable culling of occluded tiles, as reported by the renderer. */ bool enableOcclusionCulling = true; /** * @brief Wait to refine until the occlusion state of a tile is known. * * Only applicable when enableOcclusionInfo is true. Enabling this option may * cause a small delay between when a tile is needed according to the SSE and * when the tile load is kicked off. On the other hand, this delay could * allow the occlusion system to avoid loading a tile entirely if it is * found to be unnecessary a few frames later. */ bool delayRefinementForOcclusion = true; /** * @brief Enable culling of tiles that cannot be seen through atmospheric fog. */ bool enableFogCulling = true; /** * @brief Whether culled tiles should be refined until they meet * culledScreenSpaceError. * * When true, any culled tile from a disabled culling stage will be refined * until it meets the specified culledScreenSpaceError. Otherwise, its * screen-space error check will be disabled altogether and it will not bother * to refine any futher. */ bool enforceCulledScreenSpaceError = true; /** * @brief The screen-space error to refine until for culled tiles from * disabled culling stages. * * When enforceCulledScreenSpaceError is true, culled tiles from disabled * culling stages will be refined until they meet this screen-space error * value. */ double culledScreenSpaceError = 64.0; /** * @brief The maximum number of bytes that may be cached. * * Note that this value, even if 0, will never * cause tiles that are needed for rendering to be unloaded. However, if the * total number of loaded bytes is greater than this value, tiles will be * unloaded until the total is under this number or until only required tiles * remain, whichever comes first. */ int64_t maximumCachedBytes = 512 * 1024 * 1024; /** * @brief A table that maps the camera height above the ellipsoid to a fog * density. Tiles that are in full fog are culled. The density of the fog * increases as this number approaches 1.0 and becomes less dense as it * approaches zero. The more dense the fog is, the more aggressively the tiles * are culled. For example, if the camera is a height of 1000.0m above the * ellipsoid, increasing the value to 3.0e-3 will cause many tiles close to * the viewer be culled. Decreasing the value will push the fog further from * the viewer, but decrease performance as more of the tiles are rendered. * Tiles are culled when `1.0 - glm::exp(-(distance * distance * fogDensity * * fogDensity))` is >= 1.0. */ std::vector fogDensityTable = { {359.393, 2.0e-5}, {800.749, 2.0e-4}, {1275.6501, 1.0e-4}, {2151.1192, 7.0e-5}, {3141.7763, 5.0e-5}, {4777.5198, 4.0e-5}, {6281.2493, 3.0e-5}, {12364.307, 1.9e-5}, {15900.765, 1.0e-5}, {49889.0549, 8.5e-6}, {78026.8259, 6.2e-6}, {99260.7344, 5.8e-6}, {120036.3873, 5.3e-6}, {151011.0158, 5.2e-6}, {156091.1953, 5.1e-6}, {203849.3112, 4.2e-6}, {274866.9803, 4.0e-6}, {319916.3149, 3.4e-6}, {493552.0528, 2.6e-6}, {628733.5874, 2.2e-6}, {1000000.0, 0.0}}; /** * @brief Whether to render tiles directly under the camera, even if they're * not in the view frustum. * * This is useful for detecting the camera's collision with terrain and other * models. NOTE: This option currently only works with tiles that use a * `region` as their bounding volume. It is ignored for other bounding volume * types. */ bool renderTilesUnderCamera = true; /** * @brief A list of interfaces that are given an opportunity to exclude tiles * from loading and rendering. If any of the excluders indicate that a tile * should not be loaded, it will not be loaded. */ std::vector> excluders; /** * @brief A callback function that is invoked when a tileset resource fails to * load. * * Tileset resources include a Cesium ion asset endpoint, a tileset's root * tileset.json or layer.json, an individual tile's content, or an implicit * tiling subtree. */ std::function loadErrorCallback; /** * @brief Whether to keep tiles loaded during a transition period when * switching to a different LOD tile. * * For each tile, {@link TileRenderContent::getLodTransitionFadePercentage} will * indicate to the client how faded to render the tile throughout the * transition. Tile fades can be used to mask LOD transitions and make them * appear less abrupt and jarring. */ bool enableLodTransitionPeriod = false; /** * @brief How long it should take to transition between tiles of different * LODs, in seconds. * * When a tile refines or unrefines to a higher or lower LOD tile, a fade * can optionally be applied to smooth the transition. This value determines * how many seconds the whole transition should take. Note that the old tile * doesn't start fading out until the new tile fully fades in. */ float lodTransitionLength = 1.0f; /** * @brief Whether to kick descendants while a tile is still fading in. * * This does not delay loading of descendants, but it keeps them off the * render list while the tile is fading in. If this is false, the tile * currently fading in will pop in to full opacity if descendants are * rendered (this counteracts the benefits of LOD transition blending). * */ bool kickDescendantsWhileFadingIn = true; /** * @brief A soft limit on how long (in milliseconds) to spend on the * main-thread part of tile loading each frame (each call to * Tileset::updateView). A value of 0.0 indicates that all pending * main-thread loads should be completed each tick. * * Setting this to too low of a value will impede overall tile load progress, * creating a discernable load latency. */ double mainThreadLoadingTimeLimit = 0.0; /** * @brief A soft limit on how long (in milliseconds) to spend unloading * cached tiles each frame (each call to Tileset::updateView). A value of 0.0 * indicates that the tile cache should not throttle unloading tiles. */ double tileCacheUnloadTimeLimit = 0.0; /** * @brief Options for configuring the parsing of a {@link Tileset}'s content * and construction of Gltf models. */ TilesetContentOptions contentOptions; /** * @brief Arbitrary data that will be passed to {@link IPrepareRendererResources::prepareInLoadThread}. * * This object is copied and given to tile preparation threads, * so it must be inexpensive to copy. */ std::any rendererOptions; /** * @brief The ellipsoid to use for this tileset. * This value shouldn't be changed after the tileset is constructed. If you * need to change a tileset's ellipsoid, please recreate the tileset. * * If no ellipsoid is set, Ellipsoid::WGS84 will be used by default. */ CesiumGeospatial::Ellipsoid ellipsoid = CesiumGeospatial::Ellipsoid::WGS84; }; } // namespace Cesium3DTilesSelection