Add a test based on material variants.

Cesium3DTilesSelection/test/TestTilesetSelectionAlgorithm.cpp

@@ -7,6 +7,7 @@
 #include "SimplePrepareRendererResource.h"
 #include "SimpleTaskProcessor.h"
 
+#include <Cesium3DTiles/MetadataQuery.h>
 #include <CesiumGeospatial/Ellipsoid.h>
 #include <CesiumUtility/Math.h>
 
@@ -1215,6 +1216,103 @@ TEST_CASE("Makes metadata available on external tilesets") {
   CHECK(pExternalContent->metadata.groups[1].classProperty == "someClass");
 }
 
+TEST_CASE("Allows access to material variants") {
+  Cesium3DTilesSelection::registerAllTileContentTypes();
+
+  std::filesystem::path testDataPath = Cesium3DTilesSelection_TEST_DATA_DIR;
+  testDataPath = testDataPath / "MaterialVariants";
+  std::vector<std::string> files{"tileset.json", "parent.b3dm"};
+
+  std::map<std::string, std::shared_ptr<SimpleAssetRequest>>
+      mockCompletedRequests;
+  for (const auto& file : files) {
+    std::unique_ptr<SimpleAssetResponse> mockCompletedResponse =
+        std::make_unique<SimpleAssetResponse>(
+            static_cast<uint16_t>(200),
+            "doesn't matter",
+            CesiumAsync::HttpHeaders{},
+            readFile(testDataPath / file));
+    mockCompletedRequests.insert(
+        {file,
+         std::make_shared<SimpleAssetRequest>(
+             "GET",
+             file,
+             CesiumAsync::HttpHeaders{},
+             std::move(mockCompletedResponse))});
+  }
+
+  std::shared_ptr<SimpleAssetAccessor> mockAssetAccessor =
+      std::make_shared<SimpleAssetAccessor>(std::move(mockCompletedRequests));
+  TilesetExternals tilesetExternals{
+      mockAssetAccessor,
+      std::make_shared<SimplePrepareRendererResource>(),
+      AsyncSystem(std::make_shared<SimpleTaskProcessor>()),
+      nullptr};
+
+  // create tileset and call updateView() to give it a chance to load
+  Tileset tileset(tilesetExternals, "tileset.json");
+  initializeTileset(tileset);
+
+  const TilesetMetadata* pMetadata = tileset.findMetadata();
+  REQUIRE(pMetadata);
+  REQUIRE(pMetadata->schema);
+  REQUIRE(pMetadata->metadata);
+
+  std::optional<Cesium3DTiles::FoundMetadataProperty> found1 =
+      Cesium3DTiles::MetadataQuery::findFirstPropertyWithSemantic(
+          *pMetadata->schema,
+          *pMetadata->metadata,
+          "MATERIAL_VARIANTS");
+  REQUIRE(found1);
+  CHECK(found1->classIdentifier == "MaterialVariants");
+  CHECK(found1->classDefinition.properties.size() == 1);
+  CHECK(found1->propertyIdentifier == "material_variants");
+  CHECK(
+      found1->propertyDefinition.description ==
+      "Names of material variants to be expected in the glTF assets");
+  REQUIRE(found1->propertyValue.isArray());
+
+  const JsonValue::Array& variantsJson = found1->propertyValue.getArray();
+  std::vector<std::string> variants(variantsJson.size());
+  std::transform(
+      variantsJson.begin(),
+      variantsJson.end(),
+      variants.begin(),
+      [](const JsonValue& value) { return value.getStringOrDefault(""); });
+  REQUIRE(variants.size() == 4);
+  CHECK(variants[0] == "RGB");
+  CHECK(variants[1] == "RRR");
+  CHECK(variants[2] == "GGG");
+  CHECK(variants[3] == "BBB");
+
+  std::vector<std::vector<std::string>> variantsByGroup;
+  for (const Cesium3DTiles::GroupMetadata& group : pMetadata->groups) {
+    std::vector<std::string>& groupVariants = variantsByGroup.emplace_back();
+
+    std::optional<Cesium3DTiles::FoundMetadataProperty> found2 =
+        Cesium3DTiles::MetadataQuery::findFirstPropertyWithSemantic(
+            *pMetadata->schema,
+            group,
+            "MATERIAL_VARIANTS");
+    REQUIRE(found2);
+    REQUIRE(found2->propertyValue.isArray());
+
+    const JsonValue::Array& groupVariantsJson =
+        found2->propertyValue.getArray();
+    groupVariants.reserve(groupVariantsJson.size());
+    for (int i = 0; i < groupVariantsJson.size(); ++i) {
+      groupVariants.emplace_back(groupVariantsJson[i].getStringOrDefault(""));
+    }
+  }
+
+  std::vector<std::vector<std::string>> expected = {
+    { "RGB", "RRR" },
+    { "GGG", "BBB" }
+  };
+
+  CHECK(variantsByGroup == expected);
+}
+
 namespace {
 
 void runUnconditionallyRefinedTestCase(const TilesetOptions& options) {

Cesium3DTilesSelection/test/data/MaterialVariants/tileset.json

@@ -0,0 +1,89 @@
+{
+  "asset": {
+    "version": "1.0",
+    "tilesetVersion": "1.2.3"
+  },
+  "extras": {
+    "name": "Sample Tileset"
+  },
+  "properties": {
+    "id": {
+      "minimum": 0,
+      "maximum": 9
+    },
+    "Longitude": {
+      "minimum": -1.3197192952275933,
+      "maximum": -1.319644104024109
+    },
+    "Latitude": {
+      "minimum": 0.698848878034009,
+      "maximum": 0.6989046192460953
+    },
+    "Height": {
+      "minimum": 6.161747192963958,
+      "maximum": 85.41026367992163
+    }
+  },
+  "schema": {
+    "classes": {
+      "MaterialVariants": {
+        "properties": {
+          "material_variants": {
+            "type": "STRING",
+            "array": true,
+            "description": "Names of material variants to be expected in the glTF assets",
+            "semantic": "MATERIAL_VARIANTS"
+          }
+        }
+      }
+    }
+  },
+  "metadata": {
+    "class": "MaterialVariants",
+    "properties": {
+      "material_variants": ["RGB", "RRR", "GGG", "BBB"]
+    }
+  },
+  "groups": [
+    {
+      "class": "MaterialVariants",
+      "properties": {
+        "material_variants": ["RGB", "RRR"]
+      }
+    },
+    {
+      "class": "MaterialVariants",
+      "properties": {
+        "material_variants": ["GGG", "BBB"]
+      }
+    }
+  ],
+  "geometricError": 240,
+  "root": {
+    "boundingVolume": {
+      "region": [
+        -1.3197209591796106,
+        0.6988424218,
+        -1.3196390408203893,
+        0.6989055782,
+        0,
+        88
+      ]
+    },
+    "geometricError": 70,
+    "refine": "ADD",
+    "content": {
+      "uri": "parent.b3dm",
+      "boundingVolume": {
+        "region": [
+          -1.3197004795898053,
+          0.6988582109,
+          -1.3196595204101946,
+          0.6988897891,
+          0,
+          88
+        ]
+      }
+    }
+  }
+}