Cesium3DTileset.h

Go to the documentation of this file.

// Copyright 2020-2024 CesiumGS, Inc. and Contributors
 
#pragma once
 
#include "Cesium3DTilesSelection/Tileset.h"
#include "Cesium3DTilesSelection/ViewState.h"
#include "Cesium3DTilesSelection/ViewUpdateResult.h"
#include "Cesium3DTilesetLoadFailureDetails.h"
#include "CesiumCreditSystem.h"
#include "CesiumEncodedMetadataComponent.h"
#include "CesiumFeaturesMetadataComponent.h"
#include "CesiumGeoreference.h"
#include "CesiumIonServer.h"
#include "CesiumPointCloudShading.h"
#include "CesiumSampleHeightResult.h"
#include "CoreMinimal.h"
#include "CustomDepthParameters.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/Actor.h"
#include "Interfaces/IHttpRequest.h"
#include "PrimitiveSceneProxy.h"
#include <PhysicsEngine/BodyInstance.h>
#include <atomic>
#include <chrono>
#include <glm/mat4x4.hpp>
#include <unordered_map>
#include <vector>
#include "Cesium3DTileset.generated.h"
 
#ifdef CESIUM_DEBUG_TILE_STATES
#include <Cesium3DTilesSelection/DebugTileStateDatabase.h>
#endif
 
class UMaterialInterface;
class ACesiumCartographicSelection;
class ACesiumCameraManager;
class UCesiumBoundingVolumePoolComponent;
class CesiumViewExtension;
struct FCesiumCamera;
 
namespace Cesium3DTilesSelection {
class Tileset;
class TilesetView;
class TileOcclusionRendererProxyPool;
} // namespace Cesium3DTilesSelection
 
/**
 * The delegate for OnCesium3DTilesetLoadFailure, which is triggered when
 * the tileset encounters a load error.
 */
DECLARE_MULTICAST_DELEGATE_OneParam(
    FCesium3DTilesetLoadFailure,
    const FCesium3DTilesetLoadFailureDetails&);
 
DECLARE_DELEGATE_ThreeParams(
    FCesiumSampleHeightMostDetailedCallback,
    ACesium3DTileset*,
    const TArray<FCesiumSampleHeightResult>&,
    const TArray<FString>&);
 
/**
 * The delegate for the Acesium3DTileset::OnTilesetLoaded,
 * which is triggered from UpdateLoadStatus
 */
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FCompletedLoadTrigger);
 
CESIUMRUNTIME_API extern FCesium3DTilesetLoadFailure
    OnCesium3DTilesetLoadFailure;
 
UENUM(BlueprintType)
enum class ETilesetSource : uint8 {
  /**
   * The tileset will be loaded from Cesium Ion using the provided IonAssetID
   * and IonAccessToken.
   */
  FromCesiumIon UMETA(DisplayName = "From Cesium Ion"),
 
  /**
   * The tileset will be loaded from the specified Url.
   */
  FromUrl UMETA(DisplayName = "From Url"),
 
  /**
   * The tileset will be loaded from the georeference ellipsoid.
   */
  FromEllipsoid UMETA(DisplayName = "From Ellipsoid")
};
 
UENUM(BlueprintType)
enum class EApplyDpiScaling : uint8 { Yes, No, UseProjectDefault };
 
UCLASS()
class CESIUMRUNTIME_API ACesium3DTileset : public AActor {
  GENERATED_BODY()
 
public:
  ACesium3DTileset();
  virtual ~ACesium3DTileset();
 
private:
  UPROPERTY(VisibleAnywhere, Category = "Cesium") USceneComponent* Root;
 
  UPROPERTY(
      Meta =
          (AllowPrivateAccess,
           DeprecatedProperty,
           DeprecationMessage =
               "Use the Mobility property on the RootComponent instead."))
  TEnumAsByte<EComponentMobility::Type> Mobility_DEPRECATED =
      EComponentMobility::Static;
 
public:
  UFUNCTION(BlueprintCallable, meta = (DeprecatedFunction))
  EComponentMobility::Type GetMobility() const {
    return this->RootComponent->Mobility;
  }
  UFUNCTION(BlueprintCallable, meta = (DeprecatedFunction))
  void SetMobility(EComponentMobility::Type NewMobility);
 
  /**
   * @brief Initiates an asynchronous query for the height of this tileset at a
   * list of cartographic positions, where the Longitude (X) and Latitude (Y)
   * are given in degrees. The most detailed available tiles are used to
   * determine each height.
   *
   * The height of the input positions is ignored, unless height sampling fails
   * at that location. The output height is expressed in meters above the
   * ellipsoid (usually WGS84), which should not be confused with a height above
   * mean sea level.
   *
   * @param LongitudeLatitudeHeightArray The cartographic positions for which to
   * sample heights. The Longitude (X) and Latitude (Y) are expressed in
   * degrees, while Height (Z) is given in meters.
   * @param OnHeightsSampled A callback that is invoked in the game thread when
   * heights have been sampled for all positions.
   */
  void SampleHeightMostDetailed(
      const TArray<FVector>& LongitudeLatitudeHeightArray,
      FCesiumSampleHeightMostDetailedCallback OnHeightsSampled);
 
private:
  /**
   * The designated georeference actor controlling how the actor's
   * coordinate system relates to the coordinate system in this Unreal Engine
   * level.
   *
   * If this is null, the Tileset will find and use the first Georeference
   * Actor in the level, or create one if necessary. To get the active/effective
   * Georeference from Blueprints or C++, use ResolvedGeoreference instead.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      BlueprintGetter = GetGeoreference,
      BlueprintSetter = SetGeoreference,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  TSoftObjectPtr<ACesiumGeoreference> Georeference;
 
  /**
   * The resolved georeference used by this Tileset. This is not serialized
   * because it may point to a Georeference in the PersistentLevel while this
   * tileset is in a sublevel. If the Georeference property is specified,
   * however then this property will have the same value.
   *
   * This property will be null before ResolveGeoreference is called.
   */
  UPROPERTY(
      Transient,
      VisibleAnywhere,
      BlueprintReadOnly,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  ACesiumGeoreference* ResolvedGeoreference = nullptr;
 
public:
  /** @copydoc ACesium3DTileset::Georeference */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  TSoftObjectPtr<ACesiumGeoreference> GetGeoreference() const;
 
  /** @copydoc ACesium3DTileset::Georeference */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  void SetGeoreference(TSoftObjectPtr<ACesiumGeoreference> NewGeoreference);
 
  /**
   * Resolves the Cesium Georeference to use with this Actor. Returns
   * the value of the Georeference property if it is set. Otherwise, finds a
   * Georeference in the World and returns it, creating it if necessary. The
   * resolved Georeference is cached so subsequent calls to this function will
   * return the same instance.
   */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  ACesiumGeoreference* ResolveGeoreference();
 
  /**
   * Invalidates the cached resolved georeference, unsubscribing from it and
   * setting it to null. The next time ResolveGeoreference is called, the
   * Georeference will be re-resolved and re-subscribed.
   */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  void InvalidateResolvedGeoreference();
 
private:
  /**
   * The actor managing this tileset's content attributions.
   *
   * If this is null, the Tileset will find and use the first Credit System
   * Actor in the level, or create one if necessary. To get the active/effective
   * Credit System from Blueprints or C++, use ResolvedCreditSystem instead.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      BlueprintGetter = GetCreditSystem,
      BlueprintSetter = SetCreditSystem,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  TSoftObjectPtr<ACesiumCreditSystem> CreditSystem;
 
  /**
   * The resolved Credit System used by this Tileset. This is not serialized
   * because it may point to a Credit System in the PersistentLevel while this
   * tileset is in a sublevel. If the CreditSystem property is specified,
   * however then this property will have the same value.
   *
   * This property will be null before ResolveCreditSystem is called.
   */
  UPROPERTY(
      Transient,
      BlueprintReadOnly,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  ACesiumCreditSystem* ResolvedCreditSystem = nullptr;
 
  /**
   * The actor providing custom cameras for use with this Tileset.
   *
   * If this is null, the Tileset will find and use the first
   * CesiumCameraManager Actor in the level, or create one if necessary. To get
   * the active/effective Camera Manager from Blueprints or C++, use
   * ResolvedCameraManager instead.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      BlueprintGetter = GetCameraManager,
      BlueprintSetter = SetCameraManager,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  TSoftObjectPtr<ACesiumCameraManager> CameraManager;
 
  /**
   * The resolved Camera Manager used by this Tileset. This is not serialized
   * because it may point to a Camera Manager in the PersistentLevel while this
   * tileset is in a sublevel. If the CameraManager property is specified,
   * however then this property will have the same value.
   *
   * This property will be null before ResolveCameraManager is called.
   */
  UPROPERTY(
      Transient,
      BlueprintReadOnly,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  ACesiumCameraManager* ResolvedCameraManager = nullptr;
 
  /**
   * The bounding volume pool component that manages occlusion bounding volume
   * proxies.
   */
  UPROPERTY(
      Transient,
      BlueprintReadOnly,
      Category = "Cesium",
      Meta = (AllowPrivateAccess))
  UCesiumBoundingVolumePoolComponent* BoundingVolumePoolComponent = nullptr;
 
  /**
   * The custom view extension this tileset uses to pull renderer view
   * information.
   */
  TSharedPtr<CesiumViewExtension, ESPMode::ThreadSafe> _cesiumViewExtension =
      nullptr;
 
public:
  /** @copydoc ACesium3DTileset::CreditSystem */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  TSoftObjectPtr<ACesiumCreditSystem> GetCreditSystem() const;
 
  /** @copydoc ACesium3DTileset::CreditSystem */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  void SetCreditSystem(TSoftObjectPtr<ACesiumCreditSystem> NewCreditSystem);
 
  /**
   * Resolves the Cesium Credit System to use with this Actor. Returns
   * the value of the CreditSystem property if it is set. Otherwise, finds a
   * Credit System in the World and returns it, creating it if necessary. The
   * resolved Credit System is cached so subsequent calls to this function will
   * return the same instance.
   */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  ACesiumCreditSystem* ResolveCreditSystem();
 
  /**
   * Invalidates the cached resolved Credit System, setting it to null. The next
   * time ResolveCreditSystem is called, the Credit System will be re-resolved.
   */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  void InvalidateResolvedCreditSystem();
 
  /**
   * Whether or not to show this tileset's credits on screen.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium")
  bool ShowCreditsOnScreen = false;
 
  /** @copydoc ACesium3DTileset::CameraManager */
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  TSoftObjectPtr<ACesiumCameraManager> GetCameraManager() const;
 
  /** @copydoc ACesium3DTileset::CameraManager */
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetCameraManager(TSoftObjectPtr<ACesiumCameraManager> NewCameraManager);
 
  /**
   * Resolves the Cesium Camera Manager to use with this Actor. Returns
   * the value of the CameraManager property if it is set. Otherwise, finds a
   * Camera Manager in the World and returns it, creating it if necessary. The
   * resolved Camera Manager is cached so subsequent calls to this function will
   * return the same instance.
   */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  ACesiumCameraManager* ResolveCameraManager();
 
  /**
   * Invalidates the cached resolved Camera Manager, setting it to null. The
   * next time ResolveCameraManager is called, the Camera Manager will be
   * re-resolved.
   */
  UFUNCTION(BlueprintCallable, Category = "Cesium")
  void InvalidateResolvedCameraManager();
 
  /**
   * The maximum number of pixels of error when rendering this tileset.
   *
   * This is used to select an appropriate level-of-detail: A low value
   * will cause many tiles with a high level of detail to be loaded,
   * causing a finer visual representation of the tiles, but with a
   * higher performance cost for loading and rendering. A higher value will
   * cause a coarser visual representation, with lower performance
   * requirements.
   *
   * 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.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetMaximumScreenSpaceError,
      BlueprintSetter = SetMaximumScreenSpaceError,
      Category = "Cesium|Level of Detail",
      meta = (ClampMin = 0.0))
  double MaximumScreenSpaceError = 16.0;
 
  /**
   * Scale Level-of-Detail by Display DPI. This increases the performance for
   * mobile devices and high DPI screens.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Level of Detail")
  EApplyDpiScaling ApplyDpiScaling = EApplyDpiScaling::UseProjectDefault;
 
  /**
   * Whether to preload ancestor tiles.
   *
   * 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.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium|Tile Loading")
  bool PreloadAncestors = true;
 
  /**
   * Whether to preload sibling tiles.
   *
   * 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.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium|Tile Loading")
  bool PreloadSiblings = true;
 
  /**
   * Whether to unrefine back to a parent tile when a child isn't done loading.
   *
   * When this is set to true, the tileset will guarantee that the tileset will
   * never be rendered with holes in place of tiles that are not yet loaded,
   * even though the tile that is rendered instead may have low resolution. When
   * false, overall loading will be faster, but newly-visible parts of the
   * tileset may initially be blank.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium|Tile Loading")
  bool ForbidHoles = false;
 
  /**
   * The maximum number of tiles that may be loaded at once.
   *
   * When new parts of the tileset become visible, the tasks to load the
   * corresponding tiles are put into a queue. This value determines how
   * many of these tasks are processed at the same time. A higher value
   * may cause the tiles to be loaded and rendered more quickly, at the
   * cost of a higher network- and processing load.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Tile Loading",
      meta = (ClampMin = 0))
  int32 MaximumSimultaneousTileLoads = 20;
 
  /**
   * @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.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium|Tile Loading")
  int64 MaximumCachedBytes = 256 * 1024 * 1024;
 
  /**
   * The number of loading descendents a tile should allow before deciding to
   * render itself instead of waiting.
   *
   * Setting this to 0 will cause each level of detail to be loaded
   * successively. This will increase the overall loading time, but cause
   * additional detail to appear more gradually. Setting this to a high value
   * like 1000 will decrease the overall time until the desired level of detail
   * is achieved, but this high-detail representation will appear at once, as
   * soon as it is loaded completely.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Tile Loading",
      meta = (ClampMin = 0))
  int32 LoadingDescendantLimit = 20;
 
  /**
   * Whether to cull tiles that are outside the frustum.
   *
   * By default this is true, meaning that tiles that are not visible with the
   * current camera configuration will be ignored. It can be set to false, so
   * that these tiles are still considered for loading, refinement and
   * rendering.
   *
   * This will cause more tiles to be loaded, but helps to avoid holes and
   * provides a more consistent mesh, which may be helpful for physics.
   *
   * Note that this will always be disabled if UseLodTransitions is set to true.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Tile Culling",
      Meta = (EditCondition = "!UseLodTransitions", EditConditionHides))
  bool EnableFrustumCulling = true;
 
  /**
   * Whether to cull tiles that are occluded by fog.
   *
   * This does not refer to the atmospheric fog of the Unreal Engine,
   * but to an internal representation of fog: Depending on the height
   * of the camera above the ground, tiles that are far away (close to
   * the horizon) will be culled when this flag is enabled.
   *
   * Note that this will always be disabled if UseLodTransitions is set to true.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Tile Culling",
      Meta = (EditCondition = "!UseLodTransitions", EditConditionHides))
  bool EnableFogCulling = true;
 
  /**
   * Whether a specified screen-space error should be enforced for tiles that
   * are outside the frustum or hidden in fog.
   *
   * When "Enable Frustum Culling" and "Enable Fog Culling" are both true, tiles
   * outside the view frustum or hidden in fog are effectively ignored, and so
   * their level-of-detail doesn't matter. And in this scenario, this property
   * is ignored.
   *
   * However, when either of those flags are false, these "would-be-culled"
   * tiles continue to be processed, and the question arises of how to handle
   * their level-of-detail. When this property is false, refinement terminates
   * at these tiles, no matter what their current screen-space error. The tiles
   * are available for physics, shadows, etc., but their level-of-detail may
   * be very low.
   *
   * When set to true, these tiles are refined until they achieve the specified
   * "Culled Screen Space Error". This allows control over the minimum quality
   * of these would-be-culled tiles.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium|Tile Culling")
  bool EnforceCulledScreenSpaceError = false;
 
  /**
   * The screen-space error to be enforced for tiles that are outside the view
   * frustum or hidden in fog.
   *
   * When "Enable Frustum Culling" and "Enable Fog Culling" are both true, tiles
   * outside the view frustum or hidden in fog are effectively ignored, and so
   * their level-of-detail doesn't matter. And in this scenario, this property
   * is ignored.
   *
   * However, when either of those flags are false, these "would-be-culled"
   * tiles continue to be processed, and the question arises of how to handle
   * their level-of-detail. When "Enforce Culled Screen Space Error" is false,
   * this property is ignored and refinement terminates at these tiles, no
   * matter what their current screen-space error. The tiles are available for
   * physics, shadows, etc., but their level-of-detail may be very low.
   *
   * When set to true, these tiles are refined until they achieve the
   * screen-space error specified by this property.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Tile Culling",
      meta = (EditCondition = "EnforceCulledScreenSpaceError", ClampMin = 0.0))
  double CulledScreenSpaceError = 64.0;
 
  // This mirrors
  // UCesiumRuntimeSettings::EnableExperimentalOcclusionCullingFeature so that
  // it can be used as an EditCondition.
  UPROPERTY(Transient, VisibleDefaultsOnly, Category = "Cesium|Tile Occlusion")
  bool CanEnableOcclusionCulling = false;
 
  /**
   * Whether to cull tiles that are occluded.
   *
   * If this option is disabled, check that "Enable Experimental Occlusion
   * Culling Feature" is enabled in the Plugins -> Cesium section of the Project
   * Settings.
   *
   * When enabled, this feature will use Unreal's occlusion system to determine
   * if tiles are actually visible on the screen. For tiles found to be
   * occluded, the tile will not refine to show descendants, but it will still
   * be rendered to avoid holes. This results in less tile loads and less GPU
   * resource usage for dense, high-occlusion scenes like ground-level views in
   * cities.
   *
   * This will not work for tilesets with poorly fit bounding volumes and cause
   * more draw calls with very few extra culled tiles. When there is minimal
   * occlusion in a scene, such as with terrain tilesets and applications
   * focused on top-down views, this feature will yield minimal benefit and
   * potentially cause needless overhead.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetEnableOcclusionCulling,
      BlueprintSetter = SetEnableOcclusionCulling,
      Category = "Cesium|Tile Occlusion",
      meta = (EditCondition = "CanEnableOcclusionCulling"))
  bool EnableOcclusionCulling = true;
 
  /**
   * The number of CesiumBoundingVolumeComponents to use for querying the
   * occlusion state of traversed tiles.
   *
   * Only applicable when EnableOcclusionCulling is enabled.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetOcclusionPoolSize,
      BlueprintSetter = SetOcclusionPoolSize,
      Category = "Cesium|Tile Occlusion",
      meta =
          (EditCondition =
               "EnableOcclusionCulling && CanEnableOcclusionCulling",
           ClampMin = "0",
           ClampMax = "1000"))
  int32 OcclusionPoolSize = 500;
 
  /**
   * Whether to wait for valid occlusion results before refining tiles.
   *
   * Only applicable when EnableOcclusionCulling is enabled. When this option
   * is enabled, there may be small delays before tiles are refined, but there
   * may be an overall performance advantage by avoiding loads of descendants
   * that will be found to be occluded.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetDelayRefinementForOcclusion,
      BlueprintSetter = SetDelayRefinementForOcclusion,
      Category = "Cesium|Tile Occlusion",
      meta =
          (EditCondition =
               "EnableOcclusionCulling && CanEnableOcclusionCulling"))
  bool DelayRefinementForOcclusion = true;
 
  /**
   * Refreshes this tileset, ensuring that all materials and other settings are
   * applied. It is not usually necessary to invoke this, but when
   * behind-the-scenes changes are made and not reflected in the tileset, this
   * function can help.
   */
  UFUNCTION(CallInEditor, BlueprintCallable, Category = "Cesium")
  void RefreshTileset();
 
  /**
   * Pauses level-of-detail and culling updates of this tileset.
   */
  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cesium|Debug")
  bool SuspendUpdate;
 
  /**
   * If true, this tileset is ticked/updated in the editor. If false, is only
   * ticked while playing (including Play-in-Editor).
   */
  UPROPERTY(EditAnywhere, Category = "Cesium|Debug")
  bool UpdateInEditor = true;
 
  /**
   * If true, stats about tile selection are printed to the Output Log.
   */
  UPROPERTY(EditAnywhere, Category = "Cesium|Debug")
  bool LogSelectionStats = false;
 
  /**
   * If true, logs stats on the assets in this tileset's shared asset system to
   * the Output Log.
   */
  UPROPERTY(EditAnywhere, Category = "Cesium|Debug")
  bool LogSharedAssetStats = false;
 
  /**
   * If true, draws debug text above each tile being rendered with information
   * about that tile.
   */
  UPROPERTY(EditAnywhere, Category = "Cesium|Debug")
  bool DrawTileInfo = false;
 
  /**
   * Define the collision profile for all the 3D tiles created inside this
   * actor.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadOnly,
      Category = "Collision",
      meta = (ShowOnlyInnerProperties, SkipUCSModifiedProperties))
  FBodyInstance BodyInstance;
 
  /**
   * A delegate that will be called whenever the tileset is fully loaded.
   */
  UPROPERTY(BlueprintAssignable, Category = "Cesium");
  FCompletedLoadTrigger OnTilesetLoaded;
 
  /**
   * Use a dithering effect when transitioning between tiles of different LODs.
   *
   * When this is set to true, Frustrum Culling and Fog Culling are always
   * disabled.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetUseLodTransitions,
      BlueprintSetter = SetUseLodTransitions,
      Category = "Cesium|Rendering")
  bool UseLodTransitions = false;
 
  /**
   * How long dithered LOD transitions between different tiles should take, in
   * seconds.
   *
   * Only relevant if UseLodTransitions is true.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintReadWrite,
      Category = "Cesium|Rendering",
      meta = (EditCondition = "UseLodTransitions", EditConditionHides))
  float LodTransitionLength = 0.5f;
 
private:
  UPROPERTY(BlueprintGetter = GetLoadProgress, Category = "Cesium")
  float LoadProgress = 0.0f;
 
  /**
   * The type of source from which to load this tileset.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetTilesetSource,
      BlueprintSetter = SetTilesetSource,
      Category = "Cesium",
      meta = (DisplayName = "Source"))
  ETilesetSource TilesetSource = ETilesetSource::FromCesiumIon;
 
  /**
   * The URL of this tileset's "tileset.json" file.
   *
   * If this property is specified, the ion asset ID and token are ignored.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetUrl,
      BlueprintSetter = SetUrl,
      Category = "Cesium",
      meta = (EditCondition = "TilesetSource==ETilesetSource::FromUrl"))
  FString Url = "";
 
  /**
   * The ID of the Cesium ion asset to use.
   *
   * This property is ignored if the Url is specified.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetIonAssetID,
      BlueprintSetter = SetIonAssetID,
      Category = "Cesium",
      meta =
          (EditCondition = "TilesetSource==ETilesetSource::FromCesiumIon",
           ClampMin = 0))
  int64 IonAssetID;
 
  /**
   * The access token to use to access the Cesium ion resource.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetIonAccessToken,
      BlueprintSetter = SetIonAccessToken,
      Category = "Cesium",
      meta = (EditCondition = "TilesetSource==ETilesetSource::FromCesiumIon"))
  FString IonAccessToken;
 
  UPROPERTY(
      meta =
          (DeprecatedProperty,
           DeprecationMessage = "Use CesiumIonServer instead."))
  FString IonAssetEndpointUrl_DEPRECATED;
 
  /**
   * The Cesium ion Server from which this tileset is loaded.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetCesiumIonServer,
      BlueprintSetter = SetCesiumIonServer,
      Category = "Cesium",
      AdvancedDisplay,
      meta = (EditCondition = "TilesetSource==ETilesetSource::FromCesiumIon"))
  UCesiumIonServer* CesiumIonServer;
 
  /**
   * Headers to be attached to each request made for this tileset.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetRequestHeaders,
      BlueprintSetter = SetRequestHeaders,
      Category = "Cesium")
  TMap<FString, FString> RequestHeaders;
 
  /**
   * Check if the Cesium ion token used to access this tileset is working
   * correctly, and fix it if necessary.
   */
  UFUNCTION(CallInEditor, Category = "Cesium")
  void TroubleshootToken();
 
  /**
   * Whether to generate physics meshes for this tileset.
   *
   * Disabling this option will improve the performance of tile loading, but it
   * will no longer be possible to collide with the tileset since the physics
   * meshes will not be created.
   *
   * Physics meshes cannot be generated for primitives containing points.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetCreatePhysicsMeshes,
      BlueprintSetter = SetCreatePhysicsMeshes,
      Category = "Cesium|Physics")
  bool CreatePhysicsMeshes = true;
 
  /**
   * Whether to generate navigation collisions for this tileset.
   *
   * Enabling this option creates collisions for navigation when a 3D Tiles
   * tileset is loaded. It is recommended to set "Runtime Generation" to
   * "Static" in the navigation mesh settings in the project settings, as
   * collision calculations become very slow.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetCreateNavCollision,
      BlueprintSetter = SetCreateNavCollision,
      Category = "Cesium|Navigation")
  bool CreateNavCollision = false;
 
  /**
   * Whether to always generate a correct tangent space basis for tiles that
   * don't have them.
   *
   * Normally, a per-vertex tangent space basis is only required for glTF models
   * with a normal map. However, a custom, user-supplied material may need a
   * tangent space basis for other purposes. When this property is set to true,
   * tiles lacking an explicit tangent vector will have one computed
   * automatically using the MikkTSpace algorithm. When this property is false,
   * load time will be improved by skipping the generation of the tangent
   * vector, but the tangent space basis will be unreliable.
   *
   * Note that a tileset with "Enable Water Mask" set will include tangents
   * for tiles containing water, regardless of the value of this property.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetAlwaysIncludeTangents,
      BlueprintSetter = SetAlwaysIncludeTangents,
      Category = "Cesium|Rendering")
  bool AlwaysIncludeTangents = false;
 
  /**
   * Whether to generate smooth normals when normals are missing in the 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.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetGenerateSmoothNormals,
      BlueprintSetter = SetGenerateSmoothNormals,
      Category = "Cesium|Rendering")
  bool GenerateSmoothNormals = false;
 
  /**
   * Whether to request and render the water mask.
   *
   * Currently only applicable for quantized-mesh tilesets that support the
   * water mask extension.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetEnableWaterMask,
      BlueprintSetter = SetEnableWaterMask,
      Category = "Cesium|Rendering")
  bool EnableWaterMask = false;
 
  /**
   * Whether to ignore the KHR_materials_unlit extension on the glTF tiles in
   * this tileset, if it exists, and instead render with standard lighting and
   * shadows. This property will have no effect if the tileset does not have any
   * tiles that use this extension.
   *
   * The KHR_materials_unlit extension is often applied to photogrammetry
   * tilesets because lighting and shadows are already baked into their
   * textures.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetIgnoreKhrMaterialsUnlit,
      BlueprintSetter = SetIgnoreKhrMaterialsUnlit,
      Category = "Cesium|Rendering",
      meta = (DisplayName = "Ignore KHR_materials_unlit"))
  bool IgnoreKhrMaterialsUnlit = false;
 
  /**
   * A custom Material to use to render opaque elements in this tileset, in
   * order to implement custom visual effects.
   *
   * The custom material should generally be created by copying the Material
   * Instance "MI_CesiumThreeOverlaysAndClipping" and customizing the copy as
   * desired.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetMaterial,
      BlueprintSetter = SetMaterial,
      Category = "Cesium|Rendering")
  UMaterialInterface* Material = nullptr;
 
  /**
   * A custom Material to use to render translucent elements of the tileset, in
   * order to implement custom visual effects.
   *
   * The custom material should generally be created by copying the Material
   * Instance "MI_CesiumThreeOverlaysAndClippingTranslucent" and customizing the
   * copy as desired. Make sure that its Material Property Overrides -> Blend
   * Mode is set to "Translucent".
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetTranslucentMaterial,
      BlueprintSetter = SetTranslucentMaterial,
      Category = "Cesium|Rendering")
  UMaterialInterface* TranslucentMaterial = nullptr;
 
  /**
   * A custom Material to use to render this tileset in areas where the
   * watermask is, in order to implement custom visual effects.
   * Currently only applicable for quantized-mesh tilesets that support the
   * water mask extension.
   *
   * The custom material should generally be created by copying the Material
   * Instance "MI_CesiumThreeOverlaysAndClippingAndWater" and customizing the
   * copy as desired.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetWaterMaterial,
      BlueprintSetter = SetWaterMaterial,
      Category = "Cesium|Rendering")
  UMaterialInterface* WaterMaterial = nullptr;
 
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetCustomDepthParameters,
      BlueprintSetter = SetCustomDepthParameters,
      Category = "Rendering",
      meta = (ShowOnlyInnerProperties))
  FCustomDepthParameters CustomDepthParameters;
 
  /**
   * If this tileset contains points, their appearance can be configured with
   * these point cloud shading parameters.
   *
   * These settings are not supported on mobile platforms.
   */
  UPROPERTY(
      EditAnywhere,
      BlueprintGetter = GetPointCloudShading,
      BlueprintSetter = SetPointCloudShading,
      Category = "Cesium|Rendering")
  FCesiumPointCloudShading PointCloudShading;
 
protected:
  UPROPERTY()
  FString PlatformName;
 
public:
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  float GetLoadProgress() const { return LoadProgress; }
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  bool GetUseLodTransitions() const { return UseLodTransitions; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetUseLodTransitions(bool InUseLodTransitions);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  ETilesetSource GetTilesetSource() const { return TilesetSource; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetTilesetSource(ETilesetSource InSource);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  FString GetUrl() const { return Url; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetUrl(const FString& InUrl);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  TMap<FString, FString> GetRequestHeaders() const { return RequestHeaders; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetRequestHeaders(const TMap<FString, FString>& InRequestHeaders);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  int64 GetIonAssetID() const { return IonAssetID; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetIonAssetID(int64 InAssetID);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  FString GetIonAccessToken() const { return IonAccessToken; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetIonAccessToken(const FString& InAccessToken);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  UCesiumIonServer* GetCesiumIonServer() const { return CesiumIonServer; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetCesiumIonServer(UCesiumIonServer* Server);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium")
  double GetMaximumScreenSpaceError() { return MaximumScreenSpaceError; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium")
  void SetMaximumScreenSpaceError(double InMaximumScreenSpaceError);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Tile Culling|Experimental")
  bool GetEnableOcclusionCulling() const;
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Tile Culling|Experimental")
  void SetEnableOcclusionCulling(bool bEnableOcclusionCulling);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Tile Culling|Experimental")
  int32 GetOcclusionPoolSize() const { return OcclusionPoolSize; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Tile Culling|Experimental")
  void SetOcclusionPoolSize(int32 newOcclusionPoolSize);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Tile Culling|Experimental")
  bool GetDelayRefinementForOcclusion() const {
    return DelayRefinementForOcclusion;
  }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Tile Culling|Experimental")
  void SetDelayRefinementForOcclusion(bool bDelayRefinementForOcclusion);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Physics")
  bool GetCreatePhysicsMeshes() const { return CreatePhysicsMeshes; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Physics")
  void SetCreatePhysicsMeshes(bool bCreatePhysicsMeshes);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Navigation")
  bool GetCreateNavCollision() const { return CreateNavCollision; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Navigation")
  void SetCreateNavCollision(bool bCreateNavCollision);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  bool GetAlwaysIncludeTangents() const { return AlwaysIncludeTangents; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetAlwaysIncludeTangents(bool bAlwaysIncludeTangents);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  bool GetGenerateSmoothNormals() const { return GenerateSmoothNormals; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetGenerateSmoothNormals(bool bGenerateSmoothNormals);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  bool GetEnableWaterMask() const { return EnableWaterMask; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetEnableWaterMask(bool bEnableMask);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  bool GetIgnoreKhrMaterialsUnlit() const { return IgnoreKhrMaterialsUnlit; }
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetIgnoreKhrMaterialsUnlit(bool bIgnoreKhrMaterialsUnlit);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  UMaterialInterface* GetMaterial() const { return Material; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetMaterial(UMaterialInterface* InMaterial);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  UMaterialInterface* GetTranslucentMaterial() const {
    return TranslucentMaterial;
  }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetTranslucentMaterial(UMaterialInterface* InMaterial);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  UMaterialInterface* GetWaterMaterial() const { return WaterMaterial; }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetWaterMaterial(UMaterialInterface* InMaterial);
 
  UFUNCTION(BlueprintGetter, Category = "Rendering")
  FCustomDepthParameters GetCustomDepthParameters() const {
    return CustomDepthParameters;
  }
 
  UFUNCTION(BlueprintSetter, Category = "Rendering")
  void SetCustomDepthParameters(FCustomDepthParameters InCustomDepthParameters);
 
  UFUNCTION(BlueprintGetter, Category = "Cesium|Rendering")
  FCesiumPointCloudShading GetPointCloudShading() const {
    return PointCloudShading;
  }
 
  UFUNCTION(BlueprintSetter, Category = "Cesium|Rendering")
  void SetPointCloudShading(FCesiumPointCloudShading InPointCloudShading);
 
  UFUNCTION(BlueprintCallable, Category = "Cesium|Rendering")
  void PlayMovieSequencer();
 
  UFUNCTION(BlueprintCallable, Category = "Cesium|Rendering")
  void StopMovieSequencer();
 
  UFUNCTION(BlueprintCallable, Category = "Cesium|Rendering")
  void PauseMovieSequencer();
 
  /**
   * This method is not supposed to be called by clients. It is currently
   * only required by the UnrealPrepareRendererResources.
   *
   * @internal
   * See {@link
   * UCesium3DTilesetRoot::GetCesiumTilesetToUnrealRelativeWorldTransform}.
   * @endinternal
   */
  const glm::dmat4& GetCesiumTilesetToUnrealRelativeWorldTransform() const;
 
  Cesium3DTilesSelection::Tileset* GetTileset() {
    return this->_pTileset.Get();
  }
  const Cesium3DTilesSelection::Tileset* GetTileset() const {
    return this->_pTileset.Get();
  }
 
  const std::optional<FCesiumFeaturesMetadataDescription>&
  getFeaturesMetadataDescription() const {
    return this->_featuresMetadataDescription;
  }
 
  // AActor overrides (some or most of them should be protected)
  virtual bool ShouldTickIfViewportsOnly() const override;
  virtual void Tick(float DeltaTime) override;
  virtual void BeginDestroy() override;
  virtual bool IsReadyForFinishDestroy() override;
  virtual void Destroyed() override;
  virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
  virtual void PostLoad() override;
  virtual void Serialize(FArchive& Ar) override;
 
  void UpdateLoadStatus();
 
  // UObject overrides
#if WITH_EDITOR
  virtual void
  PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
  virtual void PostEditChangeChainProperty(
      FPropertyChangedChainEvent& PropertyChangedChainEvent) override;
  virtual void PostEditUndo() override;
  virtual void PostEditImport() override;
  virtual bool CanEditChange(const FProperty* InProperty) const override;
#endif
 
protected:
  // Called when the game starts or when spawned
  virtual void BeginPlay() override;
  virtual void OnConstruction(const FTransform& Transform) override;
 
  /**
   * Called after the C++ constructor and after the properties have
   * been initialized, including those loaded from config.
   */
  void PostInitProperties() override;
 
  virtual void NotifyHit(
      class UPrimitiveComponent* MyComp,
      AActor* Other,
      class UPrimitiveComponent* OtherComp,
      bool bSelfMoved,
      FVector HitLocation,
      FVector HitNormal,
      FVector NormalImpulse,
      const FHitResult& Hit) override;
 
private:
  void LoadTileset();
  void DestroyTileset();
 
  static Cesium3DTilesSelection::ViewState CreateViewStateFromViewParameters(
      const FCesiumCamera& camera,
      const glm::dmat4& unrealWorldToTileset,
      UCesiumEllipsoid* ellipsoid);
 
  std::vector<FCesiumCamera> GetCameras() const;
  std::vector<FCesiumCamera> GetPlayerCameras() const;
  std::vector<FCesiumCamera> GetSceneCaptures() const;
 
public:
  /**
   * Update the transforms of the glTF components based on the
   * the transform of the root component.
   *
   * This is supposed to be called during Tick, if the transform of
   * the root component has changed since the previous Tick.
   */
  void UpdateTransformFromCesium();
 
private:
  /**
   * The event handler for ACesiumGeoreference::OnEllipsoidChanged.
   */
  UFUNCTION(CallInEditor)
  void HandleOnGeoreferenceEllipsoidChanged(
      UCesiumEllipsoid* OldEllipsoid,
      UCesiumEllipsoid* NewEllpisoid);
 
  /**
   * Writes the values of all properties of this actor into the
   * TilesetOptions, to take them into account during the next
   * traversal.
   */
  void updateTilesetOptionsFromProperties();
 
  /**
   * Update all the "_last..." fields of this instance based
   * on the given ViewUpdateResult, printing a log message
   * if any value changed.
   *
   * @param result The ViewUpdateREsult
   */
  void updateLastViewUpdateResultState(
      const Cesium3DTilesSelection::ViewUpdateResult& result);
 
  /**
   * Creates the visual representations of the given tiles to
   * be rendered in the current frame.
   *
   * @param tiles The tiles
   */
  void
  showTilesToRender(const std::vector<Cesium3DTilesSelection::Tile*>& tiles);
 
  /**
   * Will be called after the tileset is loaded or spawned, to register
   * a delegate that calls OnFocusEditorViewportOnThis when this
   * tileset is double-clicked
   */
  void AddFocusViewportDelegate();
 
#if WITH_EDITOR
  std::vector<FCesiumCamera> GetEditorCameras() const;
 
  /**
   * Will focus all viewports on this tileset.
   *
   * This is called when double-clicking the tileset in the World Outliner.
   * It will move the tileset into the center of the view, *even if* the
   * tileset was not visible before, and no geometry has been created yet
   * for the tileset: It solely operates on the tile bounding volume that
   * was given in the root tile.
   */
  void OnFocusEditorViewportOnThis();
 
  void RuntimeSettingsChanged(
      UObject* pObject,
      struct FPropertyChangedEvent& changed);
#endif
 
private:
  TUniquePtr<Cesium3DTilesSelection::Tileset> _pTileset;
 
#ifdef CESIUM_DEBUG_TILE_STATES
  TUniquePtr<Cesium3DTilesSelection::DebugTileStateDatabase> _pStateDebug;
#endif
 
  std::optional<FCesiumFeaturesMetadataDescription>
      _featuresMetadataDescription;
 
  PRAGMA_DISABLE_DEPRECATION_WARNINGS
  std::optional<FMetadataDescription> _metadataDescription_DEPRECATED;
  PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
  // For debug output
  uint32_t _lastTilesRendered;
  uint32_t _lastWorkerThreadTileLoadQueueLength;
  uint32_t _lastMainThreadTileLoadQueueLength;
 
  uint32_t _lastTilesVisited;
  uint32_t _lastCulledTilesVisited;
  uint32_t _lastTilesCulled;
  uint32_t _lastTilesOccluded;
  uint32_t _lastTilesWaitingForOcclusionResults;
  uint32_t _lastMaxDepthVisited;
 
  std::chrono::high_resolution_clock::time_point _startTime;
 
  bool _captureMovieMode;
  bool _beforeMoviePreloadAncestors;
  bool _beforeMoviePreloadSiblings;
  int32_t _beforeMovieLoadingDescendantLimit;
  bool _beforeMovieUseLodTransitions;
 
  bool _scaleUsingDPI;
 
  // This is used as a workaround for cesium-native#186
  //
  // The tiles that are no longer supposed to be rendered in the current
  // frame, according to ViewUpdateResult::tilesToHideThisFrame,
  // are kept in this list, and hidden in the NEXT frame, because some
  // internal occlusion culling information from Unreal might prevent
  // the tiles that are supposed to be rendered instead from appearing
  // immediately.
  //
  // If we find a way to clear the wrong occlusion information in the
  // Unreal Engine, then this field may be removed, and the
  // tilesToHideThisFrame may be hidden immediately.
  std::vector<Cesium3DTilesSelection::Tile*> _tilesToHideNextFrame;
 
  int32 _tilesetsBeingDestroyed;
 
  friend class UnrealPrepareRendererResources;
  friend class UCesiumGltfPointsComponent;
};