Merge branch 'ext-primitive-voxels' into 3dtiles-content-voxels

CHANGES.md

@@ -17,6 +17,12 @@
 
 - Fixed parsing URIs that have a scheme followed by `:` instead of `://`.
 
+### v0.44.2 - 2025-02-10
+
+##### Fixes :wrench:
+
+- Fixed a bug in `GltfUtilities::parseGltfCopyright` that could cause a crash when the copyright ends with a semicolon.
+
 ### v0.44.1 - 2025-02-03
 
 ##### Fixes :wrench:

CMakeLists.txt

@@ -87,7 +87,7 @@ endif()
 include("cmake/defaults.cmake")
 
 project(cesium-native
-    VERSION 0.44.0
+    VERSION 0.44.2
     LANGUAGES CXX C
 )
 

CesiumAsync/test/ExamplesAsyncSystem.cpp

@@ -384,7 +384,7 @@ TEST_CASE("AsyncSystem Examples") {
                       processDownloadedContent(pResponse->data());
                   std::optional<std::string> maybeUrl =
                       findReferencedImageUrl(processed);
-                  if (maybeUrl) {
+                  if (!maybeUrl) {
                     return asyncSystem.createResolvedFuture<
                         std::shared_ptr<CesiumAsync::IAssetRequest>>(nullptr);
                   } else {

CesiumGltfContent/include/CesiumGltfContent/GltfUtilities.h

@@ -129,6 +129,16 @@ struct CESIUMGLTFCONTENT_API GltfUtilities {
   static std::vector<std::string_view>
   parseGltfCopyright(const CesiumGltf::Model& gltf);
 
+  /**
+   * @brief Parse a semicolon-separated string, such as the copyright field of a
+   * glTF model, and return the individual parts (credits).
+   *
+   * @param s The string to parse.
+   * @return The semicolon-delimited parts.
+   */
+  static std::vector<std::string_view>
+  parseGltfCopyright(const std::string_view& s);
+
   /**
    * @brief Merges all of the glTF's buffers into a single buffer (the first
    * one).

CesiumGltfContent/src/GltfUtilities.cpp

@@ -283,24 +283,46 @@ GltfUtilities::computeBoundingRegion(
 
 std::vector<std::string_view>
 GltfUtilities::parseGltfCopyright(const CesiumGltf::Model& gltf) {
-  std::vector<std::string_view> result;
   if (gltf.asset.copyright) {
-    const std::string_view copyright = *gltf.asset.copyright;
-    if (copyright.size() > 0) {
-      size_t start = 0;
-      size_t end;
-      size_t ltrim;
-      size_t rtrim;
-      do {
-        ltrim = copyright.find_first_not_of(" \t", start);
-        end = copyright.find(';', ltrim);
-        rtrim = copyright.find_last_not_of(" \t", end - 1);
-        result.emplace_back(copyright.substr(ltrim, rtrim - ltrim + 1));
-        start = end + 1;
-      } while (end != std::string::npos);
+    return GltfUtilities::parseGltfCopyright(*gltf.asset.copyright);
+  } else {
+    return {};
+  }
+}
+
+namespace {
+std::string_view trimWhitespace(const std::string_view& s) {
+  size_t end = s.find_last_not_of(" \t");
+  if (end == std::string::npos)
+    return {};
+  size_t start = s.find_first_not_of(" \t", 0, end + 1);
+  return s.substr(start, end - start + 1);
+}
+} // namespace
+
+std::vector<std::string_view>
+GltfUtilities::parseGltfCopyright(const std::string_view& s) {
+  std::vector<std::string_view> result;
+  if (s.empty())
+    return result;
+
+  size_t start = 0;
+
+  auto addPart = [&](size_t end) {
+    std::string_view trimmed = trimWhitespace(s.substr(start, end - start));
+    if (!trimmed.empty())
+      result.emplace_back(std::move(trimmed));
+  };
+
+  for (size_t i = 0, length = s.size(); i < length; ++i) {
+    if (s[i] == ';') {
+      addPart(i);
+      start = i + 1;
     }
   }
 
+  addPart(s.size());
+
   return result;
 }
 

CesiumGltfContent/test/TestGltfUtilities.cpp

@@ -711,3 +711,138 @@ TEST_CASE("GltfUtilities::collapseToSingleBuffer") {
     CHECK(m.bufferViews[2].byteLength == 100);
   }
 }
+
+TEST_CASE("GltfUtilities::parseGltfCopyright") {
+  SUBCASE("properly parses multiple copyright entries") {
+    Model model;
+    model.asset.copyright = "Test;a;b;c";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 4);
+    CHECK(result[0] == "Test");
+    CHECK(result[1] == "a");
+    CHECK(result[2] == "b");
+    CHECK(result[3] == "c");
+  }
+
+  SUBCASE("properly parses a single copyright entry") {
+    Model model;
+    model.asset.copyright = "Test";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 1);
+    CHECK(result[0] == "Test");
+  }
+
+  SUBCASE("properly parses an entry with a trailing semicolon") {
+    Model model;
+    model.asset.copyright = "Test;a;b;c;";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 4);
+    CHECK(result[0] == "Test");
+    CHECK(result[1] == "a");
+    CHECK(result[2] == "b");
+    CHECK(result[3] == "c");
+  }
+
+  SUBCASE("properly parses entries with whitespace") {
+    Model model;
+    model.asset.copyright = "\tTest;a\t ;\tb;\t \tc\t;\t ";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 4);
+    CHECK(result[0] == "Test");
+    CHECK(result[1] == "a");
+    CHECK(result[2] == "b");
+    CHECK(result[3] == "c");
+  }
+
+  SUBCASE("properly parses an empty string") {
+    Model model;
+    model.asset.copyright = "";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 0);
+  }
+
+  SUBCASE("properly parses whitespace only") {
+    Model model;
+    model.asset.copyright = " \t  \t";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 0);
+  }
+
+  SUBCASE("properly parses empty parts in the middle") {
+    Model model;
+    model.asset.copyright = "a;;b";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 2);
+    CHECK(result[0] == "a");
+    CHECK(result[1] == "b");
+  }
+
+  SUBCASE("properly parses whitespace parts in the middle") {
+    Model model;
+    model.asset.copyright = "a;\t;b";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 2);
+    CHECK(result[0] == "a");
+    CHECK(result[1] == "b");
+  }
+
+  SUBCASE("properly parses empty parts at the start") {
+    Model model;
+    model.asset.copyright = ";a;b";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 2);
+    CHECK(result[0] == "a");
+    CHECK(result[1] == "b");
+  }
+
+  SUBCASE("properly parses whitespace parts at the start") {
+    Model model;
+    model.asset.copyright = "\t;a;b";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 2);
+    CHECK(result[0] == "a");
+    CHECK(result[1] == "b");
+  }
+
+  SUBCASE("properly parses empty parts at the end") {
+    Model model;
+    model.asset.copyright = "a;b;";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 2);
+    CHECK(result[0] == "a");
+    CHECK(result[1] == "b");
+  }
+
+  SUBCASE("properly parses whitespace parts at the end") {
+    Model model;
+    model.asset.copyright = "a;b;\t";
+    std::vector<std::string_view> result =
+        GltfUtilities::parseGltfCopyright(model);
+
+    REQUIRE(result.size() == 2);
+    CHECK(result[0] == "a");
+    CHECK(result[1] == "b");
+  }
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cesium-native",
-  "version": "0.44.0",
+  "version": "0.44.2",
   "description": "Cesium 3D Geospatial for C++",
   "main": "index.js",
   "directories": {