Merge branch 'main' into maxar-geojson-schema

Author: j9liu

CHANGES.md

@@ -10,6 +10,7 @@
 - The `AccessorView` and `AccessorWriter` constructor overloads that take raw buffer data now require an additional `normalized` argument.
 - The `getQuaternionAccessorView` overload that took an accessor pointer now takes an accessor reference.
 - Renamed `MAXAR_content_geojson` class `ExtensionMaxarContentGeoJson` to `ExtensionTilesetMaxarContentGeoJson`.
+- `forEachTile` and `forEachContent` now take an additional `refine` argument in the callback function.
 
 ##### Additions :tada:
 

Cesium3DTiles/include/Cesium3DTiles/Tileset.h

@@ -15,11 +15,19 @@ struct CESIUM3DTILES_API Tileset : public TilesetSpec {
 
   /**
    * @brief A callback function for {@link forEachTile}.
+   *
+   * @param tileset The tileset.
+   * @param tile The tile.
+   * @param transform The tile's world transform, computed from the product of
+   * the parent's world transform and the tile's local transform.
+   * @param refine The tile's refine property, potentially inherited from an
+   * ancestor tile if not set.
    */
   typedef void ForEachTileCallback(
       Tileset& tileset,
       Tile& tile,
-      const glm::dmat4& transform);
+      const glm::dmat4& transform,
+      const std::string& refine);
 
   /**
    * @brief Apply the given callback to all tiles.
@@ -31,25 +39,33 @@ struct CESIUM3DTILES_API Tileset : public TilesetSpec {
    */
   void forEachTile(std::function<ForEachTileCallback>&& callback);
 
-  /**
-   * @brief A callback function for {@link forEachTile}.
-   */
+  /** @copydoc Tileset::ForEachTileCallback */
   typedef void ForEachTileConstCallback(
       const Tileset& tileset,
       const Tile& tile,
-      const glm::dmat4& transform);
+      const glm::dmat4& transform,
+      const std::string& refine);
 
   /** @copydoc Tileset::forEachTile */
   void forEachTile(std::function<ForEachTileConstCallback>&& callback) const;
 
   /**
    * @brief A callback function for {@link forEachContent}.
+   *
+   * @param tileset The tileset.
+   * @param tile The tile.
+   * @param content The content.
+   * @param transform The tile's world transform, computed from the product of
+   * the parent's world transform and the tile's local transform.
+   * @param refine The tile's refine property, potentially inherited from an
+   * ancestor tile if not set.
    */
   typedef void ForEachContentCallback(
       Tileset& tileset,
       Tile& tile,
       Content& content,
-      const glm::dmat4& transform);
+      const glm::dmat4& transform,
+      const std::string& refine);
 
   /**
    * @brief Apply the given callback to all contents.
@@ -61,14 +77,13 @@ struct CESIUM3DTILES_API Tileset : public TilesetSpec {
    */
   void forEachContent(std::function<ForEachContentCallback>&& callback);
 
-  /**
-   * @brief A callback function for {@link forEachContent}.
-   */
+  /** @copydoc Tileset::ForEachContentCallback */
   typedef void ForEachContentConstCallback(
       const Tileset& tileset,
       const Tile& tile,
       const Content& content,
-      const glm::dmat4& transform);
+      const glm::dmat4& transform,
+      const std::string& refine);
 
   /** @copydoc Tileset::forEachContent */
   void

Cesium3DTiles/src/Tileset.cpp

@@ -35,39 +35,57 @@ std::optional<glm::dmat4> getTileTransform(const Cesium3DTiles::Tile& tile) {
 template <typename TCallback>
 void forEachContentRecursive(
     const glm::dmat4& transform,
+    const std::string& refine,
     const Tileset& tileset,
     const Tile& tile,
     TCallback& callback) {
   glm::dmat4 tileTransform =
       transform * getTileTransform(tile).value_or(glm::dmat4(1.0));
 
+  // Inherit parent's refine if not set
+  const std::string& tileRefine = tile.refine.value_or(refine);
+
   if (tile.content) {
-    callback(tileset, tile, *tile.content, tileTransform);
+    callback(tileset, tile, *tile.content, tileTransform, tileRefine);
   }
 
   // 3D Tiles 1.1 multiple contents
   for (const Cesium3DTiles::Content& content : tile.contents) {
-    callback(tileset, tile, content, tileTransform);
+    callback(tileset, tile, content, tileTransform, tileRefine);
   }
 
   for (const Cesium3DTiles::Tile& childTile : tile.children) {
-    forEachContentRecursive(tileTransform, tileset, childTile, callback);
+    forEachContentRecursive(
+        tileTransform,
+        tileRefine,
+        tileset,
+        childTile,
+        callback);
   }
 }
 
 template <typename TCallback>
 void forEachTileRecursive(
     const glm::dmat4& transform,
+    const std::string& refine,
     const Tileset& tileset,
     const Tile& tile,
     TCallback& callback) {
   glm::dmat4 tileTransform =
       transform * getTileTransform(tile).value_or(glm::dmat4(1.0));
 
-  callback(tileset, tile, tileTransform);
+  // Inherit parent's refine if not set
+  const std::string& tileRefine = tile.refine.value_or(refine);
+
+  callback(tileset, tile, tileTransform, tileRefine);
 
   for (const Cesium3DTiles::Tile& childTile : tile.children) {
-    forEachTileRecursive(tileTransform, tileset, childTile, callback);
+    forEachTileRecursive(
+        tileTransform,
+        tileRefine,
+        tileset,
+        childTile,
+        callback);
   }
 }
 
@@ -78,17 +96,24 @@ void Tileset::forEachTile(std::function<ForEachTileCallback>&& callback) {
       [&callback](
           const Tileset& tileset,
           const Tile& tile,
-          const glm::dmat4& transform) {
+          const glm::dmat4& transform,
+          const std::string& refine) {
         callback(
             const_cast<Tileset&>(tileset),
             const_cast<Tile&>(tile),
-            transform);
+            transform,
+            refine);
       });
 }
 
 void Tileset::forEachTile(
     std::function<ForEachTileConstCallback>&& callback) const {
-  forEachTileRecursive(glm::dmat4(1.0), *this, this->root, callback);
+  forEachTileRecursive(
+      glm::dmat4(1.0),
+      Cesium3DTiles::Tile::Refine::ADD,
+      *this,
+      this->root,
+      callback);
 }
 
 void Tileset::forEachContent(std::function<ForEachContentCallback>&& callback) {
@@ -97,18 +122,25 @@ void Tileset::forEachContent(std::function<ForEachContentCallback>&& callback) {
           const Tileset& tileset,
           const Tile& tile,
           const Content& content,
-          const glm::dmat4& transform) {
+          const glm::dmat4& transform,
+          const std::string& refine) {
         callback(
             const_cast<Tileset&>(tileset),
             const_cast<Tile&>(tile),
             const_cast<Content&>(content),
-            transform);
+            transform,
+            refine);
       });
 }
 
 void Tileset::forEachContent(
     std::function<ForEachContentConstCallback>&& callback) const {
-  forEachContentRecursive(glm::dmat4(1.0), *this, this->root, callback);
+  forEachContentRecursive(
+      glm::dmat4(1.0),
+      Cesium3DTiles::Tile::Refine::ADD,
+      *this,
+      this->root,
+      callback);
 }
 
 void Tileset::addExtensionUsed(const std::string& extensionName) {

Cesium3DTiles/test/TestTileset.cpp

@@ -1,3 +1,5 @@
+#include "Cesium3DTiles/Tile.h"
+
 #include <Cesium3DTiles/Tileset.h>
 
 #include <doctest/doctest.h>
@@ -20,6 +22,11 @@ TEST_CASE("forEachTile") {
 
   Tile& grandchild = child0.children.emplace_back();
 
+  root.refine = Cesium3DTiles::Tile::Refine::ADD;
+  child0.refine = Cesium3DTiles::Tile::Refine::REPLACE;
+  child1.refine = std::nullopt;
+  grandchild.refine = Cesium3DTiles::Tile::Refine::ADD;
+
   glm::dmat4 rootTransform = glm::dmat4(2.0);
   glm::dmat4 child0Transform = glm::dmat4(3.0);
   glm::dmat4 child1Transform = glm::dmat4(4.0);
@@ -40,17 +47,27 @@ TEST_CASE("forEachTile") {
       rootTransform * child0Transform * grandchildTransform;
 
   std::vector<glm::dmat4> transforms;
-  tileset.forEachTile(
-      [&transforms](
-          Tileset& /* tileset */,
-          Tile& /* tile */,
-          const glm::dmat4& transform) { transforms.push_back(transform); });
+  std::vector<std::string> refines;
+  tileset.forEachTile([&transforms, &refines](
+                          Tileset& /* tileset */,
+                          Tile& /* tile */,
+                          const glm::dmat4& transform,
+                          const std::string& refine) {
+    transforms.push_back(transform);
+    refines.push_back(refine);
+  });
 
   REQUIRE(transforms.size() == 4);
   CHECK(transforms[0] == expectedRootTransform);
   CHECK(transforms[1] == expectedChild0Transform);
   CHECK(transforms[2] == expectedGrandchildTransform);
   CHECK(transforms[3] == expectedChild1Transform);
+
+  REQUIRE(refines.size() == 4);
+  CHECK(refines[0] == Cesium3DTiles::Tile::Refine::ADD);
+  CHECK(refines[1] == Cesium3DTiles::Tile::Refine::REPLACE);
+  CHECK(refines[2] == Cesium3DTiles::Tile::Refine::ADD);
+  CHECK(refines[3] == Cesium3DTiles::Tile::Refine::ADD);
 }
 
 TEST_CASE("forEachContent") {
@@ -66,6 +83,11 @@ TEST_CASE("forEachContent") {
 
   Tile& grandchild = child0.children.emplace_back();
 
+  root.refine = Cesium3DTiles::Tile::Refine::ADD;
+  child0.refine = Cesium3DTiles::Tile::Refine::REPLACE;
+  child1.refine = std::nullopt;
+  grandchild.refine = Cesium3DTiles::Tile::Refine::ADD;
+
   const Content& rootContent = root.content.emplace();
   const Content& child1Content = child1.content.emplace();
 
@@ -94,13 +116,16 @@ TEST_CASE("forEachContent") {
       rootTransform * child0Transform * grandchildTransform;
 
   std::vector<glm::dmat4> transforms;
+  std::vector<std::string> refines;
   std::vector<Cesium3DTiles::Content*> contents;
-  tileset.forEachContent([&transforms, &contents](
+  tileset.forEachContent([&transforms, &refines, &contents](
                              Tileset& /* tileset */,
                              Tile& /* tile */,
                              Content& content,
-                             const glm::dmat4& transform) {
+                             const glm::dmat4& transform,
+                             const std::string& refine) {
     transforms.push_back(transform);
+    refines.push_back(refine);
     contents.push_back(&content);
   });
 
@@ -110,6 +135,12 @@ TEST_CASE("forEachContent") {
   CHECK(transforms[2] == expectedGrandchildTransform);
   CHECK(transforms[3] == expectedChild1Transform);
 
+  REQUIRE(refines.size() == 4);
+  CHECK(refines[0] == Cesium3DTiles::Tile::Refine::ADD);
+  CHECK(refines[1] == Cesium3DTiles::Tile::Refine::ADD);
+  CHECK(refines[2] == Cesium3DTiles::Tile::Refine::ADD);
+  CHECK(refines[3] == Cesium3DTiles::Tile::Refine::ADD);
+
   REQUIRE(contents.size() == 4);
   CHECK(contents[0] == &rootContent);
   CHECK(contents[1] == &grandchildContent0);

CesiumGltfReader/CMakeLists.txt

@@ -63,6 +63,4 @@ target_link_libraries(CesiumGltfReader
         meshoptimizer::meshoptimizer
         modp_b64::modp_b64
         spz::spz
-        WebP::webp
-        WebP::webpdecoder
 )

CesiumImage/CMakeLists.txt

@@ -51,6 +51,8 @@ target_link_libraries(CesiumImage
         CesiumUtility
     PRIVATE
         KTX::ktx
+        WebP::webp
+        WebP::webpdecoder
 )
 
 if(CESIUM_DISABLE_LIBJPEG_TURBO)
@@ -65,4 +67,4 @@ else()
         PRIVATE
             $<IF:$<TARGET_EXISTS:libjpeg-turbo::turbojpeg>,libjpeg-turbo::turbojpeg,libjpeg-turbo::turbojpeg-static>
     )
-endif()
+endif()

doc/diagrams/dependencies/CesiumGltfReader.mmd

@@ -10,12 +10,9 @@ graph TD
   CesiumGltfReader[CesiumGltfReader] --> CesiumGltf[CesiumGltf]
   CesiumGltfReader[CesiumGltfReader] --> CesiumImage[CesiumImage]
   CesiumGltfReader[CesiumGltfReader] --> CesiumJsonReader[CesiumJsonReader]
-  CesiumGltfReader[CesiumGltfReader] --> WebP_webp{{WebP::webp}}
-  CesiumGltfReader[CesiumGltfReader] --> WebP_webpdecoder{{WebP::webpdecoder}}
   CesiumGltfReader[CesiumGltfReader] --> draco_draco{{draco::draco}}
-  CesiumGltfReader[CesiumGltfReader] --> libjpeg-turbo_turbojpeg-static{{libjpeg-turbo::turbojpeg-static}}
   CesiumGltfReader[CesiumGltfReader] --> meshoptimizer_meshoptimizer{{meshoptimizer::meshoptimizer}}
   CesiumGltfReader[CesiumGltfReader] --> modp_b64_modp_b64{{modp_b64::modp_b64}}
   CesiumGltfReader[CesiumGltfReader] --> spz_spz{{spz::spz}}
-  class WebP_webp,WebP_webpdecoder,draco_draco,libjpeg-turbo_turbojpeg-static,meshoptimizer_meshoptimizer,modp_b64_modp_b64,spz_spz dependencyNode
+  class draco_draco,meshoptimizer_meshoptimizer,modp_b64_modp_b64,spz_spz dependencyNode
   class CesiumAsync,CesiumGltf,CesiumImage,CesiumJsonReader,CesiumGltfReader libraryNode

doc/diagrams/dependencies/CesiumImage.mmd

@@ -8,5 +8,8 @@ graph TD
   classDef libraryNode fill:#9f9,font-weight:bold,font-size:28px
   CesiumImage[CesiumImage] --> CesiumUtility[CesiumUtility]
   CesiumImage[CesiumImage] --> KTX_ktx{{KTX::ktx}}
-  class KTX_ktx dependencyNode
+  CesiumImage[CesiumImage] --> WebP_webp{{WebP::webp}}
+  CesiumImage[CesiumImage] --> WebP_webpdecoder{{WebP::webpdecoder}}
+  CesiumImage[CesiumImage] --> libjpeg-turbo_turbojpeg-static{{libjpeg-turbo::turbojpeg-static}}
+  class KTX_ktx,WebP_webp,WebP_webpdecoder,libjpeg-turbo_turbojpeg-static dependencyNode
   class CesiumUtility,CesiumImage libraryNode