Support 3D Tile I3dm legacy tile format

CHANGES.md

@@ -1,5 +1,11 @@
 # Change Log
 
+### v0.34.0
+
+##### Additions :tada:
+
+- Added support for I3dm 3D Tile content files.
+
 ### v0.33.0 - 2024-03-01
 
 ##### Breaking Changes :mega:

CMakeLists.txt

@@ -36,8 +36,8 @@ if (NOT DEFINED GLOB_USE_CONFIGURE_DEPENDS)
     )
 endif()
 
-set(CESIUM_DEBUG_POSTFIX "d")
-set(CESIUM_RELEASE_POSTFIX "")
+set(CESIUM_DEBUG_POSTFIX "d" CACHE STRING "debug postfix for cesium native")
+set(CESIUM_RELEASE_POSTFIX "" CACHE STRING "release postfix for cesium native")
 
 set(CMAKE_DEBUG_POSTFIX ${CESIUM_DEBUG_POSTFIX})
 set(CMAKE_RELEASE_POSTFIX ${CESIUM_RELEASE_POSTFIX})
@@ -132,8 +132,8 @@ endfunction()
 add_subdirectory(extern EXCLUDE_FROM_ALL)
 
 # These libraries override the debug postfix, so re-override it.
-set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX ${CESIUM_DEBUG_POSTFIX})
-set_target_properties(tinyxml2 PROPERTIES DEBUG_POSTFIX ${CESIUM_DEBUG_POSTFIX})
+set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX "${CESIUM_DEBUG_POSTFIX}")
+set_target_properties(tinyxml2 PROPERTIES DEBUG_POSTFIX "${CESIUM_DEBUG_POSTFIX}")
 
 # Public Targets
 add_subdirectory(CesiumUtility)

Cesium3DTilesContent/include/Cesium3DTilesContent/B3dmToGltfConverter.h

@@ -10,9 +10,12 @@
 #include <optional>
 
 namespace Cesium3DTilesContent {
+struct ConverterSubprocessor;
+
 struct B3dmToGltfConverter {
   static GltfConverterResult convert(
       const gsl::span<const std::byte>& b3dmBinary,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor*);
 };
 } // namespace Cesium3DTilesContent

Cesium3DTilesContent/include/Cesium3DTilesContent/BinaryToGltfConverter.h

@@ -8,11 +8,14 @@
 #include <cstddef>
 
 namespace Cesium3DTilesContent {
+struct ConverterSubprocessor;
+
 struct BinaryToGltfConverter {
 public:
   static GltfConverterResult convert(
       const gsl::span<const std::byte>& gltfBinary,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor* subProcessor);
 
 private:
   static CesiumGltfReader::GltfReader _gltfReader;

Cesium3DTilesContent/include/Cesium3DTilesContent/CmptToGltfConverter.h

@@ -8,9 +8,12 @@
 #include <cstddef>
 
 namespace Cesium3DTilesContent {
+struct ConverterSubprocessor;
+
 struct CmptToGltfConverter {
   static GltfConverterResult convert(
       const gsl::span<const std::byte>& cmptBinary,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor*);
 };
 } // namespace Cesium3DTilesContent

Cesium3DTilesContent/include/Cesium3DTilesContent/GltfConverterResult.h

@@ -5,7 +5,12 @@
 #include <CesiumGltf/Model.h>
 #include <CesiumUtility/ErrorList.h>
 
+#include <glm/common.hpp>
+#include <glm/gtx/quaternion.hpp>
+
 #include <optional>
+#include <string>
+#include <vector>
 
 namespace Cesium3DTilesContent {
 /**

Cesium3DTilesContent/include/Cesium3DTilesContent/GltfConverters.h

@@ -12,6 +12,30 @@
 #include <string_view>
 
 namespace Cesium3DTilesContent {
+
+/**
+ * Data required to make a recursive request to fetch an asset, mostly for the
+ * benefit of I3dm files.
+ */
+struct CESIUM3DTILESCONTENT_API ConverterSubprocessor {
+  ConverterSubprocessor(
+      const CesiumAsync::AsyncSystem& asyncSystem_,
+      const std::shared_ptr<CesiumAsync::IAssetAccessor>& pAssetAccessor_,
+      const std::string& baseUrl_,
+      const glm::dmat4 tileTransform_,
+      const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders_)
+      : asyncSystem(asyncSystem_),
+        pAssetAccessor(pAssetAccessor_),
+        baseUrl(baseUrl_),
+        tileTransform(tileTransform_),
+        requestHeaders(requestHeaders_) {}
+  const CesiumAsync::AsyncSystem& asyncSystem;
+  const std::shared_ptr<CesiumAsync::IAssetAccessor> pAssetAccessor;
+  const std::string baseUrl;
+  glm::dmat4 tileTransform;
+  const std::vector<CesiumAsync::IAssetAccessor::THeader>& requestHeaders;
+};
+
 /**
  * @brief Creates {@link GltfConverterResult} objects from a
  * a binary content.
@@ -34,7 +58,8 @@ class CESIUM3DTILESCONTENT_API GltfConverters {
    */
   using ConverterFunction = GltfConverterResult (*)(
       const gsl::span<const std::byte>& content,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor* subprocessor);
 
   /**
    * @brief Register the given function for the given magic header.
@@ -123,7 +148,8 @@ class CESIUM3DTILESCONTENT_API GltfConverters {
   static GltfConverterResult convert(
       const std::string& filePath,
       const gsl::span<const std::byte>& content,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor* subprocessor);
 
   /**
    * @brief Creates the {@link GltfConverterResult} from the given
@@ -147,7 +173,8 @@ class CESIUM3DTILESCONTENT_API GltfConverters {
    */
   static GltfConverterResult convert(
       const gsl::span<const std::byte>& content,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor* subprocessor);
 
 private:
   static std::string toLowerCase(const std::string_view& str);

Cesium3DTilesContent/include/Cesium3DTilesContent/I3dmToGltfConverter.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <Cesium3DTilesContent/GltfConverterResult.h>
+
+#include <CesiumGltf/Model.h>
+#include <CesiumGltfReader/GltfReader.h>
+
+#include <glm/mat4x4.hpp>
+#include <gsl/span>
+
+#include <optional>
+
+namespace Cesium3DTilesContent {
+struct ConverterSubprocessor;
+
+struct I3dmToGltfConverter {
+  static GltfConverterResult convert(
+      const gsl::span<const std::byte>& instancesBinary,
+      const CesiumGltfReader::GltfReaderOptions& options,
+	  ConverterSubprocessor* subprocessor);
+};
+} // namespace Cesium3DTilesContent

Cesium3DTilesContent/include/Cesium3DTilesContent/LegacyUtilities.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <CesiumAsync/IAssetAccessor.h>
+#include <CesiumAsync/IAssetRequest.h>
+
+#include <Cesium3DTilesContent/GltfConverters.h>
+#include <CesiumUtility/ErrorList.h>
+
+#include <glm/fwd.hpp>
+
+#include <rapidjson/document.h>
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace CesiumGltf {
+class Model;
+class Buffer;
+}
+
+namespace Cesium3DTilesContent {
+
+struct ByteResult {
+	std::vector<std::byte> bytes;
+	CesiumUtility::ErrorList errorList;
+};
+
+CesiumAsync::Future<ByteResult> get(const ConverterSubprocessor& subprocessor, const std::string& relativeUrl);
+
+namespace LegacyUtilities {
+std::optional<uint32_t> parseOffset(const rapidjson::Document& document, const char* semantic, CesiumUtility::ErrorList& errorList);
+
+typedef bool (rapidjson::Value::*ValuePredicate)() const;
+
+template<typename T> bool isValue(const rapidjson::Value& value);
+template<typename T> T getValue(const rapidjson::Value& value);
+
+template<typename T>
+std::optional<T> getOpt(const rapidjson::Value& value) {
+  if (isValue<T>(value)) {
+    return std::make_optional(getValue<T>(value));
+  }
+  return {};
+}
+
+template<typename T>
+std::optional<T> getValue(const rapidjson::Document& document, const char *semantic) {
+  const auto valueIt = document.FindMember(semantic);
+  if (valueIt == document.MemberEnd() || !isValue<T>(valueIt->value)) {
+    return {};
+  }
+  return std::make_optional(getValue<T>(valueIt->value));
+}
+
+template<>
+inline bool isValue<bool>(const rapidjson::Value& value) {
+  return value.IsBool();
+}
+
+template<>
+inline bool getValue<bool>(const rapidjson::Value& value) {
+  return value.GetBool();
+}
+
+template<>
+inline bool isValue<uint32_t>(const rapidjson::Value& value) {
+    return value.IsUint();
+}
+
+template<>
+inline uint32_t getValue<uint32_t>(const rapidjson::Value& value) {
+    return value.GetUint();
+}
+
+bool validateJsonArrayValues(const rapidjson::Value& arrayValue, uint32_t expectedLength, ValuePredicate predicate);
+
+std::optional<glm::vec3> parseArrayValueVec3(const rapidjson::Value& arrayValue);
+
+std::optional<glm::vec3> parseArrayValueVec3(const rapidjson::Document& document, const char *name);
+
+int32_t createBufferInGltf(CesiumGltf::Model& gltf);
+int32_t createBufferInGltf(CesiumGltf::Model& gltf, std::vector<std::byte>&& buffer);
+
+int32_t createBufferViewInGltf(
+    CesiumGltf::Model& gltf,
+    const int32_t bufferId,
+    const int64_t byteLength,
+    const int64_t byteStride);
+
+int32_t createAccessorInGltf(
+    CesiumGltf::Model& gltf,
+    const int32_t bufferViewId,
+    const int32_t componentType,
+    const int64_t count,
+    const std::string type);
+}
+}

Cesium3DTilesContent/include/Cesium3DTilesContent/PntsToGltfConverter.h

@@ -10,9 +10,12 @@
 #include <optional>
 
 namespace Cesium3DTilesContent {
+struct ConverterSubprocessor;
+
 struct PntsToGltfConverter {
   static GltfConverterResult convert(
       const gsl::span<const std::byte>& pntsBinary,
-      const CesiumGltfReader::GltfReaderOptions& options);
+      const CesiumGltfReader::GltfReaderOptions& options,
+      ConverterSubprocessor*);
 };
 } // namespace Cesium3DTilesContent

Cesium3DTilesContent/src/B3dmToGltfConverter.cpp

@@ -136,7 +136,7 @@ void convertB3dmContentToGltf(
       b3dmBinary.subspan(glbStart, glbEnd - glbStart);
 
   GltfConverterResult binToGltfResult =
-      BinaryToGltfConverter::convert(glbData, options);
+      BinaryToGltfConverter::convert(glbData, options, nullptr);
 
   result.model = std::move(binToGltfResult.model);
   result.errors.merge(std::move(binToGltfResult.errors));
@@ -231,7 +231,8 @@ void convertB3dmMetadataToGltfStructuralMetadata(
 
 GltfConverterResult B3dmToGltfConverter::convert(
     const gsl::span<const std::byte>& b3dmBinary,
-    const CesiumGltfReader::GltfReaderOptions& options) {
+    const CesiumGltfReader::GltfReaderOptions& options,
+    ConverterSubprocessor*) {
   GltfConverterResult result;
   B3dmHeader header;
   uint32_t headerLength = 0;

Cesium3DTilesContent/src/BinaryToGltfConverter.cpp

@@ -5,7 +5,8 @@ CesiumGltfReader::GltfReader BinaryToGltfConverter::_gltfReader;
 
 GltfConverterResult BinaryToGltfConverter::convert(
     const gsl::span<const std::byte>& gltfBinary,
-    const CesiumGltfReader::GltfReaderOptions& options) {
+    const CesiumGltfReader::GltfReaderOptions& options,
+    ConverterSubprocessor*) {
   CesiumGltfReader::GltfReaderResult loadedGltf =
       _gltfReader.readGltf(gltfBinary, options);
 

Cesium3DTilesContent/src/CmptToGltfConverter.cpp

@@ -24,7 +24,8 @@ static_assert(sizeof(InnerHeader) == 12);
 
 GltfConverterResult CmptToGltfConverter::convert(
     const gsl::span<const std::byte>& cmptBinary,
-    const CesiumGltfReader::GltfReaderOptions& options) {
+    const CesiumGltfReader::GltfReaderOptions& options,
+    ConverterSubprocessor* subProcessor) {
   GltfConverterResult result;
   if (cmptBinary.size() < sizeof(CmptHeader)) {
     result.errors.emplaceWarning("Composite tile must be at least 16 bytes.");
@@ -78,7 +79,8 @@ GltfConverterResult CmptToGltfConverter::convert(
 
     pos += pInner->byteLength;
 
-    innerTiles.emplace_back(GltfConverters::convert(innerData, options));
+    innerTiles.emplace_back(
+        GltfConverters::convert(innerData, options, subProcessor));
   }
 
   uint32_t tilesLength = pHeader->tilesLength;

Cesium3DTilesContent/src/GltfConverters.cpp

@@ -40,17 +40,18 @@ GltfConverters::getConverterByMagic(const gsl::span<const std::byte>& content) {
 GltfConverterResult GltfConverters::convert(
     const std::string& filePath,
     const gsl::span<const std::byte>& content,
-    const CesiumGltfReader::GltfReaderOptions& options) {
+    const CesiumGltfReader::GltfReaderOptions& options,
+    ConverterSubprocessor* subprocessor) {
   std::string magic;
   auto converterFun = getConverterByMagic(content, magic);
   if (converterFun) {
-    return converterFun(content, options);
+    return converterFun(content, options, subprocessor);
   }
 
   std::string fileExtension;
   converterFun = getConverterByFileExtension(filePath, fileExtension);
   if (converterFun) {
-    return converterFun(content, options);
+    return converterFun(content, options, subprocessor);
   }
 
   ErrorList errors;
@@ -65,11 +66,12 @@ GltfConverterResult GltfConverters::convert(
 
 GltfConverterResult GltfConverters::convert(
     const gsl::span<const std::byte>& content,
-    const CesiumGltfReader::GltfReaderOptions& options) {
+    const CesiumGltfReader::GltfReaderOptions& options,
+    ConverterSubprocessor* subprocessor) {
   std::string magic;
   auto converter = getConverterByMagic(content, magic);
   if (converter) {
-    return converter(content, options);
+    return converter(content, options, subprocessor);
   }
 
   ErrorList errors;