Merge branch 'main' into geospatial-guide-tag

Author: kring

.clang-tidy

@@ -124,7 +124,9 @@ Checks:
   - "modernize-use-equals-delete"
   - "modernize-use-nullptr"
   - "modernize-use-starts-ends-with"
-  - "modernize-use-std-numbers"
+  # The <numbers> header is unfortunately not available in Android NDK r25b,
+  # which is an important target for cesium-native via Unreal Engine.
+  #- "modernize-use-std-numbers"
   #- "modernize-use-using"
   - "performance-*"
   - "-performance-enum-size"

CHANGES.md

@@ -2,14 +2,21 @@
 
 ### v0.44.0 - 2025-02-03
 
-##### Fixes :wrench:
+##### Breaking Changes :mega:
 
-- Fixed a crash in `GltfWriter` that would happen when the `EXT_structural_metadata` `schema` property was null.
+- cesium-native no longer uses the `GLM_FORCE_SIZE_T_LENGTH` option with the `glm` library
 
 ##### Additions :tada:
 
+- Added conversion of I3dm batch table metadata to `EXT_structural_metadata` and `EXT_instance_features` extensions.
+- Added `CesiumIonClient::Connection::geocode` method for making geocoding queries against the Cesium ion geocoder API.
+- Added `UrlTemplateRasterOverlay` for requesting raster tiles from services using a templated URL.
 - `upsampleGltfForRasterOverlays` is now compatible with meshes using TRIANGLE_STRIP, TRIANGLE_FAN, or non-indexed TRIANGLES primitives.
 
+##### Fixes :wrench:
+
+- Fixed a crash in `GltfWriter` that would happen when the `EXT_structural_metadata` `schema` property was null.
+
 ### v0.43.0 - 2025-01-02
 
 ##### Breaking Changes :mega:

CMakeGraphVizOptions.cmake

@@ -2,6 +2,6 @@ set(GRAPHVIZ_GENERATE_PER_TARGET FALSE)
 set(GRAPHVIZ_GENERATE_DEPENDERS FALSE)
 set(GRAPHVIZ_OBJECT_LIBS FALSE)
 list(APPEND GRAPHVIZ_IGNORE_TARGETS cesium-native-tests)
-list(APPEND GRAPHVIZ_IGNORE_TARGETS "Catch2::*")
+list(APPEND GRAPHVIZ_IGNORE_TARGETS "doctest::*")
 list(APPEND GRAPHVIZ_IGNORE_TARGETS "lib*.lib")
 list(APPEND GRAPHVIZ_IGNORE_TARGETS "lib*.so")

CMakeLists.txt

@@ -56,7 +56,7 @@ set(PACKAGES_PRIVATE
 )
 
 # Packages only used for testing
-set(PACKAGES_TEST catch2)
+set(PACKAGES_TEST doctest)
 
 if(NOT VCPKG_MANIFEST_MODE)
     set(PACKAGES_ALL ${PACKAGES_PUBLIC})
@@ -116,13 +116,7 @@ cmake_dependent_option(
     OFF
 )
 
-cmake_dependent_option(
-    CESIUM_CLANG_TIDY_USE_THREADS
-    "Sets the number of threads for run-clang-tidy to use."
-    14
-    CESIUM_ENABLE_CLANG_TIDY
-    1
-)
+set(CESIUM_CLANG_TIDY_USE_THREADS 14 CACHE STRING "Sets the number of threads for run-clang-tidy to use.")
 
 if(CESIUM_INSTALL_STATIC_LIBS OR CESIUM_INSTALL_HEADERS)
     foreach(PACKAGE ${PACKAGES_PUBLIC})
@@ -247,7 +241,7 @@ list(APPEND CMAKE_PREFIX_PATH "${PACKAGE_BUILD_DIR}")
 # and imporeted library target ourselves. This is the case for modp_b64::modp_b64, picosha2::picosha2 and earcut. In
 # these cases, we *do* have the somewhat ugly and verbose details in the extern/CMakeLists.txt file.
 find_package(Async++ CONFIG REQUIRED)
-find_package(Catch2 CONFIG REQUIRED)
+find_package(doctest CONFIG REQUIRED)
 find_package(draco CONFIG REQUIRED)
 find_package(expected-lite CONFIG REQUIRED)
 find_package(glm CONFIG REQUIRED)

Cesium3DTiles/test/TestMetadataQuery.cpp

@@ -5,15 +5,15 @@
 #include <Cesium3DTiles/Schema.h>
 #include <CesiumUtility/JsonValue.h>
 
-#include <catch2/catch_test_macros.hpp>
+#include <doctest/doctest.h>
 
 #include <optional>
 
 using namespace Cesium3DTiles;
 using namespace CesiumUtility;
 
 TEST_CASE("MetadataQuery") {
-  SECTION("findFirstPropertyWithSemantic") {
+  SUBCASE("findFirstPropertyWithSemantic") {
     Schema schema{};
     Class& classDefinition =
         schema.classes.emplace("someClass", Class()).first->second;

Cesium3DTilesContent/src/BatchTableToGltfStructuralMetadata.cpp

@@ -1,18 +1,24 @@
 #include "BatchTableToGltfStructuralMetadata.h"
 
 #include "BatchTableHierarchyPropertyValues.h"
+#include "MetadataProperty.h"
 
+#include <Cesium3DTilesContent/GltfConverterUtility.h>
+#include <CesiumGltf/Accessor.h>
 #include <CesiumGltf/Buffer.h>
 #include <CesiumGltf/BufferView.h>
 #include <CesiumGltf/Class.h>
 #include <CesiumGltf/ClassProperty.h>
+#include <CesiumGltf/ExtensionExtInstanceFeatures.h>
 #include <CesiumGltf/ExtensionExtMeshFeatures.h>
+#include <CesiumGltf/ExtensionExtMeshGpuInstancing.h>
 #include <CesiumGltf/ExtensionKhrDracoMeshCompression.h>
 #include <CesiumGltf/ExtensionModelExtStructuralMetadata.h>
 #include <CesiumGltf/FeatureId.h>
 #include <CesiumGltf/Mesh.h>
 #include <CesiumGltf/MeshPrimitive.h>
 #include <CesiumGltf/Model.h>
+#include <CesiumGltf/Node.h>
 #include <CesiumGltf/PropertyTable.h>
 #include <CesiumGltf/PropertyTableProperty.h>
 #include <CesiumGltf/PropertyType.h>
@@ -29,6 +35,7 @@
 #include <rapidjson/stringbuffer.h>
 #include <rapidjson/writer.h>
 
+#include <algorithm>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
@@ -2008,4 +2015,215 @@ ErrorList BatchTableToGltfStructuralMetadata::convertFromPnts(
 
   return result;
 }
+
+namespace {
+
+// Does something like this already exist?
+
+template <typename T> int32_t componentTypeFromCpp();
+
+template <> int32_t componentTypeFromCpp<uint8_t>() {
+  return Accessor::ComponentType::UNSIGNED_BYTE;
+}
+
+template <> int32_t componentTypeFromCpp<uint16_t>() {
+  return Accessor::ComponentType::UNSIGNED_SHORT;
+}
+
+template <> int32_t componentTypeFromCpp<uint32_t>() {
+  return Accessor::ComponentType::UNSIGNED_INT;
+}
+
+// encapsulation of the binary batch id data in an I3dm
+struct BatchIdSemantic {
+  std::variant<
+      std::span<const uint8_t>,
+      std::span<const uint16_t>,
+      std::span<const uint32_t>>
+      batchSpan;
+  const std::byte* rawData;
+  uint32_t numElements;
+  uint32_t byteSize;
+
+  template <typename UintType>
+  static std::span<const UintType>
+  makeSpan(const std::byte* byteData, uint32_t offset, uint32_t numElements) {
+    return std::span<const UintType>(
+        reinterpret_cast<const UintType*>(byteData + offset),
+        numElements);
+  }
+
+  BatchIdSemantic(
+      const rapidjson::Document& featureTableJson,
+      uint32_t numInstances,
+      const std::span<const std::byte>& featureTableJsonData)
+      : rawData(nullptr), numElements(0), byteSize(0) {
+    const auto batchIdIt = featureTableJson.FindMember("BATCH_ID");
+    if (batchIdIt == featureTableJson.MemberEnd() ||
+        !batchIdIt->value.IsObject()) {
+      return;
+    }
+    const auto byteOffsetIt = batchIdIt->value.FindMember("byteOffset");
+    if (byteOffsetIt == batchIdIt->value.MemberEnd() ||
+        !byteOffsetIt->value.IsUint()) {
+      // Warning
+    }
+    uint32_t byteOffset = byteOffsetIt->value.GetUint();
+    const auto componentTypeIt = batchIdIt->value.FindMember("componentType");
+    if (componentTypeIt != featureTableJson.MemberEnd() &&
+        componentTypeIt->value.IsString()) {
+      const std::string& componentTypeString =
+          componentTypeIt->value.GetString();
+      if (MetadataProperty::stringToMetadataComponentType.find(
+              componentTypeString) ==
+          MetadataProperty::stringToMetadataComponentType.end()) {
+        // Warning
+      }
+      MetadataProperty::ComponentType componentType =
+          MetadataProperty::stringToMetadataComponentType.at(
+              componentTypeString);
+      rawData = featureTableJsonData.data();
+      if (componentType == MetadataProperty::ComponentType::UNSIGNED_BYTE) {
+        batchSpan = makeSpan<uint8_t>(rawData, byteOffset, numInstances);
+        numElements = numInstances;
+        byteSize = numElements * sizeof(uint8_t);
+      } else if (
+          componentType == MetadataProperty::ComponentType::UNSIGNED_SHORT) {
+        batchSpan = makeSpan<uint8_t>(rawData, byteOffset, numInstances);
+        numElements = numInstances;
+        byteSize = numElements * sizeof(uint16_t);
+      } else if (
+          componentType == MetadataProperty::ComponentType::UNSIGNED_INT) {
+        batchSpan = makeSpan<uint32_t>(rawData, byteOffset, numInstances);
+        numElements = numInstances;
+        byteSize = numElements * sizeof(uint32_t);
+      }
+    }
+  }
+
+  size_t idSize() const {
+    return std::visit(
+        [](auto&& batchIds) { return sizeof(batchIds[0]); },
+        batchSpan);
+  }
+
+  uint32_t maxBatchId() const {
+    return std::visit(
+        [](auto&& batchIds) {
+          auto itr = std::max_element(batchIds.begin(), batchIds.end());
+          return static_cast<uint32_t>(*itr);
+        },
+        batchSpan);
+  }
+
+  int32_t componentType() const {
+    return std::visit(
+        [](auto&& batchIds) {
+          using span_type = std::remove_reference_t<decltype(batchIds)>;
+          return componentTypeFromCpp<typename span_type::value_type>();
+        },
+        batchSpan);
+  }
+};
+
+// returns an accessor ID for the added feature IDs
+int32_t
+addFeatureIdsToGltf(CesiumGltf::Model& gltf, const BatchIdSemantic& batchIds) {
+  int32_t featuresBufferId = GltfConverterUtility::createBufferInGltf(gltf);
+  auto& featuresBuffer = gltf.buffers[static_cast<uint32_t>(featuresBufferId)];
+  featuresBuffer.cesium.data.resize(batchIds.byteSize);
+  std::memcpy(
+      &featuresBuffer.cesium.data[0],
+      batchIds.rawData,
+      batchIds.byteSize);
+  int32_t featuresBufferViewId = GltfConverterUtility::createBufferViewInGltf(
+      gltf,
+      featuresBufferId,
+      0,
+      static_cast<int64_t>(batchIds.idSize()));
+  gltf.bufferViews[static_cast<uint32_t>(featuresBufferViewId)].byteLength =
+      batchIds.byteSize;
+
+  int32_t accessorId = GltfConverterUtility::createAccessorInGltf(
+      gltf,
+      featuresBufferViewId,
+      batchIds.componentType(),
+      batchIds.numElements,
+      Accessor::Type::SCALAR);
+  return accessorId;
+}
+
+} // namespace
+
+ErrorList BatchTableToGltfStructuralMetadata::convertFromI3dm(
+    const rapidjson::Document& featureTableJson,
+    const rapidjson::Document& batchTableJson,
+    const std::span<const std::byte>& featureTableJsonData,
+    const std::span<const std::byte>& batchTableBinaryData,
+    CesiumGltf::Model& gltf) {
+  // Check to make sure a char of rapidjson is 1 byte
+  static_assert(
+      sizeof(rapidjson::Value::Ch) == 1,
+      "RapidJson::Value::Ch is not 1 byte");
+
+  ErrorList result;
+
+  // Parse the batch table and convert it to the EXT_structural_metadata
+  // extension.
+
+  // Batch table length is either the max batch ID + 1 or, if there are no batch
+  // IDs, the number of instances.
+  int64_t featureCount = 0;
+  std::optional<BatchIdSemantic> optBatchIds;
+  const auto batchIdIt = featureTableJson.FindMember("BATCH_ID");
+  std::optional<uint32_t> optInstancesLength =
+      GltfConverterUtility::getValue<uint32_t>(
+          featureTableJson,
+          "INSTANCES_LENGTH");
+  if (!optInstancesLength) {
+    result.emplaceError("Required INSTANCES_LENGTH semantic is missing");
+    return result;
+  }
+  if (batchIdIt == featureTableJson.MemberEnd()) {
+    featureCount = *optInstancesLength;
+  } else {
+    optBatchIds = BatchIdSemantic(
+        featureTableJson,
+        *optInstancesLength,
+        featureTableJsonData);
+    uint32_t maxBatchId = optBatchIds->maxBatchId();
+    featureCount = maxBatchId + 1;
+  }
+
+  convertBatchTableToGltfStructuralMetadataExtension(
+      batchTableJson,
+      batchTableBinaryData,
+      gltf,
+      featureCount,
+      result);
+
+  int32_t featureIdAccessor = -1;
+  if (optBatchIds.has_value()) {
+    featureIdAccessor = addFeatureIdsToGltf(gltf, *optBatchIds);
+  }
+
+  // Create an EXT_instance_features extension for node that has an
+  // EXT_mesh_gpu_instancing extension
+  for (Node& node : gltf.nodes) {
+    if (auto* pGpuInstancing =
+            node.getExtension<ExtensionExtMeshGpuInstancing>()) {
+      auto& instanceFeatureExt =
+          node.addExtension<ExtensionExtInstanceFeatures>();
+      gltf.addExtensionUsed(ExtensionExtInstanceFeatures::ExtensionName);
+      instanceFeatureExt.featureIds.resize(1);
+      instanceFeatureExt.featureIds[0].featureCount = featureCount;
+      instanceFeatureExt.featureIds[0].propertyTable = 0;
+      if (featureIdAccessor >= 0) {
+        pGpuInstancing->attributes["_FEATURE_ID_0"] = featureIdAccessor;
+        instanceFeatureExt.featureIds[0].attribute = 0;
+      }
+    }
+  }
+  return result;
+}
 } // namespace Cesium3DTilesContent

Cesium3DTilesContent/src/BatchTableToGltfStructuralMetadata.h

@@ -21,5 +21,12 @@ struct BatchTableToGltfStructuralMetadata {
       const rapidjson::Document& batchTableJson,
       const std::span<const std::byte>& batchTableBinaryData,
       CesiumGltf::Model& gltf);
+
+  static CesiumUtility::ErrorList convertFromI3dm(
+      const rapidjson::Document& featureTableJson,
+      const rapidjson::Document& batchTableJson,
+      const std::span<const std::byte>& featureTableJsonData,
+      const std::span<const std::byte>& batchTableBinaryData,
+      CesiumGltf::Model& gltf);
 };
 } // namespace Cesium3DTilesContent