This PR adds support for 3D Tiles Next

.gitmodules

@@ -22,3 +22,12 @@
 [submodule "extern/Catch2"]
 	path = extern/Catch2
 	url = https://github.com/catchorg/Catch2.git
+[submodule "extern/libmorton"]
+	path = extern/libmorton
+	url = [email protected]:Forceflow/libmorton.git
+[submodule "extern/rapidxml"]
+	path = extern/rapidxml
+	url = https://github.com/notviri/rapidxml.git
+[submodule "extern/tiny-utf8"]
+	path = extern/tiny-utf8
+	url = https://github.com/DuffsDevice/tiny-utf8.git

CDBTo3DTiles/CMakeLists.txt

@@ -9,14 +9,18 @@ add_library(CDBTo3DTiles
     src/CDBGeometryVectors.cpp
     src/CDBElevation.cpp
     src/CDBImagery.cpp
+    src/CDBRMTexture.cpp
+    src/CDBRMDescriptor.cpp
+    src/CDBMaterials.cpp
     src/CDBModels.cpp
     src/CDBAttributes.cpp
     src/CDBDataset.cpp
     src/CDBGeoCell.cpp
     src/CDBTile.cpp
     src/CDBTileset.cpp
     src/CDB.cpp
-    src/CDBTo3DTiles.cpp)
+    src/CDBTo3DTiles.cpp
+    src/CDBTilesetBuilder.cpp)
 
 set(PRIVATE_INCLUDE_PATHS
     ${PROJECT_SOURCE_DIR}/src
@@ -29,15 +33,25 @@ set(PRIVATE_THIRD_PARTY_INCLUDE_PATHS
     ${nlohmann_json_INCLUDE_DIRS}
     ${GDAL_INCLUDE_DIRS}
     ${tinygltf_INCLUDE_DIRS}
+    ${LIBMORTON_INCLUDE_DIR}
+    ${glm_INCLUDE_DIR}
+    ${rapidxml_INCLUDE_DIR}
+    ${tiny_utf8_INCLUDE_DIRS}
 )
 
-target_include_directories(CDBTo3DTiles
+foreach(INCLUDE_DIR ${PRIVATE_THIRD_PARTY_INCLUDE_PATHS})
+  target_include_directories(CDBTo3DTiles
     SYSTEM PUBLIC
-        "$<BUILD_INTERFACE:$<$<BOOL:$<TARGET_PROPERTY:CDBTo3DTiles_THIRD_PARTY_INCLUDE_PRIVATE>>:${PRIVATE_THIRD_PARTY_INCLUDE_PATHS}>>"
+      ${INCLUDE_DIR}
+  )
+endforeach()
 
+target_include_directories(CDBTo3DTiles
     PUBLIC
-        ${PROJECT_SOURCE_DIR}/include
-        "$<BUILD_INTERFACE:$<$<BOOL:$<TARGET_PROPERTY:CDBTo3DTiles_INCLUDE_PRIVATE>>:${PRIVATE_INCLUDE_PATHS}>>")
+      ${CMAKE_CURRENT_LIST_DIR}/../Core/include
+      ${PROJECT_SOURCE_DIR}/include
+      ${PRIVATE_INCLUDE_PATHS}
+)
 
 target_link_libraries(CDBTo3DTiles
     PRIVATE
@@ -52,6 +66,7 @@ target_link_libraries(CDBTo3DTiles
         meshoptimizer
         Core
         ${GDAL_LIBRARIES})
+link_libraries(Core)
 
 set_property(TARGET CDBTo3DTiles
     PROPERTY

CDBTo3DTiles/include/CDBTo3DTiles.h

@@ -4,6 +4,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include "../src/CDBTilesetBuilder.h"
 
 namespace CDBTo3DTiles {
 class GlobalInitializer
@@ -23,8 +24,14 @@ class Converter
 
     void combineDataset(const std::vector<std::string> &datasets);
 
+    void setUse3dTilesNext(bool use3dTilesNext);
+
+    void setExternalSchema(bool externalSchema);
+
     void setGenerateElevationNormal(bool generateElevationNormal);
 
+    void setSubtreeLevels(int subtreeLevels);
+
     void setElevationLODOnly(bool elevationLOD);
 
     void setElevationDecimateError(float elevationDecimateError);
@@ -34,9 +41,8 @@ class Converter
     void convert();
 
 private:
-    struct Impl;
     struct TilesetCollection;
 
-    std::unique_ptr<Impl> m_impl;
+    std::unique_ptr<CDBTilesetBuilder> m_impl;
 };
 } // namespace CDBTo3DTiles

CDBTo3DTiles/include/Utility.h

@@ -41,4 +41,32 @@ inline std::vector<std::string> splitString(const std::string &str, const std::s
     results.emplace_back(str.substr(last));
     return results;
 }
+
+inline uint64_t alignTo8(uint64_t v)
+{
+    return (v + 7) & ~7u;
+}
+
+inline unsigned int countSetBitsInInteger(unsigned int integer)
+{
+    unsigned int count = 0;
+    while(integer > 0) 
+    {
+        if ((integer & 1) == 1)
+            count += 1;
+        integer >>= 1;
+    }
+    return count;
+}
+
+inline unsigned int countSetBitsInVectorOfInts(std::vector<uint8_t> vec)
+{
+    unsigned int count = 0;
+    for(unsigned int integer : vec)
+    {
+        count += countSetBitsInInteger(integer);
+    }
+    return count;
+}
+
 } // namespace CDBTo3DTiles

CDBTo3DTiles/src/CDB.cpp

@@ -439,6 +439,34 @@ bool CDB::isImageryExist(const CDBTile &tile) const
     return std::filesystem::exists(imagery);
 }
 
+bool CDB::isRMTextureExist(const CDBTile &tile) const
+{
+    CDBTile rmTextureTile = CDBTile(tile.getGeoCell(),
+                                  CDBDataset::RMTexture,
+                                  1,
+                                  1,
+                                  tile.getLevel(),
+                                  tile.getUREF(),
+                                  tile.getRREF());
+
+    auto rmTexture = m_path / (rmTextureTile.getRelativePath().string() + ".tif");
+    return std::filesystem::exists(rmTexture);
+}
+
+bool CDB::isRMDescriptorExist(const CDBTile &tile) const
+{
+    CDBTile rmDescriptorTile = CDBTile(tile.getGeoCell(),
+                                  CDBDataset::RMDescriptor,
+                                  1,
+                                  1,
+                                  tile.getLevel(),
+                                  tile.getUREF(),
+                                  tile.getRREF());
+
+    auto rmDescriptor = m_path / (rmDescriptorTile.getRelativePath().string() + ".xml");
+    return std::filesystem::exists(rmDescriptor);
+}
+
 std::optional<CDBImagery> CDB::getImagery(const CDBTile &tile) const
 {
     CDBTile imageryTile = CDBTile(tile.getGeoCell(),
@@ -464,6 +492,49 @@ std::optional<CDBImagery> CDB::getImagery(const CDBTile &tile) const
     return CDBImagery(std::move(imageryDataset), imageryTile);
 }
 
+std::optional<CDBRMTexture> CDB::getRMTexture(const CDBTile &tile) const
+{
+    CDBTile rmTextureTile = CDBTile(tile.getGeoCell(),
+                                  CDBDataset::RMTexture,
+                                  1,
+                                  1,
+                                  tile.getLevel(),
+                                  tile.getUREF(),
+                                  tile.getRREF());
+
+    auto rmTexturePath = m_path / (rmTextureTile.getRelativePath().string() + ".tif");
+    if (!std::filesystem::exists(rmTexturePath)) {
+        return std::nullopt;
+    }
+
+    auto rmTextureDataset = GDALDatasetUniquePtr(
+        (GDALDataset *) GDALOpen(rmTexturePath.c_str(), GDALAccess::GA_ReadOnly));
+
+    if (!rmTextureDataset) {
+        return std::nullopt;
+    }
+
+    return CDBRMTexture(std::move(rmTextureDataset), rmTextureTile);
+}
+
+CDBRMDescriptor* CDB::getRMDescriptor(const CDBTile &tile) const
+{
+    CDBTile rmDescriptorTile = CDBTile(tile.getGeoCell(),
+                                  CDBDataset::RMDescriptor,
+                                  1,
+                                  1,
+                                  tile.getLevel(),
+                                  tile.getUREF(),
+                                  tile.getRREF());
+
+    auto rmDescriptorPath = m_path / (rmDescriptorTile.getRelativePath().string() + ".xml");
+    if (!std::filesystem::exists(rmDescriptorPath)) {
+        return nullptr;
+    }
+
+    return new CDBRMDescriptor(rmDescriptorPath, rmDescriptorTile);
+}
+
 void CDB::forEachDatasetTile(const CDBGeoCell &geoCell,
                              CDBDataset dataset,
                              std::function<void(const std::filesystem::path &)> process)

CDBTo3DTiles/src/CDB.h

@@ -3,6 +3,8 @@
 #include "CDBElevation.h"
 #include "CDBGeometryVectors.h"
 #include "CDBImagery.h"
+#include "CDBRMTexture.h"
+#include "CDBRMDescriptor.h"
 #include "CDBModels.h"
 #include "CDBTileset.h"
 #include <filesystem>
@@ -41,8 +43,16 @@ class CDB
 
     bool isImageryExist(const CDBTile &tile) const;
 
+    bool isRMTextureExist(const CDBTile &tile) const;
+
+    bool isRMDescriptorExist(const CDBTile &tile) const;
+
     std::optional<CDBImagery> getImagery(const CDBTile &tile) const;
 
+    std::optional<CDBRMTexture> getRMTexture(const CDBTile &tile) const;
+
+    CDBRMDescriptor* getRMDescriptor(const CDBTile &tile) const;
+
     static const std::filesystem::path TILES;
     static const std::filesystem::path METADATA;
     static const std::filesystem::path GTModel;