初始提交: UE5.3项目基础框架

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Asset.h

@@ -0,0 +1,51 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Metadata about the entire tileset.
+ */
+struct CESIUM3DTILES_API Asset final : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Asset";
+
+  /**
+   * @brief The 3D Tiles version. The version defines the JSON schema for the
+   * tileset JSON and the base set of tile formats.
+   */
+  std::string version;
+
+  /**
+   * @brief Application-specific version of this tileset, e.g., for when an
+   * existing tileset is updated.
+   */
+  std::optional<std::string> tilesetVersion;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Asset));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(this->version.capacity() * sizeof(char));
+    if (this->tilesetVersion) {
+      accum += int64_t(this->tilesetVersion->capacity() * sizeof(char));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Availability.h

@@ -0,0 +1,72 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object describing the availability of a set of elements.
+ */
+struct CESIUM3DTILES_API Availability final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Availability";
+
+  /**
+   * @brief Known values for Integer indicating whether all of the elements are
+   * available (1) or all are unavailable (0).
+   */
+  struct Constant {
+    /** @brief UNAVAILABLE (`0`) */
+    static constexpr int32_t UNAVAILABLE = 0;
+
+    /** @brief AVAILABLE (`1`) */
+    static constexpr int32_t AVAILABLE = 1;
+  };
+
+  /**
+   * @brief Index of a buffer view that indicates whether each element is
+   * available. The bitstream conforms to the boolean array encoding described
+   * in the 3D Metadata specification. If an element is available, its bit is 1,
+   * and if it is unavailable, its bit is 0.
+   */
+  std::optional<int64_t> bitstream;
+
+  /**
+   * @brief A number indicating how many 1 bits exist in the availability
+   * bitstream.
+   */
+  std::optional<int64_t> availableCount;
+
+  /**
+   * @brief Integer indicating whether all of the elements are available (1) or
+   * all are unavailable (0).
+   *
+   * Known values are defined in {@link Constant}.
+   *
+   */
+  std::optional<int32_t> constant;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Availability));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/BoundingVolume.h

@@ -0,0 +1,70 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <vector>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A bounding volume that encloses a tile or its content. At least one
+ * bounding volume property is required. Bounding volumes include `box`,
+ * `region`, or `sphere`.
+ */
+struct CESIUM3DTILES_API BoundingVolume final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "BoundingVolume";
+
+  /**
+   * @brief An array of 12 numbers that define an oriented bounding box. The
+   * first three elements define the x, y, and z values for the center of the
+   * box. The next three elements (with indices 3, 4, and 5) define the x axis
+   * direction and half-length. The next three elements (indices 6, 7, and 8)
+   * define the y axis direction and half-length. The last three elements
+   * (indices 9, 10, and 11) define the z axis direction and half-length.
+   */
+  std::vector<double> box;
+
+  /**
+   * @brief An array of six numbers that define a bounding geographic region in
+   * EPSG:4979 coordinates with the order [west, south, east, north, minimum
+   * height, maximum height]. Longitudes and latitudes are in radians. The range
+   * for latitudes is [-PI/2,PI/2]. The range for longitudes is [-PI,PI]. The
+   * value that is given as the 'south' of the region shall not be larger than
+   * the value for the 'north' of the region. The heights are in meters above
+   * (or below) the WGS84 ellipsoid. The 'minimum height' shall not be larger
+   * than the 'maximum height'.
+   */
+  std::vector<double> region;
+
+  /**
+   * @brief An array of four numbers that define a bounding sphere. The first
+   * three elements define the x, y, and z values for the center of the sphere.
+   * The last element (with index 3) defines the radius in meters. The radius
+   * shall not be negative.
+   */
+  std::vector<double> sphere;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(BoundingVolume));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(sizeof(double) * this->box.capacity());
+    accum += int64_t(sizeof(double) * this->region.capacity());
+    accum += int64_t(sizeof(double) * this->sphere.capacity());
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Buffer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <Cesium3DTiles/BufferCesium.h>
+#include <Cesium3DTiles/BufferSpec.h>
+#include <Cesium3DTiles/Library.h>
+
+namespace Cesium3DTiles {
+/** @copydoc BufferSpec */
+struct CESIUM3DTILES_API Buffer final : public BufferSpec {
+  Buffer() = default;
+
+  /**
+   * @brief Holds properties that are specific to the 3D Tiles loader rather
+   * than part of the 3D Tiles spec.
+   */
+  BufferCesium cesium;
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/BufferCesium.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+
+#include <cstddef>
+#include <vector>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Holds {@link Buffer} properties that are specific to the 3D Tiles loader
+ * rather than part of the 3D Tiles spec.
+ */
+struct CESIUM3DTILES_API BufferCesium final {
+  /**
+   * @brief The buffer's data.
+   */
+  std::vector<std::byte> data;
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/BufferSpec.h

@@ -0,0 +1,69 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A buffer is a binary blob. It is either the binary chunk of the
+ * subtree file, or an external buffer referenced by a URI.
+ */
+struct CESIUM3DTILES_API BufferSpec : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Buffer";
+
+  /**
+   * @brief The URI (or IRI) of the file that contains the binary buffer data.
+   * Relative paths are relative to the file containing the buffer JSON. `uri`
+   * is required when using the JSON subtree format and not required when using
+   * the binary subtree format - when omitted the buffer refers to the binary
+   * chunk of the subtree file. Data URIs are not allowed.
+   */
+  std::optional<std::string> uri;
+
+  /**
+   * @brief The length of the buffer in bytes.
+   */
+  int64_t byteLength = int64_t();
+
+  /**
+   * @brief The name of the buffer.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(BufferSpec));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->uri) {
+      accum += int64_t(this->uri->capacity() * sizeof(char));
+    }
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    return accum;
+  }
+
+protected:
+  /**
+   * @brief This class is not meant to be instantiated directly. Use {@link Buffer} instead.
+   */
+  BufferSpec() = default;
+  friend struct Buffer;
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/BufferView.h

@@ -0,0 +1,60 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A contiguous subset of a buffer
+ */
+struct CESIUM3DTILES_API BufferView final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "BufferView";
+
+  /**
+   * @brief The index of the buffer.
+   */
+  int64_t buffer = int64_t();
+
+  /**
+   * @brief The offset into the buffer in bytes.
+   */
+  int64_t byteOffset = int64_t();
+
+  /**
+   * @brief The total byte length of the buffer view.
+   */
+  int64_t byteLength = int64_t();
+
+  /**
+   * @brief The name of the `bufferView`.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(BufferView));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Class.h

@@ -0,0 +1,67 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/ClassProperty.h>
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A class containing a set of properties.
+ */
+struct CESIUM3DTILES_API Class final : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Class";
+
+  /**
+   * @brief The name of the class, e.g. for display purposes.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief The description of the class.
+   */
+  std::optional<std::string> description;
+
+  /**
+   * @brief A dictionary, where each key is a property ID and each value is an
+   * object defining the property. Property IDs shall be alphanumeric
+   * identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::ClassProperty> properties;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Class));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    if (this->description) {
+      accum += int64_t(this->description->capacity() * sizeof(char));
+    }
+    accum += int64_t(
+        this->properties.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::ClassProperty)));
+    for (const auto& [k, v] : this->properties) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += v.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::ClassProperty));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/ClassProperty.h

@@ -0,0 +1,241 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+#include <CesiumUtility/JsonValue.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A single property of a metadata class.
+ */
+struct CESIUM3DTILES_API ClassProperty final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "ClassProperty";
+
+  /**
+   * @brief Known values for The element type.
+   */
+  struct Type {
+    /** @brief `SCALAR` */
+    inline static const std::string SCALAR = "SCALAR";
+
+    /** @brief `VEC2` */
+    inline static const std::string VEC2 = "VEC2";
+
+    /** @brief `VEC3` */
+    inline static const std::string VEC3 = "VEC3";
+
+    /** @brief `VEC4` */
+    inline static const std::string VEC4 = "VEC4";
+
+    /** @brief `MAT2` */
+    inline static const std::string MAT2 = "MAT2";
+
+    /** @brief `MAT3` */
+    inline static const std::string MAT3 = "MAT3";
+
+    /** @brief `MAT4` */
+    inline static const std::string MAT4 = "MAT4";
+
+    /** @brief `STRING` */
+    inline static const std::string STRING = "STRING";
+
+    /** @brief `BOOLEAN` */
+    inline static const std::string BOOLEAN = "BOOLEAN";
+
+    /** @brief `ENUM` */
+    inline static const std::string ENUM = "ENUM";
+  };
+
+  /**
+   * @brief Known values for The datatype of the element's components. Required
+   * for `SCALAR`, `VECN`, and `MATN` types, and disallowed for other types.
+   */
+  struct ComponentType {
+    /** @brief `INT8` */
+    inline static const std::string INT8 = "INT8";
+
+    /** @brief `UINT8` */
+    inline static const std::string UINT8 = "UINT8";
+
+    /** @brief `INT16` */
+    inline static const std::string INT16 = "INT16";
+
+    /** @brief `UINT16` */
+    inline static const std::string UINT16 = "UINT16";
+
+    /** @brief `INT32` */
+    inline static const std::string INT32 = "INT32";
+
+    /** @brief `UINT32` */
+    inline static const std::string UINT32 = "UINT32";
+
+    /** @brief `INT64` */
+    inline static const std::string INT64 = "INT64";
+
+    /** @brief `UINT64` */
+    inline static const std::string UINT64 = "UINT64";
+
+    /** @brief `FLOAT32` */
+    inline static const std::string FLOAT32 = "FLOAT32";
+
+    /** @brief `FLOAT64` */
+    inline static const std::string FLOAT64 = "FLOAT64";
+  };
+
+  /**
+   * @brief The name of the property, e.g. for display purposes.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief The description of the property.
+   */
+  std::optional<std::string> description;
+
+  /**
+   * @brief The element type.
+   *
+   * Known values are defined in {@link Type}.
+   *
+   */
+  std::string type = Type::SCALAR;
+
+  /**
+   * @brief The datatype of the element's components. Required for `SCALAR`,
+   * `VECN`, and `MATN` types, and disallowed for other types.
+   *
+   * Known values are defined in {@link ComponentType}.
+   *
+   */
+  std::optional<std::string> componentType;
+
+  /**
+   * @brief Enum ID as declared in the `enums` dictionary. Required when `type`
+   * is `ENUM`. Disallowed when `type` is not `ENUM`
+   */
+  std::optional<std::string> enumType;
+
+  /**
+   * @brief Whether the property is an array. When `count` is defined the
+   * property is a fixed-length array. Otherwise the property is a
+   * variable-length array.
+   */
+  bool array = false;
+
+  /**
+   * @brief The number of array elements. May only be defined when `array` is
+   * `true`.
+   */
+  std::optional<int64_t> count;
+
+  /**
+   * @brief Specifies whether integer values are normalized. Only applicable to
+   * `SCALAR`, `VECN`, and `MATN` types with integer component types. For
+   * unsigned integer component types, values are normalized between
+   * `[0.0, 1.0]`. For signed integer component types, values are normalized
+   * between `[-1.0, 1.0]`. For all other component types, this property shall
+   * be false.
+   */
+  bool normalized = false;
+
+  /**
+   * @brief An offset to apply to property values. Only applicable to `SCALAR`,
+   * `VECN`, and `MATN` types when the component type is `FLOAT32` or `FLOAT64`,
+   * or when the property is `normalized`. Not applicable to variable-length
+   * arrays.
+   */
+  std::optional<CesiumUtility::JsonValue> offset;
+
+  /**
+   * @brief A scale to apply to property values. Only applicable to `SCALAR`,
+   * `VECN`, and `MATN` types when the component type is `FLOAT32` or `FLOAT64`,
+   * or when the property is `normalized`. Not applicable to variable-length
+   * arrays.
+   */
+  std::optional<CesiumUtility::JsonValue> scale;
+
+  /**
+   * @brief Maximum allowed value for the property. Only applicable to `SCALAR`,
+   * `VECN`, and `MATN` types. This is the maximum of all property values, after
+   * the transforms based on the `normalized`, `offset`, and `scale` properties
+   * have been applied. Not applicable to variable-length arrays.
+   */
+  std::optional<CesiumUtility::JsonValue> max;
+
+  /**
+   * @brief Minimum allowed value for the property. Only applicable to `SCALAR`,
+   * `VECN`, and `MATN` types. This is the minimum of all property values, after
+   * the transforms based on the `normalized`, `offset`, and `scale` properties
+   * have been applied. Not applicable to variable-length arrays.
+   */
+  std::optional<CesiumUtility::JsonValue> min;
+
+  /**
+   * @brief If required, the property shall be present in every entity
+   * conforming to the class. If not required, individual entities may include
+   * `noData` values, or the entire property may be omitted. As a result,
+   * `noData` has no effect on a required property. Client implementations may
+   * use required properties to make performance optimizations.
+   */
+  bool required = false;
+
+  /**
+   * @brief A `noData` value represents missing data — also known as a sentinel
+   * value — wherever it appears. `BOOLEAN` properties may not specify `noData`
+   * values. This is given as the plain property value, without the transforms
+   * from the `normalized`, `offset`, and `scale` properties. Shall not be
+   * defined if `required` is true.
+   */
+  std::optional<CesiumUtility::JsonValue> noData;
+
+  /**
+   * @brief A default value to use when encountering a `noData` value or an
+   * omitted property. The value is given in its final form, taking the effect
+   * of `normalized`, `offset`, and `scale` properties into account. Shall not
+   * be defined if `required` is true.
+   */
+  std::optional<CesiumUtility::JsonValue> defaultProperty;
+
+  /**
+   * @brief An identifier that describes how this property should be
+   * interpreted. The semantic cannot be used by other properties in the class.
+   */
+  std::optional<std::string> semantic;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(ClassProperty));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    if (this->description) {
+      accum += int64_t(this->description->capacity() * sizeof(char));
+    }
+    if (this->enumType) {
+      accum += int64_t(this->enumType->capacity() * sizeof(char));
+    }
+    if (this->semantic) {
+      accum += int64_t(this->semantic->capacity() * sizeof(char));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/ClassStatistics.h

@@ -0,0 +1,60 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/PropertyStatistics.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Statistics about entities that conform to a class that was defined in
+ * a metadata schema.
+ */
+struct CESIUM3DTILES_API ClassStatistics final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "ClassStatistics";
+
+  /**
+   * @brief The number of entities that conform to the class.
+   */
+  std::optional<int64_t> count;
+
+  /**
+   * @brief A dictionary, where each key corresponds to a property ID in the
+   * class' `properties` dictionary and each value is an object containing
+   * statistics about property values.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::PropertyStatistics> properties;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(ClassStatistics));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(
+        this->properties.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::PropertyStatistics)));
+    for (const auto& [k, v] : this->properties) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum +=
+          v.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::PropertyStatistics));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Content.h

@@ -0,0 +1,73 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/BoundingVolume.h>
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/MetadataEntity.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Metadata about the tile's content and a link to the content.
+ */
+struct CESIUM3DTILES_API Content final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Content";
+
+  /**
+   * @brief An optional bounding volume that tightly encloses tile content.
+   * tile.boundingVolume provides spatial coherence and
+   * tile.content.boundingVolume enables tight view frustum culling. When this
+   * is omitted, tile.boundingVolume is used.
+   */
+  std::optional<Cesium3DTiles::BoundingVolume> boundingVolume;
+
+  /**
+   * @brief A uri that points to tile content. When the uri is relative, it is
+   * relative to the referring tileset JSON file.
+   */
+  std::string uri;
+
+  /**
+   * @brief Metadata that is associated with this content.
+   */
+  std::optional<Cesium3DTiles::MetadataEntity> metadata;
+
+  /**
+   * @brief The group this content belongs to. The value is an index into the
+   * array of `groups` that is defined for the containing tileset.
+   */
+  std::optional<int64_t> group;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Content));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->boundingVolume) {
+      accum += this->boundingVolume->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::BoundingVolume));
+    }
+    accum += int64_t(this->uri.capacity() * sizeof(char));
+    if (this->metadata) {
+      accum += this->metadata->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::MetadataEntity));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Enum.h

@@ -0,0 +1,101 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/EnumValue.h>
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object defining the values of an enum.
+ */
+struct CESIUM3DTILES_API Enum final : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Enum";
+
+  /**
+   * @brief Known values for The type of the integer enum value.
+   */
+  struct ValueType {
+    /** @brief `INT8` */
+    inline static const std::string INT8 = "INT8";
+
+    /** @brief `UINT8` */
+    inline static const std::string UINT8 = "UINT8";
+
+    /** @brief `INT16` */
+    inline static const std::string INT16 = "INT16";
+
+    /** @brief `UINT16` */
+    inline static const std::string UINT16 = "UINT16";
+
+    /** @brief `INT32` */
+    inline static const std::string INT32 = "INT32";
+
+    /** @brief `UINT32` */
+    inline static const std::string UINT32 = "UINT32";
+
+    /** @brief `INT64` */
+    inline static const std::string INT64 = "INT64";
+
+    /** @brief `UINT64` */
+    inline static const std::string UINT64 = "UINT64";
+  };
+
+  /**
+   * @brief The name of the enum, e.g. for display purposes.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief The description of the enum.
+   */
+  std::optional<std::string> description;
+
+  /**
+   * @brief The type of the integer enum value.
+   *
+   * Known values are defined in {@link ValueType}.
+   *
+   */
+  std::string valueType = ValueType::UINT16;
+
+  /**
+   * @brief An array of enum values. Duplicate names or duplicate integer values
+   * are not allowed.
+   */
+  std::vector<Cesium3DTiles::EnumValue> values;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Enum));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    if (this->description) {
+      accum += int64_t(this->description->capacity() * sizeof(char));
+    }
+    accum +=
+        int64_t(sizeof(Cesium3DTiles::EnumValue) * this->values.capacity());
+    for (const Cesium3DTiles::EnumValue& value : this->values) {
+      accum += value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::EnumValue));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/EnumValue.h

@@ -0,0 +1,56 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An enum value.
+ */
+struct CESIUM3DTILES_API EnumValue final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "EnumValue";
+
+  /**
+   * @brief The name of the enum value.
+   */
+  std::string name;
+
+  /**
+   * @brief The description of the enum value.
+   */
+  std::optional<std::string> description;
+
+  /**
+   * @brief The integer enum value.
+   */
+  int64_t value = int64_t();
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(EnumValue));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(this->name.capacity() * sizeof(char));
+    if (this->description) {
+      accum += int64_t(this->description->capacity() * sizeof(char));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Extension3dTilesBoundingVolumeS2.h

@@ -0,0 +1,58 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief 3D Tiles extension for S2 bounding volumes.
+ */
+struct CESIUM3DTILES_API Extension3dTilesBoundingVolumeS2 final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Extension3dTilesBoundingVolumeS2";
+  /** @brief The official name of the extension. This should be the same as its
+   * key in the `extensions` object. */
+  static constexpr const char* ExtensionName = "3DTILES_bounding_volume_S2";
+
+  /**
+   * @brief A hexadecimal representation of the S2CellId. Tokens shall be
+   * lower-case, shall not contain whitespace and shall have trailing zeros
+   * stripped.
+   */
+  std::string token;
+
+  /**
+   * @brief The minimum height of the tile, specified in meters above (or below)
+   * the WGS84 ellipsoid.
+   */
+  double minimumHeight = double();
+
+  /**
+   * @brief The maximum height of the tile, specified in meters above (or below)
+   * the WGS84 ellipsoid.
+   */
+  double maximumHeight = double();
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Extension3dTilesBoundingVolumeS2));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(this->token.capacity() * sizeof(char));
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/GroupMetadata.h

@@ -0,0 +1,32 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/MetadataEntity.h>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object containing metadata about a group.
+ */
+struct CESIUM3DTILES_API GroupMetadata final : public MetadataEntity {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "GroupMetadata";
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(GroupMetadata));
+    accum += MetadataEntity::getSizeBytes() - int64_t(sizeof(MetadataEntity));
+
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/ImplicitTiling.h

@@ -0,0 +1,78 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/Subtrees.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief This object allows a tile to be implicitly subdivided. Tile and
+ * content availability and metadata is stored in subtrees which are referenced
+ * externally.
+ */
+struct CESIUM3DTILES_API ImplicitTiling final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "ImplicitTiling";
+
+  /**
+   * @brief Known values for A string describing the subdivision scheme used
+   * within the tileset.
+   */
+  struct SubdivisionScheme {
+    /** @brief `QUADTREE` */
+    inline static const std::string QUADTREE = "QUADTREE";
+
+    /** @brief `OCTREE` */
+    inline static const std::string OCTREE = "OCTREE";
+  };
+
+  /**
+   * @brief A string describing the subdivision scheme used within the tileset.
+   *
+   * Known values are defined in {@link SubdivisionScheme}.
+   *
+   */
+  std::string subdivisionScheme = SubdivisionScheme::QUADTREE;
+
+  /**
+   * @brief The number of distinct levels in each subtree. For example, a
+   * quadtree with `subtreeLevels = 2` will have subtrees with 5 nodes (one root
+   * and 4 children).
+   */
+  int64_t subtreeLevels = int64_t();
+
+  /**
+   * @brief The numbers of the levels in the tree with available tiles.
+   */
+  int64_t availableLevels = int64_t();
+
+  /**
+   * @brief An object describing the location of subtree files.
+   */
+  Cesium3DTiles::Subtrees subtrees;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(ImplicitTiling));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += this->subtrees.getSizeBytes() -
+             int64_t(sizeof(Cesium3DTiles::Subtrees));
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Library.h

@@ -0,0 +1,18 @@
+#pragma once
+
+/**
+ * @brief Classes for using [3D Tiles](https://github.com/CesiumGS/3d-tiles).
+ *
+ * @mermaid-interactive{dependencies/Cesium3DTiles}
+ */
+namespace Cesium3DTiles {}
+
+#if defined(_WIN32) && defined(CESIUM_SHARED)
+#ifdef CESIUM3DTILES_BUILDING
+#define CESIUM3DTILES_API __declspec(dllexport)
+#else
+#define CESIUM3DTILES_API __declspec(dllimport)
+#endif
+#else
+#define CESIUM3DTILES_API
+#endif

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/MetadataEntity.h

@@ -0,0 +1,64 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+#include <CesiumUtility/JsonValue.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object containing a reference to a class from a metadata schema,
+ * and property values that conform to the properties of that class.
+ */
+struct CESIUM3DTILES_API MetadataEntity
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "MetadataEntity";
+
+  /**
+   * @brief The class that property values conform to. The value shall be a
+   * class ID declared in the `classes` dictionary of the metadata schema.
+   */
+  std::string classProperty;
+
+  /**
+   * @brief A dictionary, where each key corresponds to a property ID in the
+   * class' `properties` dictionary and each value contains the property values.
+   * The type of the value shall match the property definition: For `BOOLEAN`
+   * use `true` or `false`. For `STRING` use a JSON string. For numeric types
+   * use a JSON number. For `ENUM` use a valid enum `name`, not an integer
+   * value. For `ARRAY`, `VECN`, and `MATN` types use a JSON array containing
+   * values matching the `componentType`. Required properties shall be included
+   * in this dictionary.
+   */
+  std::unordered_map<std::string, CesiumUtility::JsonValue> properties;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(MetadataEntity));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(this->classProperty.capacity() * sizeof(char));
+    accum += int64_t(
+        this->properties.bucket_count() *
+        (sizeof(std::string) + sizeof(CesiumUtility::JsonValue)));
+    for (const auto& [k, v] : this->properties) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += int64_t(sizeof(CesiumUtility::JsonValue));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/MetadataQuery.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <Cesium3DTiles/MetadataEntity.h>
+#include <Cesium3DTiles/Schema.h>
+#include <CesiumUtility/JsonValue.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+
+/**
+ * @brief Holds the details of a found property in a {@link MetadataEntity}.
+ *
+ * Because this structure holds _references_ to the original {@link Schema} and
+ * {@link MetadataEntity} instances, it will be invalided if either are
+ * destroyed or modified. Continuing to access this result in that scenario will
+ * result in undefined behavior.
+ */
+struct CESIUM3DTILES_API FoundMetadataProperty {
+  /**
+   * @brief A reference to the identifier of the class that contains the found
+   * property within the {@link Schema}.
+   */
+  const std::string& classIdentifier;
+
+  /**
+   * @brief A reference to the {@link Class} that contains the found property
+   * within the {@link Schema}.
+   */
+  const Class& classDefinition;
+
+  /**
+   * @brief A reference to the identifier of the found property within the
+   * {@link Schema}.
+   */
+  const std::string& propertyIdentifier;
+
+  /**
+   * @brief A reference to the {@link ClassProperty} describing the found
+   * property within the {@link Schema}.
+   */
+  const ClassProperty& propertyDefinition;
+
+  /**
+   * @brief A reference to the value of the found property within the
+   * {@link MetadataEntity}.
+   */
+  const CesiumUtility::JsonValue& propertyValue;
+};
+
+/**
+ * @brief Convenience functions for querying {@link MetadataEntity} instances.
+ */
+class CESIUM3DTILES_API MetadataQuery {
+public:
+  /**
+   * @brief Gets the first property with a given
+   * {@link ClassProperty::semantic}.
+   *
+   * @param schema The schema to use to look up semantics.
+   * @param entity The metadata entity to search for a property with the
+   * semantic.
+   * @param semantic The semantic to find.
+   * @return The details of the found property, or `std::nullopt` if a property
+   * with the given semantic does not exist.
+   */
+  static std::optional<FoundMetadataProperty> findFirstPropertyWithSemantic(
+      const Schema& schema,
+      const MetadataEntity& entity,
+      const std::string& semantic);
+};
+
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Properties.h

@@ -0,0 +1,46 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A dictionary object of metadata about per-feature properties.
+ */
+struct CESIUM3DTILES_API Properties final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Properties";
+
+  /**
+   * @brief The maximum value of this property of all the features in the
+   * tileset. The maximum value shall not be smaller than the minimum value.
+   */
+  double maximum = double();
+
+  /**
+   * @brief The minimum value of this property of all the features in the
+   * tileset. The maximum value shall not be smaller than the minimum value.
+   */
+  double minimum = double();
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Properties));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/PropertyStatistics.h

@@ -0,0 +1,109 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+#include <CesiumUtility/JsonValue.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Statistics about property values.
+ */
+struct CESIUM3DTILES_API PropertyStatistics final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "PropertyStatistics";
+
+  /**
+   * @brief The minimum property value occurring in the tileset. Only applicable
+   * to `SCALAR`, `VECN`, and `MATN` types. This is the minimum of all property
+   * values, after the transforms based on the `normalized`, `offset`, and
+   * `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> min;
+
+  /**
+   * @brief The maximum property value occurring in the tileset. Only applicable
+   * to `SCALAR`, `VECN`, and `MATN` types. This is the maximum of all property
+   * values, after the transforms based on the `normalized`, `offset`, and
+   * `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> max;
+
+  /**
+   * @brief The arithmetic mean of property values occurring in the tileset.
+   * Only applicable to `SCALAR`, `VECN`, and `MATN` types. This is the mean of
+   * all property values, after the transforms based on the `normalized`,
+   * `offset`, and `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> mean;
+
+  /**
+   * @brief The median of property values occurring in the tileset. Only
+   * applicable to `SCALAR`, `VECN`, and `MATN` types. This is the median of all
+   * property values, after the transforms based on the `normalized`, `offset`,
+   * and `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> median;
+
+  /**
+   * @brief The standard deviation of property values occurring in the tileset.
+   * Only applicable to `SCALAR`, `VECN`, and `MATN` types. This is the standard
+   * deviation of all property values, after the transforms based on the
+   * `normalized`, `offset`, and `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> standardDeviation;
+
+  /**
+   * @brief The variance of property values occurring in the tileset. Only
+   * applicable to `SCALAR`, `VECN`, and `MATN` types. This is the variance of
+   * all property values, after the transforms based on the `normalized`,
+   * `offset`, and `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> variance;
+
+  /**
+   * @brief The sum of property values occurring in the tileset. Only applicable
+   * to `SCALAR`, `VECN`, and `MATN` types. This is the sum of all property
+   * values, after the transforms based on the `normalized`, `offset`, and
+   * `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> sum;
+
+  /**
+   * @brief A dictionary, where each key corresponds to an enum `name` and each
+   * value is the number of occurrences of that enum. Only applicable when
+   * `type` is `ENUM`. For fixed-length arrays, this is an array of
+   * component-wise occurrences.
+   */
+  std::unordered_map<std::string, CesiumUtility::JsonValue> occurrences;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(PropertyStatistics));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(
+        this->occurrences.bucket_count() *
+        (sizeof(std::string) + sizeof(CesiumUtility::JsonValue)));
+    for (const auto& [k, v] : this->occurrences) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += int64_t(sizeof(CesiumUtility::JsonValue));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/PropertyTable.h

@@ -0,0 +1,77 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/PropertyTableProperty.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Properties conforming to a class, organized as property values stored
+ * in binary columnar arrays.
+ */
+struct CESIUM3DTILES_API PropertyTable final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "PropertyTable";
+
+  /**
+   * @brief The name of the property table, e.g. for display purposes.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief The class that property values conform to. The value shall be a
+   * class ID declared in the `classes` dictionary.
+   */
+  std::string classProperty;
+
+  /**
+   * @brief The number of elements in each property array.
+   */
+  int64_t count = int64_t();
+
+  /**
+   * @brief A dictionary, where each key corresponds to a property ID in the
+   * class' `properties` dictionary and each value is an object describing where
+   * property values are stored. Required properties shall be included in this
+   * dictionary.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::PropertyTableProperty>
+      properties;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(PropertyTable));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    accum += int64_t(this->classProperty.capacity() * sizeof(char));
+    accum += int64_t(
+        this->properties.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::PropertyTableProperty)));
+    for (const auto& [k, v] : this->properties) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += v.getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::PropertyTableProperty));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/PropertyTableProperty.h

@@ -0,0 +1,164 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+#include <CesiumUtility/JsonValue.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An array of binary property values. This represents one column of a
+ * property table, and contains one value of a certain property for each
+ * metadata entity.
+ */
+struct CESIUM3DTILES_API PropertyTableProperty final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "PropertyTableProperty";
+
+  /**
+   * @brief Known values for The type of values in `arrayOffsets`.
+   */
+  struct ArrayOffsetType {
+    /** @brief `UINT8` */
+    inline static const std::string UINT8 = "UINT8";
+
+    /** @brief `UINT16` */
+    inline static const std::string UINT16 = "UINT16";
+
+    /** @brief `UINT32` */
+    inline static const std::string UINT32 = "UINT32";
+
+    /** @brief `UINT64` */
+    inline static const std::string UINT64 = "UINT64";
+  };
+
+  /**
+   * @brief Known values for The type of values in `stringOffsets`.
+   */
+  struct StringOffsetType {
+    /** @brief `UINT8` */
+    inline static const std::string UINT8 = "UINT8";
+
+    /** @brief `UINT16` */
+    inline static const std::string UINT16 = "UINT16";
+
+    /** @brief `UINT32` */
+    inline static const std::string UINT32 = "UINT32";
+
+    /** @brief `UINT64` */
+    inline static const std::string UINT64 = "UINT64";
+  };
+
+  /**
+   * @brief The index of the buffer view containing property values. The data
+   * type of property values is determined by the property definition: When
+   * `type` is `BOOLEAN` values are packed into a bitstream. When `type` is
+   * `STRING` values are stored as byte sequences and decoded as UTF-8 strings.
+   * When `type` is `SCALAR`, `VECN`, or `MATN` the values are stored as the
+   * provided `componentType` and the buffer view `byteOffset` shall be aligned
+   * to a multiple of the `componentType` size. When `type` is `ENUM` values are
+   * stored as the enum's `valueType` and the buffer view `byteOffset` shall be
+   * aligned to a multiple of the `valueType` size. Each enum value in the array
+   * shall match one of the allowed values in the enum definition.
+   * `arrayOffsets` is required for variable-length arrays and `stringOffsets`
+   * is required for strings (for variable-length arrays of strings, both are
+   * required).
+   */
+  int64_t values = int64_t();
+
+  /**
+   * @brief The index of the buffer view containing offsets for variable-length
+   * arrays. The number of offsets is equal to the property table `count` plus
+   * one. The offsets represent the start positions of each array, with the last
+   * offset representing the position after the last array. The array length is
+   * computed using the difference between the subsequent offset and the current
+   * offset. If `type` is `STRING` the offsets index into the string offsets
+   * array (stored in `stringOffsets`), otherwise they index into the property
+   * array (stored in `values`). The data type of these offsets is determined by
+   * `arrayOffsetType`. The buffer view `byteOffset` shall be aligned to a
+   * multiple of the `arrayOffsetType` size.
+   */
+  std::optional<int64_t> arrayOffsets;
+
+  /**
+   * @brief The index of the buffer view containing offsets for strings. The
+   * number of offsets is equal to the number of string elements plus one. The
+   * offsets represent the byte offsets of each string in the property array
+   * (stored in `values`), with the last offset representing the byte offset
+   * after the last string. The string byte length is computed using the
+   * difference between the subsequent offset and the current offset. The data
+   * type of these offsets is determined by `stringOffsetType`. The buffer view
+   * `byteOffset` shall be aligned to a multiple of the `stringOffsetType` size.
+   */
+  std::optional<int64_t> stringOffsets;
+
+  /**
+   * @brief The type of values in `arrayOffsets`.
+   *
+   * Known values are defined in {@link ArrayOffsetType}.
+   *
+   */
+  std::string arrayOffsetType = ArrayOffsetType::UINT32;
+
+  /**
+   * @brief The type of values in `stringOffsets`.
+   *
+   * Known values are defined in {@link StringOffsetType}.
+   *
+   */
+  std::string stringOffsetType = StringOffsetType::UINT32;
+
+  /**
+   * @brief An offset to apply to property values. Only applicable when the
+   * component type is `FLOAT32` or `FLOAT64`, or when the property is
+   * `normalized`. Overrides the class property's `offset` if both are defined.
+   */
+  std::optional<CesiumUtility::JsonValue> offset;
+
+  /**
+   * @brief A scale to apply to property values. Only applicable when the
+   * component type is `FLOAT32` or `FLOAT64`, or when the property is
+   * `normalized`. Overrides the class property's `scale` if both are defined.
+   */
+  std::optional<CesiumUtility::JsonValue> scale;
+
+  /**
+   * @brief Maximum value present in the property values. Only applicable to
+   * `SCALAR`, `VECN`, and `MATN` types. This is the maximum of all property
+   * values, after the transforms based on the `normalized`, `offset`, and
+   * `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> max;
+
+  /**
+   * @brief Minimum value present in the property values. Only applicable to
+   * `SCALAR`, `VECN`, and `MATN` types. This is the minimum of all property
+   * values, after the transforms based on the `normalized`, `offset`, and
+   * `scale` properties have been applied.
+   */
+  std::optional<CesiumUtility::JsonValue> min;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(PropertyTableProperty));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Schema.h

@@ -0,0 +1,97 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Class.h>
+#include <Cesium3DTiles/Enum.h>
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object defining classes and enums.
+ */
+struct CESIUM3DTILES_API Schema final : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Schema";
+
+  /**
+   * @brief Unique identifier for the schema. Schema IDs shall be alphanumeric
+   * identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`.
+   */
+  std::string id;
+
+  /**
+   * @brief The name of the schema, e.g. for display purposes.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * @brief The description of the schema.
+   */
+  std::optional<std::string> description;
+
+  /**
+   * @brief Application-specific version of the schema.
+   */
+  std::optional<std::string> version;
+
+  /**
+   * @brief A dictionary, where each key is a class ID and each value is an
+   * object defining the class. Class IDs shall be alphanumeric identifiers
+   * matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::Class> classes;
+
+  /**
+   * @brief A dictionary, where each key is an enum ID and each value is an
+   * object defining the values for the enum. Enum IDs shall be alphanumeric
+   * identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::Enum> enums;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Schema));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(this->id.capacity() * sizeof(char));
+    if (this->name) {
+      accum += int64_t(this->name->capacity() * sizeof(char));
+    }
+    if (this->description) {
+      accum += int64_t(this->description->capacity() * sizeof(char));
+    }
+    if (this->version) {
+      accum += int64_t(this->version->capacity() * sizeof(char));
+    }
+    accum += int64_t(
+        this->classes.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::Class)));
+    for (const auto& [k, v] : this->classes) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += v.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Class));
+    }
+    accum += int64_t(
+        this->enums.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::Enum)));
+    for (const auto& [k, v] : this->enums) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += v.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Enum));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Statistics.h

@@ -0,0 +1,53 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/ClassStatistics.h>
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <string>
+#include <unordered_map>
+
+namespace Cesium3DTiles {
+/**
+ * @brief Statistics about entities.
+ */
+struct CESIUM3DTILES_API Statistics final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Statistics";
+
+  /**
+   * @brief A dictionary, where each key corresponds to a class ID in the
+   * `classes` dictionary of the metatata schema that was defined for the
+   * tileset that contains these statistics. Each value is an object containing
+   * statistics about entities that conform to the class.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::ClassStatistics> classes;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Statistics));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(
+        this->classes.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::ClassStatistics)));
+    for (const auto& [k, v] : this->classes) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum +=
+          v.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::ClassStatistics));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Subtree.h

@@ -0,0 +1,151 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Availability.h>
+#include <Cesium3DTiles/Buffer.h>
+#include <Cesium3DTiles/BufferView.h>
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/MetadataEntity.h>
+#include <Cesium3DTiles/PropertyTable.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object describing the availability of tiles and content in a
+ * subtree, as well as availability of children subtrees. May also store
+ * metadata for available tiles and content.
+ */
+struct CESIUM3DTILES_API Subtree final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Subtree";
+
+  /**
+   * @brief An array of buffers.
+   */
+  std::vector<Cesium3DTiles::Buffer> buffers;
+
+  /**
+   * @brief An array of buffer views.
+   */
+  std::vector<Cesium3DTiles::BufferView> bufferViews;
+
+  /**
+   * @brief An array of property tables.
+   */
+  std::vector<Cesium3DTiles::PropertyTable> propertyTables;
+
+  /**
+   * @brief The availability of tiles in the subtree. The availability bitstream
+   * is a 1D boolean array where tiles are ordered by their level in the subtree
+   * and Morton index within that level. A tile's availability is determined by
+   * a single bit, 1 meaning a tile exists at that spatial index, and 0 meaning
+   * it does not. The number of elements in the array is `(N^subtreeLevels -
+   * 1)/(N - 1)` where N is 4 for subdivision scheme `QUADTREE` and 8 for
+   * `OCTREE`. Availability may be stored in a buffer view or as a constant
+   * value that applies to all tiles. If a non-root tile's availability is 1 its
+   * parent tile's availability shall also be 1. `tileAvailability.constant: 0`
+   * is disallowed, as subtrees shall have at least one tile.
+   */
+  Cesium3DTiles::Availability tileAvailability;
+
+  /**
+   * @brief An array of content availability objects. If the tile has a single
+   * content this array will have one element; if the tile has multiple contents
+   * - as supported by 3DTILES_multiple_contents and 3D Tiles 1.1 - this array
+   * will have multiple elements.
+   */
+  std::vector<Cesium3DTiles::Availability> contentAvailability;
+
+  /**
+   * @brief The availability of children subtrees. The availability bitstream is
+   * a 1D boolean array where subtrees are ordered by their Morton index in the
+   * level of the tree immediately below the bottom row of the subtree. A child
+   * subtree's availability is determined by a single bit, 1 meaning a subtree
+   * exists at that spatial index, and 0 meaning it does not. The number of
+   * elements in the array is `N^subtreeLevels` where N is 4 for subdivision
+   * scheme `QUADTREE` and 8 for `OCTREE`. Availability may be stored in a
+   * buffer view or as a constant value that applies to all child subtrees. If
+   * availability is 0 for all child subtrees, then the tileset does not
+   * subdivide further.
+   */
+  Cesium3DTiles::Availability childSubtreeAvailability;
+
+  /**
+   * @brief Index of the property table containing tile metadata. Tile metadata
+   * only exists for available tiles and is tightly packed by increasing tile
+   * index. To access individual tile metadata, implementations may create a
+   * mapping from tile indices to tile metadata indices.
+   */
+  std::optional<int64_t> tileMetadata;
+
+  /**
+   * @brief An array of indexes to property tables containing content metadata.
+   * If the tile has a single content this array will have one element; if the
+   * tile has multiple contents - as supported by 3DTILES_multiple_contents and
+   * 3D Tiles 1.1 - this array will have multiple elements. Content metadata
+   * only exists for available contents and is tightly packed by increasing tile
+   * index. To access individual content metadata, implementations may create a
+   * mapping from tile indices to content metadata indices.
+   */
+  std::vector<int64_t> contentMetadata;
+
+  /**
+   * @brief Subtree metadata encoded in JSON.
+   */
+  std::optional<Cesium3DTiles::MetadataEntity> subtreeMetadata;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Subtree));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(sizeof(Cesium3DTiles::Buffer) * this->buffers.capacity());
+    for (const Cesium3DTiles::Buffer& value : this->buffers) {
+      accum += value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Buffer));
+    }
+    accum += int64_t(
+        sizeof(Cesium3DTiles::BufferView) * this->bufferViews.capacity());
+    for (const Cesium3DTiles::BufferView& value : this->bufferViews) {
+      accum +=
+          value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::BufferView));
+    }
+    accum += int64_t(
+        sizeof(Cesium3DTiles::PropertyTable) * this->propertyTables.capacity());
+    for (const Cesium3DTiles::PropertyTable& value : this->propertyTables) {
+      accum +=
+          value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::PropertyTable));
+    }
+    accum += this->tileAvailability.getSizeBytes() -
+             int64_t(sizeof(Cesium3DTiles::Availability));
+    accum += int64_t(
+        sizeof(Cesium3DTiles::Availability) *
+        this->contentAvailability.capacity());
+    for (const Cesium3DTiles::Availability& value : this->contentAvailability) {
+      accum +=
+          value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Availability));
+    }
+    accum += this->childSubtreeAvailability.getSizeBytes() -
+             int64_t(sizeof(Cesium3DTiles::Availability));
+    accum += int64_t(sizeof(int64_t) * this->contentMetadata.capacity());
+    if (this->subtreeMetadata) {
+      accum += this->subtreeMetadata->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::MetadataEntity));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Subtrees.h

@@ -0,0 +1,41 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Library.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <string>
+
+namespace Cesium3DTiles {
+/**
+ * @brief An object describing the location of subtree files.
+ */
+struct CESIUM3DTILES_API Subtrees final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Subtrees";
+
+  /**
+   * @brief A URI with embedded expressions that describes the resource that is associated with an implicit tile in an implicit tileset. Allowed expressions are `{level}`, `{x}`, `{y}`, and `{z}`. `{level}` is substituted with the level of the node, `{x}` is substituted with the x index of the node within the level, and `{y}` is substituted with the y index of the node within the level. `{z}` may only be given when the subdivision scheme is `OCTREE`, and it is substituted with the z index of the node within the level.
+   */
+  std::string uri;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Subtrees));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += int64_t(this->uri.capacity() * sizeof(char));
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Tile.h

@@ -0,0 +1,157 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/BoundingVolume.h>
+#include <Cesium3DTiles/Content.h>
+#include <Cesium3DTiles/ImplicitTiling.h>
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/MetadataEntity.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A tile in a 3D Tiles tileset.
+ */
+struct CESIUM3DTILES_API Tile final : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Tile";
+
+  /**
+   * @brief Known values for Specifies if additive or replacement refinement is
+   * used when traversing the tileset for rendering. This property is required
+   * for the root tile of a tileset; it is optional for all other tiles. The
+   * default is to inherit from the parent tile.
+   */
+  struct Refine {
+    /** @brief `ADD` */
+    inline static const std::string ADD = "ADD";
+
+    /** @brief `REPLACE` */
+    inline static const std::string REPLACE = "REPLACE";
+  };
+
+  /**
+   * @brief The bounding volume that encloses the tile.
+   */
+  Cesium3DTiles::BoundingVolume boundingVolume;
+
+  /**
+   * @brief Optional bounding volume that defines the volume the viewer shall be
+   * inside of before the tile's content will be requested and before the tile
+   * will be refined based on geometricError.
+   */
+  std::optional<Cesium3DTiles::BoundingVolume> viewerRequestVolume;
+
+  /**
+   * @brief The error, in meters, introduced if this tile is rendered and its
+   * children are not. At runtime, the geometric error is used to compute screen
+   * space error (SSE), i.e., the error measured in pixels.
+   */
+  double geometricError = double();
+
+  /**
+   * @brief Specifies if additive or replacement refinement is used when
+   * traversing the tileset for rendering. This property is required for the
+   * root tile of a tileset; it is optional for all other tiles. The default is
+   * to inherit from the parent tile.
+   *
+   * Known values are defined in {@link Refine}.
+   *
+   */
+  std::optional<std::string> refine;
+
+  /**
+   * @brief A floating-point 4x4 affine transformation matrix, stored in
+   * column-major order, that transforms the tile's content--i.e., its features
+   * as well as content.boundingVolume, boundingVolume, and
+   * viewerRequestVolume--from the tile's local coordinate system to the parent
+   * tile's coordinate system, or, in the case of a root tile, from the tile's
+   * local coordinate system to the tileset's coordinate system. `transform`
+   * does not apply to any volume property when the volume is a region, defined
+   * in EPSG:4979 coordinates. `transform` scales the `geometricError` by the
+   * maximum scaling factor from the matrix.
+   */
+  std::vector<double> transform =
+      {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
+
+  /**
+   * @brief Metadata about the tile's content and a link to the content. When
+   * this is omitted the tile is just used for culling. When this is defined,
+   * then `contents` shall be undefined.
+   */
+  std::optional<Cesium3DTiles::Content> content;
+
+  /**
+   * @brief An array of contents. When this is defined, then `content` shall be
+   * undefined.
+   */
+  std::vector<Cesium3DTiles::Content> contents;
+
+  /**
+   * @brief A metadata entity that is associated with this tile.
+   */
+  std::optional<Cesium3DTiles::MetadataEntity> metadata;
+
+  /**
+   * @brief An object that describes the implicit subdivision of this tile.
+   */
+  std::optional<Cesium3DTiles::ImplicitTiling> implicitTiling;
+
+  /**
+   * @brief An array of objects that define child tiles. Each child tile content
+   * is fully enclosed by its parent tile's bounding volume and, generally, has
+   * a geometricError less than its parent tile's geometricError. For leaf
+   * tiles, there are no children, and this property may not be defined.
+   */
+  std::vector<Cesium3DTiles::Tile> children;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Tile));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += this->boundingVolume.getSizeBytes() -
+             int64_t(sizeof(Cesium3DTiles::BoundingVolume));
+    if (this->viewerRequestVolume) {
+      accum += this->viewerRequestVolume->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::BoundingVolume));
+    }
+    accum += int64_t(sizeof(double) * this->transform.capacity());
+    if (this->content) {
+      accum += this->content->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::Content));
+    }
+    accum +=
+        int64_t(sizeof(Cesium3DTiles::Content) * this->contents.capacity());
+    for (const Cesium3DTiles::Content& value : this->contents) {
+      accum += value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Content));
+    }
+    if (this->metadata) {
+      accum += this->metadata->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::MetadataEntity));
+    }
+    if (this->implicitTiling) {
+      accum += this->implicitTiling->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::ImplicitTiling));
+    }
+    accum += int64_t(sizeof(Cesium3DTiles::Tile) * this->children.capacity());
+    for (const Cesium3DTiles::Tile& value : this->children) {
+      accum += value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Tile));
+    }
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles

Plugins/CesiumForUnreal/Source/ThirdParty/include/Cesium3DTiles/Tileset.h

@@ -0,0 +1,139 @@
+// This file was generated by generate-classes.
+// DO NOT EDIT THIS FILE!
+#pragma once
+
+#include <Cesium3DTiles/Asset.h>
+#include <Cesium3DTiles/GroupMetadata.h>
+#include <Cesium3DTiles/Library.h>
+#include <Cesium3DTiles/MetadataEntity.h>
+#include <Cesium3DTiles/Properties.h>
+#include <Cesium3DTiles/Schema.h>
+#include <Cesium3DTiles/Statistics.h>
+#include <Cesium3DTiles/Tile.h>
+#include <CesiumUtility/ExtensibleObject.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace Cesium3DTiles {
+/**
+ * @brief A 3D Tiles tileset.
+ */
+struct CESIUM3DTILES_API Tileset final
+    : public CesiumUtility::ExtensibleObject {
+  /**
+   * @brief The original name of this type.
+   */
+  static constexpr const char* TypeName = "Tileset";
+
+  /**
+   * @brief Metadata about the entire tileset.
+   */
+  Cesium3DTiles::Asset asset;
+
+  /**
+   * @brief A dictionary object of metadata about per-feature properties.
+   */
+  std::unordered_map<std::string, Cesium3DTiles::Properties> properties;
+
+  /**
+   * @brief An object defining the structure of metadata classes and enums. When
+   * this is defined, then `schemaUri` shall be undefined.
+   */
+  std::optional<Cesium3DTiles::Schema> schema;
+
+  /**
+   * @brief The URI (or IRI) of the external schema file. When this is defined,
+   * then `schema` shall be undefined.
+   */
+  std::optional<std::string> schemaUri;
+
+  /**
+   * @brief An object containing statistics about metadata entities.
+   */
+  std::optional<Cesium3DTiles::Statistics> statistics;
+
+  /**
+   * @brief An array of groups that tile content may belong to. Each element of
+   * this array is a metadata entity that describes the group. The tile content
+   * `group` property is an index into this array.
+   */
+  std::vector<Cesium3DTiles::GroupMetadata> groups;
+
+  /**
+   * @brief A metadata entity that is associated with this tileset.
+   */
+  std::optional<Cesium3DTiles::MetadataEntity> metadata;
+
+  /**
+   * @brief The error, in meters, introduced if this tileset is not rendered. At
+   * runtime, the geometric error is used to compute screen space error (SSE),
+   * i.e., the error measured in pixels.
+   */
+  double geometricError = double();
+
+  /**
+   * @brief The root tile.
+   */
+  Cesium3DTiles::Tile root;
+
+  /**
+   * @brief Names of 3D Tiles extensions used somewhere in this tileset.
+   */
+  std::vector<std::string> extensionsUsed;
+
+  /**
+   * @brief Names of 3D Tiles extensions required to properly load this tileset.
+   * Each element of this array shall also be contained in `extensionsUsed`.
+   */
+  std::vector<std::string> extensionsRequired;
+
+  /**
+   * @brief Calculates the size in bytes of this object, including the contents
+   * of all collections, pointers, and strings. This will NOT include the size
+   * of any extensions attached to the object. Calling this method may be slow
+   * as it requires traversing the object's entire structure.
+   */
+  int64_t getSizeBytes() const {
+    int64_t accum = 0;
+    accum += int64_t(sizeof(Tileset));
+    accum += CesiumUtility::ExtensibleObject::getSizeBytes() -
+             int64_t(sizeof(CesiumUtility::ExtensibleObject));
+    accum += this->asset.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Asset));
+    accum += int64_t(
+        this->properties.bucket_count() *
+        (sizeof(std::string) + sizeof(Cesium3DTiles::Properties)));
+    for (const auto& [k, v] : this->properties) {
+      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
+      accum += v.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Properties));
+    }
+    if (this->schema) {
+      accum +=
+          this->schema->getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Schema));
+    }
+    if (this->schemaUri) {
+      accum += int64_t(this->schemaUri->capacity() * sizeof(char));
+    }
+    if (this->statistics) {
+      accum += this->statistics->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::Statistics));
+    }
+    accum +=
+        int64_t(sizeof(Cesium3DTiles::GroupMetadata) * this->groups.capacity());
+    for (const Cesium3DTiles::GroupMetadata& value : this->groups) {
+      accum +=
+          value.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::GroupMetadata));
+    }
+    if (this->metadata) {
+      accum += this->metadata->getSizeBytes() -
+               int64_t(sizeof(Cesium3DTiles::MetadataEntity));
+    }
+    accum += this->root.getSizeBytes() - int64_t(sizeof(Cesium3DTiles::Tile));
+    accum += int64_t(sizeof(std::string) * this->extensionsUsed.capacity());
+    accum += int64_t(sizeof(std::string) * this->extensionsRequired.capacity());
+    return accum;
+  }
+};
+} // namespace Cesium3DTiles