334 lines
12 KiB
C
334 lines
12 KiB
C
|
#pragma once
|
||
|
|
|
||
|
|
#include "Library.h"
|
||
|
|
|
||
|
|
#include <CesiumGeospatial/Ellipsoid.h>
|
||
|
|
#include <CesiumGltf/Ktx2TranscodeTargets.h>
|
||
|
|
|
||
|
|
#include <functional>
|
||
|
|
#include <memory>
|
||
|
|
#include <optional>
|
||
|
|
#include <string>
|
||
|
|
#include <vector>
|
||
|
|
|
||
|
|
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<std::string> 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<FogDensityAtHeight> 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<std::shared_ptr<ITileExcluder>> 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<void(const TilesetLoadFailureDetails&)> 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
|