SparseBuildOctreeCommand.cpp

#include "SparseBuildOctreeCommand.h"
 
#include "Context.h"
 
#include "Resources/ModelManager.h"
#include "Resources/MeshManager.h"
#include "Resources/Buffer.h"
#include "Resources/MaterialManager.h"
 
#include "Scene/GetBounds.h"
 
#include "Services/Variables.h"
 
#include "Editor.h"
#include "Batch.h"
 
#include "Serialization/JsonParser.h"
#include "Serialization/ModelWriter.h"
 
#include "SparseBuildOctree.h"
#include "AssetStatsCommand.h"
#include "Utilities/Parallel.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
 
#include "zstd.h"
 
#include "glm/gtx/compatibility.hpp"
#include "glm/gtx/component_wise.hpp"
#include "glm/gtx/transform.hpp"
 
#define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING
#include "rapidjson/stringbuffer.h"
#include "rapidjson/prettywriter.h"
#undef _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING
 
#include <fstream>
#include <regex>
#include <span>
 
using namespace Cogs;
using namespace Cogs::Core;
using namespace Cogs::Geometry;
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("SparseBuildOctree");
 
  template<typename T>
  void setIfNotSet(Cogs::Core::ModelLoadInfo& loadInfo, const Cogs::StringView& key, const T& value)
  {
    if (!loadInfo.properties->hasProperty(key)) {
      loadInfo.properties->addProperty(key, value);
    }
  }
  template<>
  void setIfNotSet(Cogs::Core::ModelLoadInfo& loadInfo, const Cogs::StringView& key, const Cogs::StringView& value)
  {
    if (!value.empty() && !loadInfo.properties->hasProperty(key)) {
      loadInfo.properties->addProperty(key, value);
    }
  }
  template<>
  void setIfNotSet(Cogs::Core::ModelLoadInfo& loadInfo, const Cogs::StringView& key, const std::string& value)
  {
    setIfNotSet(loadInfo, key, Cogs::StringView(value));
  }
 
 
  void parameterizationTriggerload(Context* context, SparseOctree::Parameterization& p, const SparseOctree::OctreeInfo& info)
  {
    ModelLoadInfo& loadInfo = *context->modelManager->createLoadInfo();
    loadInfo.resourceId = (uint32_t)-1;
    loadInfo.resourcePath = info.source;
    loadInfo.loadFlags = ResourceLoadFlags::ForceUnique;
    loadInfo.modelFlags = ModelLoadFlags::ForceUnique;
 
    if (context->variables->get("resources.models.autoReload", false)) {
      loadInfo.loadFlags |= ResourceLoadFlags::AutoReload;
    }
 
    // Store loadInfo properties.
    // 1. Copy all properties from from the Batch-file "properties" section
    //     "properties": { "keepList": "Path.tags.json",  etc.
    // 2. Set renamed properties parsed from the Batch-file "properties" section,
    //    unless the output property has been set in the Batch property list.
    //    Allows migrating to new batch format setting output properties directly,
    //        e.g. Batch properties: { "rvm.tagSimplify.keepList": "Path.tags.json" ,,)
    //    Batch property "keepList" saved as: "rvm.tagSimplify.keepList"
    // 3. Later if "rvm.tasks" is defined, (defining list of RVMParser tasks with properties),
    //    Overwrite any properties defined in RVMParser tasks defintion
    //        e.g.     "rvm.tasks": { "rvm.tagSimplify.keepList": "My/Custom/Path.tag.json",
    //    This allows a user creating a Kognitwin import definition where only most of the import
    //    properties are pre-defined to pass a new "rvm.tasks" def, with modified params,
    //    like: "rvm.tessellate.origin": [Custom X/Y/Z]
    //
    loadInfo.properties = std::make_unique<PropertyStore>();
    *loadInfo.properties = info.properties;
 
    ::setIfNotSet(loadInfo, "rvm.tessellate.tolerance", p.tolerance);
    ::setIfNotSet(loadInfo, "rvm.tessellate.remesh", p.remesh);
    ::setIfNotSet(loadInfo, "rvm.tessellate.remeshGridSpacing", p.remeshGridSpacing);
    ::setIfNotSet(loadInfo, "rvm.tessellate.remeshVolumeBlur", p.remeshVolumeBlur);
    ::setIfNotSet(loadInfo, "rvm.tessellate.remeshTriSoupBlur", p.remeshTriSoupBlur);
    ::setIfNotSet(loadInfo, "rvm.tessellate.remeshSimplification", p.remeshSimplification);
    ::setIfNotSet(loadInfo, "rvm.tessellate.featureAngle", p.featureAngle);
    ::setIfNotSet(loadInfo, "rvm.tessellate.cullDiameter", p.cullDiameter);
    ::setIfNotSet(loadInfo, "rvm.tessellate.cullGeometryThreshold", p.cullGeometry);
    ::setIfNotSet(loadInfo, "rvm.tessellate.cullLeafThreshold", p.cullLeaf);
    ::setIfNotSet(loadInfo, "rvm.tessellate.simplificationFactor", p.simplificationFactor);
    ::setIfNotSet(loadInfo, "rvm.tessellate.simplificationMode", p.simplificationMode);
 
    if (info.keepList.size()) {
      ::setIfNotSet(loadInfo, "rvm.tagSimplify.keepList", info.keepList);
    };
 
    // All loaded triangle meshes are merged together, so no point in setting up
    // hierarchy etc.
    ::setIfNotSet(loadInfo, "rvm.export.noHierarchy", true);
    ::setIfNotSet(loadInfo, "rvm.export.discardLines", true);
    ::setIfNotSet(loadInfo, "rvm.export.doNotMergeGeometries", false);
 
    ::setIfNotSet(loadInfo, "rvm.export.idInTexCoord", true);
 
 
    ::setIfNotSet(loadInfo, "rvm.filter.rootEndsWith", info.filter_rootEndsWith);
    ::setIfNotSet(loadInfo, "rvm.filter.rootIncludes", info.filter_rootIncludes);
    ::setIfNotSet(loadInfo, "rvm.filter.rootPattern", info.filter_rootPattern);
    ::setIfNotSet(loadInfo, "rvm.filter.attributeName", info.filter_attributeName);
    ::setIfNotSet(loadInfo, "rvm.filter.attributeValue", info.filter_attributeValue);
 
    if (!info.filter_excludeNodes.empty()) {
      ::setIfNotSet(loadInfo, "rvm.filter.numExcludeNodes", std::to_string(info.filter_excludeNodes.size()));
      for (size_t i = 1; i <= info.filter_excludeNodes.size(); ++i)
        ::setIfNotSet(loadInfo, "rvm.filter.excludeNode" + std::to_string(i), info.filter_excludeNodes[i - 1]);
    }
 
    // Save RVM Tasks defintions. Runs in this order.
    ::setIfNotSet(loadInfo, "rvm.filter.filter", info.taskFilter);
 
    p.model = context->modelManager->loadResource(&loadInfo);
 
    LOG_DEBUG(logger, "Approximate command line: %s"
              " --rvm.tessellate.tolerance=%.2f"
              " --rvm.tessellate.remesh=%.2f"
              " --rvm.tessellate.remeshGridSpacing=%.4f"
              " --rvm.tessellate.remeshVolumeBlur=%d"
              " --rvm.tessellate.remeshTriSoupBlur=%d"
              " --rvm.tessellate.remeshSimplification=%.2f"
              " --rvm.tessellate.featureAngle=%.2f"
              " --rvm.tessellate.cullDiameter=%.2f"
              " --rvm.tessellate.cullGeometryThreshold=%.2f"
              " --rvm.tessellate.cullLeafThreshold=%.2f"
              " --rvm.tessellate.simplificationFactor=%.2f"
              " --rvm.tessellate.simplificationMode=%d"
              ,
              info.source.c_str(),
              p.tolerance,
              p.remesh,
              p.remeshGridSpacing,
              p.remeshVolumeBlur,
              p.remeshTriSoupBlur,
              p.remeshSimplification,
              p.featureAngle,
              p.cullDiameter,
              p.cullGeometry,
              p.cullLeaf,
              p.simplificationFactor,
              p.simplificationMode);
  }
 
  void parameterizationWaitForLoad(Context* context, SparseOctree::Parameterization& p)
  {
    Timer timer = Timer::startNew();
    do {
      Cogs::Core::runFrames(context, 2);
      p.isLoaded = ((p.model->getFlags() & (ResourceFlags::Loaded | ResourceFlags::FailedLoad)) != 0);
      if (10.0 * 60.0 * 60.0 < timer.elapsedSeconds()) {
        LOG_FATAL(logger, "Failed to load model in 10 hours, breaking out.");
        break;
      }
    }
    while (p.isLoaded == false);
  }
 
  void levelInitCells(Context* /*context*/, SparseOctree::Grid& grid, const SparseOctree::Octree& octree, const size_t level)
  {
    const SparseOctree::SceneInfo& scene = octree.scenes[level];
    const Geometry::BoundingBox& bounds = scene.bounds;
    size_t xSize = octree.grids[level].dimensions.x;
    size_t ySize = octree.grids[level].dimensions.y;
    size_t zSize = octree.grids[level].dimensions.z;
 
    LOG_DEBUG(logger, " +- dimensions: [%zu %zu %zu]", xSize, ySize, zSize);
 
    if (isEmpty(bounds)) {
      LOG_DEBUG(logger, " +- bounding box: <empty>");
      return;
    }
    LOG_DEBUG(logger, " +- bounding box: [%.2f %.2f %.2f] x [%.2f %.2f %.2f]",
              bounds.min.x, bounds.min.y, bounds.min.z,
              bounds.max.x, bounds.max.y, bounds.max.z);
    glm::vec3 size = bounds.max - bounds.min;
    grid.origin = bounds.min;
    grid.cellSize = size / glm::vec3(xSize, ySize, zSize);
  }
 
  SparseOctree::CellIndex createCell(SparseOctree::Grid& grid, SparseOctree::CellMapKey key, size_t i, size_t j, size_t k)
  {
    SparseOctree::CellIndex cellIndex = grid.cellStore.size();
 
    grid.cellMap.emplace(key, cellIndex);
 
    SparseOctree::Cell& cell = grid.cellStore.emplace_back();
    cell.x = static_cast<uint32_t>(i);
    cell.y = static_cast<uint32_t>(j);
    cell.z = static_cast<uint32_t>(k);
    return cellIndex;
  }
 
  void levelFilterEntities(Context* /*context*/, SparseOctree::Grid& grid, SparseOctree::Octree& octree, size_t level) {
 
    const SparseOctree::SceneInfo& scene = octree.scenes[level];
    const SparseOctree::LevelInput& input = octree.inputs[level];
 
    const float cullingThreshold = std::min(scene.maxGeometrySize, input.cullingThreshold);
 
    float maxDensity = 0.0f;
    float minDensity = 1000000000.0f;
    size_t outliers = 0;
 
    // Filter out entitites that we should 
    std::vector<const SparseOctree::EntityRef*> filteredEntities;
    filteredEntities.reserve(scene.entities.size());
 
    struct {
      size_t explicitlySkipped = 0;
      size_t missingMesh = 0;
      size_t smallerThanCullingThreshold = 0;
      size_t biggerThanMaxSize = 0;
    } skipStats;
 
    for (auto& e : scene.entities) {
      if (e.skip) { skipStats.explicitlySkipped++; continue; }
      if (!e.mesh) { skipStats.missingMesh++; continue; }
      if (e.maxDim < cullingThreshold) { skipStats.smallerThanCullingThreshold++; continue; }
      if (e.maxDim > 10000000) { skipStats.biggerThanMaxSize++; continue; }
 
      assert(!glm::any(glm::isnan(e.box.min)) && !glm::any(glm::isnan(e.box.max)) && "NaN in our boxes.");
 
      if (octree.info.discardOutliers) {
        const size_t count = e.mesh->getCount();
        const glm::vec3 diag = e.box.max - e.box.min;
        const float volume = diag.x * diag.y * diag.z;
        const float density = (float)count / volume;
 
        if (count > size_t(octree.info.outlierMinVertexCount) && density > octree.info.outlierMinVertexDensity && volume < octree.info.outlierMaxVolume) {
          LOG_DEBUG(logger, "Count: %zu", count);
          LOG_DEBUG(logger, "Volume:  %f", volume);
          LOG_DEBUG(logger, "Density: %f", density);
 
          ++outliers;
 
          maxDensity = std::max(maxDensity, density);
          minDensity = std::min(minDensity, density);
 
          if (octree.info.outputOutliers) {
            filteredEntities.push_back(&e);
          }
        }
        else if (!octree.info.outputOutliers) {
          filteredEntities.push_back(&e);
        }
      }
      else {
        filteredEntities.push_back(&e);
      }
    }
 
    if (outliers) {
      LOG_INFO(logger, "Outliers: %zu", outliers);
      LOG_INFO(logger, "Max density: %f", maxDensity);
      LOG_INFO(logger, "Min density: %f", minDensity);
    }
 
 
 
    size_t meshCellOverlap = 0;
    const Geometry::BoundingBox bounds = scene.bounds;
    for (const SparseOctree::EntityRef* e : filteredEntities) {
 
      const Geometry::BoundingBox& bbox = e->box;
      assert(e->box.min.x <= e->box.max.x && e->box.min.y <= e->box.max.y && e->box.min.z <= e->box.max.z);
 
      glm::vec3 flo = glm::max(glm::vec3(0.f), glm::floor((bbox.min - bounds.min) / grid.cellSize));
      glm::vec3 fhi = glm::max(glm::vec3(0.f), glm::floor((bbox.max - bounds.min) / grid.cellSize));
 
      glm::uvec3 lo = glm::uvec3(flo);
      glm::uvec3 hi = glm::min(glm::uvec3(fhi) + glm::uvec3(1), grid.dimensions);
 
      for (size_t k = lo.z; k < hi.z; k++) {
        for (size_t j = lo.y; j < hi.y; j++) {
          for (size_t i = lo.x; i < hi.x; i++) {
 
            assert(i < grid.dimensions.x && j < grid.dimensions.y && k < grid.dimensions.z);
 
            SparseOctree::CellIndex cellIndex;
            SparseOctree::CellMapKey key = grid.cellMapKey(i, j, k);
            if (auto it = grid.cellMap.find(key); it != grid.cellMap.end()) {
              cellIndex = it->second;
              SparseOctree::Cell& cell = grid.cellStore[cellIndex];
              assert(cell.x == i && cell.y == j && cell.z == k);
            }
            else {
              // Create new cell
              cellIndex = createCell(grid, key, i, j, k);
 
              // Make sure that all ancestors exist so cells are always connected upwards
              size_t kk = k;
              size_t jj = j;
              size_t ii = i;
              for (size_t l = level + 1; l < octree.numLevels; l++) {
                kk /= 2;
                jj /= 2;
                ii /= 2;
                SparseOctree::Grid& ancestorGrid = octree.grids[l];
                SparseOctree::CellMapKey ancestorKey =  ancestorGrid.cellMapKey(ii, jj, kk);
                if (auto at = ancestorGrid.cellMap.find(ancestorKey); at != ancestorGrid.cellMap.end()) {
                  break;
                }
                else {
                  SparseOctree::CellIndex ancestorIndex = createCell(ancestorGrid, ancestorKey, ii, jj, kk);
                  SparseOctree::Cell& ancestorCell = ancestorGrid.cellStore[ancestorIndex];
                  assert(ancestorCell.x == ii && ancestorCell.y == jj && ancestorCell.z == kk);
                }
              }
 
            }
 
            SparseOctree::Cell& cell = grid.cellStore[cellIndex];
            assert(cell.x == i && cell.y == j && cell.z == k);
 
            cell.touches.push_back(e->index);
            meshCellOverlap++;
          }
        }
      }
    }
 
    for (SparseOctree::Cell& cell : grid.cellStore) {
      cell.bbox.min = grid.origin + grid.cellSize * glm::vec3(cell.x, cell.y, cell.z);
      cell.bbox.max = grid.origin + grid.cellSize * glm::vec3(cell.x + 1, cell.y + 1, cell.z + 1);
    }
 
    LOG_DEBUG(logger, "FilterEntities: initial=%zu, survived=%zu, explicitlySkipped=%zu, missingMesh=%zu smallerThanCullingThreshold=%zu, biggerThanMaxSize=%zu",
                scene.entities.size(), filteredEntities.size(),
                skipStats.explicitlySkipped, skipStats.missingMesh, skipStats.smallerThanCullingThreshold, skipStats.biggerThanMaxSize);
 
    LOG_DEBUG(logger, "FilterEntities: meshCellOverlap=%zu", meshCellOverlap);
  }
 
  void levelGetModelAndBounds(SparseOctree::Octree& octree, SparseOctree::SceneInfo& scene, float maxTolerance)
  {
    Model& model = *scene.model.resolve();
 
    scene.entities.resize(model.parts.size());
 
    scene.bounds = Geometry::BoundingBox();
    for (size_t i = 0; i < model.parts.size(); ++i) {
      const ModelPart& part = model.parts[i];
      SparseOctree::EntityRef& e = scene.entities[i];
 
      e.index = (uint32_t)i;
      e.parent = part.parentIndex;
 
      if (part.nameIndex != (uint32_t)-1) {
        auto name = model.getPartName(part);
 
        if (octree.info.skipPattern.size() && name.find(octree.info.skipPattern) != StringView::NoPosition) {
          LOG_INFO(logger, "Skipped object %.*s", StringViewFormat(name));
          e.skip = true;
        }
      }
 
      if (part.meshIndex != (uint32_t)-1) {
        e.mesh = model.meshes[part.meshIndex];
 
        if (e.mesh->primitiveType != PrimitiveType::TriangleList) {
          continue;
        }
 
        // Skip degenerate meshes.
        if (e.mesh->getCount() < 3) {
          LOG_ERROR(logger, "Skipped part %zu with degenerate mesh; %u count.", i, e.mesh->getCount());
          e.mesh = {};
          continue;
        }
 
        if (part.materialIndex != NoIndex) {
          e.material = model.materials[part.materialIndex];
        }
        e.startIndex = part.startIndex;
        e.vertexCount = part.vertexCount;
 
        if (part.boundsIndex != (uint32_t)-1) {
          e.box = model.bounds[part.boundsIndex];
        }
        else {
          if (isEmpty(e.mesh->boundingBox)) {
            e.mesh->setBounds(calculateBounds(e.mesh.resolve()));
          }
          e.box = e.mesh->boundingBox;
 
          if (octree.info.useMinBounds && glm::any(glm::lessThan(e.box.min, octree.info.minBounds))) {
            LOG_ERROR(logger, "Skipped part %zu with invalid min bounds: [ %.3f, %.3f, %.3f ].", i, e.box.min.x, e.box.min.y, e.box.min.z);
            e.mesh = {};
            continue;
          }
 
          if (octree.info.useMaxBounds && glm::any(glm::greaterThan(e.box.max, octree.info.maxBounds))) {
            LOG_ERROR(logger, "Skipped part %zu with invalid max bounds: [ %.3f, %.3f, %.3f ].", i, e.box.max.x, e.box.max.y, e.box.max.z);
            e.mesh = {};
            continue;
          }
        }
        scene.bounds += e.box;
        e.span = e.box.max - e.box.min;
        e.maxDim = glm::compMax(e.span);
 
        scene.geometries++;
        scene.maxGeometrySize = std::max(scene.maxGeometrySize, e.maxDim);
      }
    }
 
    // Remeshing slightly grows tiny shapes, so a coarse level can be bigger than a detailed level.
    // We adust bounds a bit to accommodate this.
    if (!isEmpty(scene.bounds)) {
      scene.bounds.min -= glm::vec3(maxTolerance);
      scene.bounds.max += glm::vec3(maxTolerance);
    }
  }
 
  bool calculateLevelSizes(SparseOctree::Octree & octree)
  {
    if (!octree.scenes[0].geometries) return false;
 
    const uint32_t maxCells = (uint32_t)std::pow(2, octree.numLevels);
 
    glm::vec3 size0 = octree.scenes[0].bounds.max - octree.scenes[0].bounds.min;
 
    glm::uvec3 cells(maxCells);       // number of cells in X, Y, Z
    glm::uvec3 levels(octree.numLevels);     // number of lod levels along X, Y, Z
 
    // Cell size at most detailed level
    glm::vec3 cellSize(size0.x / cells.x, size0.y / cells.y, size0.z / cells.z);
 
    // Reduce number of lod-levels in direction if cells are smaller than minCellSize
    for (uint32_t l = 0; l < octree.numLevels; ++l) {
      for (uint32_t i = 0; i < 3; ++i) {
        if (cellSize[i] > octree.minCellSize) continue;
        --levels[i];
        cells[i] = (uint32_t)std::pow(2u, levels[i]);
        cellSize[i] = size0[i] / cells[i];
      }
    }
 
 
    for (uint32_t l = 0; l < octree.numLevels; ++l) {
      for (uint32_t i = 0; i < 3; ++i) {
        if (l < (levels[i] - 1) && levels[i] != 0) {
          assert(l + 1 <= levels[i]);
          octree.grids[l].dimensions[i] = 1u << (levels[i] - l - 1);
        } else {
          octree.grids[l].dimensions[i] = 1;
        }
      }
    }
 
    assert(octree.inputs.size() >= octree.numLevels && "Invalid inputs.");
 
 
    return true;
  }
 
  Value jsonEncodeMeshReference(MemoryPoolAllocator<CrtAllocator>& alloc, const SparseOctree::OctreeInfo& info, const SparseOctree::MeshRef& meshRef, bool includeBounds)
  {
    Value value(kObjectType);
 
    if (includeBounds && info.embedMeshBounds && !isEmpty(meshRef.bbox)) {
      Value bbox(kArrayType);
      bbox.PushBack(meshRef.bbox.min.x, alloc);
      bbox.PushBack(meshRef.bbox.min.y, alloc);
      bbox.PushBack(meshRef.bbox.min.z, alloc);
      bbox.PushBack(meshRef.bbox.max.x, alloc);
      bbox.PushBack(meshRef.bbox.max.y, alloc);
      bbox.PushBack(meshRef.bbox.max.z, alloc);
 
      Value properties(kObjectType);
      properties.AddMember("bbox", Value(bbox, alloc), alloc);
 
      value.AddMember("properties", properties, alloc);
    }
 
    if (meshRef.part == (uint32_t)-1) {
      value.AddMember("model", Value(meshRef.fileName.c_str(), alloc), alloc);
    }
    else {
      Value model(kObjectType);
      model.AddMember("source", Value(meshRef.fileName.c_str(), alloc), alloc);
      model.AddMember("part", Value(meshRef.part), alloc);
      value.AddMember("model", model, alloc);
    }
    return value;
  }
 
  Value jsonEncodeMeshReferences(MemoryPoolAllocator<CrtAllocator>& alloc, const SparseOctree::OctreeInfo& info, const SparseOctree::Cell& cell, bool forceBounds)
  {
    // Note: We only try to include the bounding box if there are multiple mesh references. If there is a single
    // mesh reference, that corresponds to the whole cell (=lod-node), and the asset system already culls for that.
 
    if (cell.meshRefs.empty()) return Value();
 
    if (cell.meshRefs.size() == 1) return jsonEncodeMeshReference(alloc, info, cell.meshRefs[0], forceBounds);
 
    Value value(kArrayType);
    for (const SparseOctree::MeshRef& meshRef : cell.meshRefs) {
      value.PushBack(jsonEncodeMeshReference(alloc, info, meshRef, true), alloc);
    }
    return value;
  }
 
  void jsonWriteAsset(MemoryPoolAllocator<CrtAllocator>& alloc,
                      const SparseOctree::OctreeInfo& info,
                      const std::string& filename,
                      Value root)
  {
    Document hDoc(&alloc);
    hDoc.SetObject();
    Value entities(kArrayType);
    entities.PushBack(root, alloc);
    hDoc.AddMember("entities", entities, alloc);
 
    StringBuffer buffer;
 
    if (info.prettyPrint) {
      PrettyWriter<StringBuffer> writer(buffer);
      writer.SetIndent(' ', 2);
      writer.SetMaxDecimalPlaces(4);
      hDoc.Accept(writer);
    }
    else {
      Writer<StringBuffer> writer(buffer);
      writer.SetMaxDecimalPlaces(4);
      hDoc.Accept(writer);
    }
 
    if (0 < info.compressionLevel) {
 
      ZSTD_CCtx* zstd_ctx = ZSTD_createCCtx();
 
      size_t uncompressedSize = buffer.GetSize();
      size_t maxSize = ZSTD_compressBound(uncompressedSize);
      Memory::MemoryBuffer compressed(maxSize);
 
      size_t result = ZSTD_compressCCtx(zstd_ctx, compressed.data(), maxSize, buffer.GetString(), uncompressedSize, info.compressionLevel);
      if (ZSTD_isError(result)) {
        LOG_ERROR(logger, "%s: zstd compression failed: %s", filename.c_str(), ZSTD_getErrorName(result));
        return;
      }
      else if (uncompressedSize <= result) {
        LOG_WARNING(logger, "%s: compressed size greater or equal to uncompressed size", filename.c_str());
      }
      ZSTD_freeCCtx(zstd_ctx);
 
      std::ofstream file(filename, std::ios::binary);
      file.write((const char*)compressed.data(), result);
      file.close();
    }
    else {
      std::ofstream file(filename);
      file.write(buffer.GetString(), buffer.GetSize());
      file.close();
    }
 
    LOG_INFO(logger, "Wrote asset %s.", filename.c_str());
  }
 
}
 
void Cogs::Core::SparseBuildOctreeCommand::exportAsset(Context * context, SparseOctree::Octree & octree)
{
  MemoryPoolAllocator alloc;
 
  std::vector<std::vector<uint32_t>> weightsPerLevel(octree.numLevels);
  std::vector<std::vector<Value>> valuesPerLevel(octree.numLevels);
 
  const SparseOctree::OctreeInfo& info = octree.info;
 
  std::vector<Geometry::BoundingBox> bounds, childBounds;
 
  for (size_t level = 0; level < octree.numLevels; ++level) {
    size_t xSize = octree.grids[level].dimensions.x;
    size_t ySize = octree.grids[level].dimensions.y;
    size_t zSize = octree.grids[level].dimensions.z;
 
    const SparseOctree::Grid& grid = octree.grids[level];
 
    childBounds.swap(bounds);
    bounds.resize(grid.cellStore.size());
 
    if (level == 0) {
 
      // FIXME: This should really be the mesh bounds
      for (size_t i = 0, n = bounds.size(); i < n; i++) {
        bounds[i] = grid.cellStore[i].bbox;
      }
    }
 
    else {
      const glm::uvec3 childLayerDim = octree.grids[level - 1].dimensions;
 
      const SparseOctree::Grid& childGrid = octree.grids[level - 1];
      assert(childBounds.size() == childGrid.cellStore.size());
 
      for (size_t i = 0, n = bounds.size(); i < n; i++) {
 
        const SparseOctree::Cell& cell = grid.cellStore[i];
 
        // Build aggregate bounds that fully enclose child nodes, which
        // might be bigger than the bounds of the current cell
        Geometry::BoundingBox box = cell.bbox;
 
        size_t x0 = 2 * cell.x;
        size_t x1 = std::min(x0 + 2, size_t(childGrid.dimensions.x));
 
        size_t y0 = 2 * cell.y;
        size_t y1 = std::min(y0 + 2, size_t(childGrid.dimensions.y));
 
        size_t z0 = 2 * cell.z;
        size_t z1 = std::min(z0 + 2, size_t(childGrid.dimensions.z));
 
        for (size_t z = z0; z < z1; z++) {
          for (size_t y = y0; y < y1; y++) {
            for (size_t x = x0; x < x1; x++) {
 
              SparseOctree::CellMapKey childKey = childGrid.cellMapKey(x, y, z);
              if (auto it = childGrid.cellMap.find(childKey); it != childGrid.cellMap.end()) {
                SparseOctree::CellIndex childIx = it->second;
                assert(childIx < childBounds.size());
                box += childBounds[childIx];
              }
            }
          }
        }
        bounds[i] = box;
      }
    }
    
 
    std::vector<Value>& values = valuesPerLevel[level];
    std::vector<uint32_t>& weights = weightsPerLevel[level];
 
    std::vector<Value>& prevValues = valuesPerLevel[level ? level - 1 : 0];
    std::vector<uint32_t>& prevWeights = weightsPerLevel[level ? level - 1 : 0];
 
    glm::uvec3 prevDims = octree.grids[level ? level - 1: level].dimensions;
 
    const SparseOctree::Grid& prevGrid = octree.grids[level ? level - 1 : 0];
 
    values.resize(grid.cellStore.size());
    weights.resize(grid.cellStore.size());
 
    std::string directory = IO::combine(info.filesDirectory, std::to_string(level));
    IO::createDirectories(IO::combine(directory, ".cogsbin"));
 
    for (size_t z = 0; z < zSize; ++z) {
      for (size_t y = 0; y < ySize; ++y) {
        for (size_t x = 0; x < xSize; ++x) {
 
          SparseOctree::CellMapKey key = grid.cellMapKey(x, y, z);
          auto it = grid.cellMap.find(key);
          if (it == grid.cellMap.end()) {
            continue;
          }
 
          SparseOctree::CellIndex cellIndex = it->second;
          const SparseOctree::Cell& cell = grid.cellStore[cellIndex];
          assert(cell.x == x && cell.y == y && cell.z == z);
 
          Value nodeValue(kNullType);
          uint32_t nodeWeight = static_cast<uint32_t>(cell.meshRefs.size());
 
          if (level == 0 && !cell.meshRefs.empty()) {
            // Force bounds on level 0 since they are otherwise only culled by the lod node at level 1, covering 2x2x2 of these.
            nodeValue = jsonEncodeMeshReferences(alloc, info, cell, true);
          }
          else if (level != 0) {
            Value lods(kArrayType);
            Value lvl0(kArrayType);
 
            uint32_t xFac = prevDims.x > xSize ? 2 : 1;
            uint32_t yFac = prevDims.y > ySize ? 2 : 1;
            uint32_t zFac = prevDims.z > zSize ? 2 : 1;
 
            for (uint32_t zz = 0; zz < zFac; ++zz) {
              for (uint32_t yy = 0; yy < yFac; ++yy) {
                for (uint32_t xx = 0; xx < xFac; ++xx) {
 
                  size_t i = x * xFac + xx;
                  size_t j = y * yFac + yy;
                  size_t k = z * zFac + zz;
 
                  SparseOctree::CellMapKey childKey = prevGrid.cellMapKey(i, j, k);
                  if (auto jt = prevGrid.cellMap.find(childKey); jt != prevGrid.cellMap.end()) {
 
                    Value& v = prevValues[jt->second];
                    if (v.IsArray()) {
                      for (rapidjson::SizeType r = 0; r < v.Size(); r++) {
                        lvl0.PushBack(v[r], alloc);
                      }
                    }
                    else if (!v.IsNull()) {
                      lvl0.PushBack(v, alloc);
                    }
                    nodeWeight += prevWeights[jt->second];
                  }
                }
              }
            }
            if (cell.meshRefs.empty() && lvl0.Empty()) continue;
 
            Value lvl1 = jsonEncodeMeshReferences(alloc, info, cell, false);
 
            glm::vec3 min = bounds[cellIndex].min;
            glm::vec3 max = bounds[cellIndex].max;
            Value bbox(kArrayType);
            bbox.PushBack(Value(min.x), alloc);
            bbox.PushBack(Value(min.y), alloc);
            bbox.PushBack(Value(min.z), alloc);
            bbox.PushBack(Value(max.x), alloc);
            bbox.PushBack(Value(max.y), alloc);
            bbox.PushBack(Value(max.z), alloc);
 
            Value errors(kArrayType);
            if (octree.inputs[level].threshold < 0) {
              errors.PushBack(Value(level * 10.0f - 5), alloc);
              errors.PushBack(Value(level * 10.0f + 5), alloc);
            }
            else {
              errors.PushBack(Value(octree.inputs[level - 1].threshold), alloc);
              errors.PushBack(Value(octree.inputs[level].threshold), alloc);
            }
 
            Value properties(kObjectType);
            properties.AddMember("bbox", bbox, alloc);
            properties.AddMember("errors", errors, alloc);
 
            if (lvl0.Size() == 0) {
              // Empty array, just encode as empty object
              lods.PushBack(Value(kObjectType), alloc);
            }
            else if (lvl0.Size() == 1) {
              // Single element array, encode as single object
              lods.PushBack(lvl0[0], alloc);
            }
            else {
              // Encode as array
              lods.PushBack(lvl0, alloc);
            }
 
            if (lvl1.IsNull()) {
              // If the cell is empty, encode as empty object
              lods.PushBack(Value(kObjectType), alloc);
            }
            else {
              lods.PushBack(lvl1, alloc);
            }
 
            auto name = std::string("lod_") + std::to_string(level) + ":" + std::to_string(x) + ":" + std::to_string(y);
 
            nodeValue = Value(kObjectType);
            nodeValue.AddMember("name", Value(name.c_str(), alloc), alloc);
            nodeValue.AddMember("type", Value("LodGroup", alloc), alloc);
            nodeValue.AddMember("properties", properties, alloc);
            nodeValue.AddMember("lods", lods, alloc);
          }
 
          if ((level + 2 < octree.numLevels) && info.maxSubtreeSize && info.maxSubtreeSize < nodeWeight && nodeValue.IsObject()) {
            const std::string relative = info.name +
              "_L" + std::to_string(level) +
              "_" + std::to_string(x) +
              "_" + std::to_string(y) +
              "_" + std::to_string(z) +
              ".asset";
 
            const std::string filename = IO::combine(info.layerDirectory, relative);
            jsonWriteAsset(alloc, info, filename, std::move(nodeValue));
 
            Value asset(kObjectType);
            asset.AddMember("source", Value(relative.c_str(), alloc), alloc);
            asset.AddMember("flags", Value("InstantiateOnDemand | RelativePaths", alloc), alloc);
            nodeValue = Value(kObjectType);
            nodeValue.AddMember("asset", asset, alloc);
            nodeWeight = 1;
          }
 
          values[cellIndex] = nodeValue;
          weights[cellIndex] = nodeWeight;
        }
      }
    }
  }
 
  const std::string filename = info.assetFileNameStem + ".asset";
  jsonWriteAsset(alloc, info, filename, std::move(valuesPerLevel[octree.numLevels - 1][0]));
  if (info.statistics) {
    AssetStatsCommand::calculateStats(context, properties, filename, info.assetFileNameStem + "_stats.json");
  }
}
 
namespace
{
  bool matchFilename2(const std::string name, const std::string pattern)
  {
    const auto extension = Cogs::IO::extension(pattern);
    const auto stem = Cogs::IO::stem(pattern);
 
    bool extensionMatch = false;
    auto entryExtension = Cogs::IO::extension(name);
    auto entryStem = Cogs::IO::stem(name);
 
    if (extension == "*") {
      extensionMatch = true;
    }
    else if (extension == entryExtension) {
      extensionMatch = true;
    }
 
    bool patternMatch = false;
 
    if (stem == "*") {
      patternMatch = true;
    }
    else if (stem.find('*') != std::string::npos) {
      auto stemEx = stem;
      stemEx.replace(stem.find('*'), 1, ".*");
 
      std::regex stemRegex(stemEx);
 
      std::smatch match;
      std::regex_search(entryStem, match, stemRegex);
      if (match.size()) patternMatch = true;
    } else if (entryStem == stem) {
      patternMatch = true;
    }
 
    return extensionMatch && patternMatch;
  }
}
 
void Cogs::Core::SparseBuildOctreeCommand::apply()
{
  
}
 
void Cogs::Core::SparseBuildOctreeCommand::undo()
{
 
}
 
namespace
{
  std::span<const float> getArrayProp(Cogs::Core::PropertyStore & properties, Cogs::Core::StringRef key)
  {
    auto index = properties.findProperty(0, properties.size(), key);
    return index != (unsigned)-1 ? properties.getFloatArray(index) : std::span<float>{};
  }
}
 
void Cogs::Core::SparseBuildOctreeCommand::applyPost()
{
  context->variables->get("resources.globalFrameUpdateQuota")->setInt(0);
 
  auto source = properties.getProperty("source", StringView());
  auto pattern = properties.getProperty("pattern", StringView()).to_string();
  auto prePattern = properties.getProperty("prePattern", StringView()).to_string();
  if (!prePattern.empty()) {
    pattern = prePattern + pattern;
  }
  auto postPattern = properties.getProperty("postPattern", StringView()).to_string();
  if (!postPattern.empty()) {
    pattern = pattern + postPattern;
  }
  auto directory = IO::absolute(source.to_string());
  auto outDirectory = properties.getProperty("destination", StringView());
  const bool forceUpdate = properties.getProperty("forceUpdate", false);
  auto assetFileName = properties.getProperty("fileName", StringView("Out.asset")).to_string();
 
  std::vector<std::string> sources;
 
  LOG_DEBUG(logger, "Matching files for pattern %s in %.*s:", pattern.c_str(), StringViewFormat(source));
 
  if(IO::isFile(directory)) {
    sources.emplace_back(directory);
  }
  else {
    for (auto& entry : IO::directoryIterator(directory)) {
      std::string path;
      try {
        path = IO::getPath(entry);
      }
      catch (std::system_error& e) {
        LOG_FATAL(logger, "Failed to handle path, code=%d: %s", e.code().value(), e.what());
        abort();
      }
      if (IO::isFile(path)) {
        auto dirname = IO::parentPath(path);
        auto filename = IO::fileName(path);
        if (matchFilename2(filename, pattern)) {
          LOG_DEBUG(logger, "  Matched source %s", filename.c_str());
          sources.emplace_back(path);
        }
      }
    }
  }
 
  if (sources.empty()) {
    LOG_WARNING(logger, "Matching sources empty for pattern %s in %.*s.", pattern.c_str(), StringViewFormat(source));
    return;
  }
 
  std::vector<SparseOctree::OctreeInfo> infos;
 
  for (auto & source_ : sources) {
    SparseOctree::OctreeInfo& info = infos.emplace_back();
    info.source = source_;
    info.name = IO::stem(info.source);
    info.absolute = IO::absolute(info.source);
    info.directory = IO::absolute(outDirectory.to_string());
    info.layer = IO::stem(assetFileName);
    info.layerDirectory = IO::combine(outDirectory.to_string(), info.layer);
    info.filesDirectory = IO::combine(info.layerDirectory, info.name);
    info.assetFileNameStem = IO::combine(info.layerDirectory, info.name);
    info.layerAndName = IO::combine(info.layer, info.name);
    info.keepList = IO::absolute(properties.getProperty("keepList", StringView()).to_string());
    info.discardOutliers = properties.getProperty("discardOutliers", info.discardOutliers);
    info.outlierMinVertexCount = properties.getProperty("outlierMinVertexCount", info.outlierMinVertexCount);
    info.outlierMinVertexDensity = properties.getProperty("outlierMinVertexDensity", info.outlierMinVertexDensity);
    info.outlierMaxVolume = properties.getProperty("outlierMaxVolume", info.outlierMaxVolume);
    info.outputOutliers = properties.getProperty("outputOutliers", info.outputOutliers);
    info.maxSubtreeSize = static_cast<uint32_t>(std::max(0, static_cast<int>(properties.getProperty("maxSubtreeSize", info.maxSubtreeSize))));
    info.maxMeshVertexCount = properties.getProperty("maxMeshVertexCount", info.maxMeshVertexCount);
    info.maxModelVertexCount = properties.getProperty("maxModelVertexCount", info.maxModelVertexCount);
    info.maxModelMeshCount = properties.getProperty("maxModelMeshCount", info.maxModelMeshCount);
    info.dropReductionLevelThreshold = properties.getProperty("dropReductionLevelThreshold", info.dropReductionLevelThreshold);
    info.dropReductionThreshold = properties.getProperty("dropReductionThreshold", info.dropReductionThreshold);
    info.minReductionThreshold = properties.getProperty("minReductionThreshold", info.minReductionThreshold);
    info.edgeLengthWeight = properties.getProperty("edgeLengthWeight", info.edgeLengthWeight);
    info.skipPattern = properties.getProperty("skipPattern", info.skipPattern).to_string();
    info.useCompression = properties.getProperty("useCompression", info.useCompression);
    info.prettyPrint = properties.getProperty("prettyPrint", info.prettyPrint);
    info.compressionLevel = properties.getProperty("compressionLevel", info.compressionLevel);
    info.embedMeshBounds = properties.getProperty("embedMeshBounds", info.embedMeshBounds);
    info.statistics = properties.getProperty("statistics", info.statistics);
    info.colorizeLevels = properties.getProperty("colorizeLevels", info.colorizeLevels);
 
    info.filter_rootEndsWith = properties.getProperty("filter_rootEndsWith", info.filter_rootEndsWith).to_string();
    info.filter_rootIncludes = properties.getProperty("filter_rootIncludes", info.filter_rootIncludes).to_string();
    info.filter_rootPattern = properties.getProperty("filter_rootPattern", info.filter_rootPattern).to_string();
    info.filter_attributeName = properties.getProperty("filter_attributeName", info.filter_attributeName).to_string();
    info.filter_attributeValue = properties.getProperty("filter_attributeValue", info.filter_attributeValue).to_string();
 
    info.filter_excludeNodes.clear();
 
    Cogs::StringView levelReducer = properties.getProperty("levelReducer", "rationalreducer-vertexcount");
    switch (levelReducer.hashLowercase()) {
    case Cogs::hash("rationalreducer-vertexcount"):
      LOG_DEBUG(logger, "levelReducer=rationalreducer-vertexcount");
      info.levelReducer = SparseOctree::LevelReducer::RationalReducerVertexCount;
      break;
    case Cogs::hash("meshoptimizer-vertexcount"):
      LOG_DEBUG(logger, "levelReducer=meshoptimizer-vertexcount");
      info.levelReducer = SparseOctree::LevelReducer::MeshOptimizerVertexCount;
      break;
    case Cogs::hash("meshoptimizer-sloppy-vertexcount"):
      LOG_DEBUG(logger, "levelReducer=meshoptimizer-sloppy-vertexcount");
      info.levelReducer = SparseOctree::LevelReducer::MeshOptimizerSloppyVertexCount;
      break;
    default:
      LOG_ERROR(logger, "Unknown levelReducer \"%.*s\"", StringViewFormat(levelReducer));
      break;
    }
 
    // Allow filtering one node: "filter_excludeNode"
    // Real solution for clients is to use the "filter" with Full filter desc in JSON.
    auto prop = properties.getProperty("filter_excludeNode", "").to_string();
    if (!prop.empty())
      info.filter_excludeNodes.emplace_back(std::move(prop));
 
    // Extract RVM Tasks defintions. Runs in this order. Custom compatibility read for "filter".
    // info.tasks =         properties.getProperty("rvm.tasks", info.tasks).to_string();
    info.taskFilter =    properties.getProperty("filter", info.taskFilter).to_string();
    info.taskFilter =    properties.getProperty("rvm.filter.filter", info.taskFilter).to_string();
 
    // Copy all properties from input:
    info.properties = properties;
 
    auto minBoundsId = properties.findProperty("minBounds");
    if (minBoundsId != (unsigned)-1) {
      auto vals = getArrayProp(properties, Strings::add("minBounds"));
      info.minBounds = glm::vec3(vals[0], vals[1], vals[2]);
      info.useMinBounds = true;
    }
 
    auto maxBoundsId = properties.findProperty("maxBounds");
    if (maxBoundsId != (unsigned)-1) {
      auto vals = getArrayProp(properties, Strings::add("maxBounds"));
      info.maxBounds = glm::vec3(vals[0], vals[1], vals[2]);
      info.useMaxBounds = true;
    }
 
 
    LOG_DEBUG(logger, "maxSubtreeSize=%u maxMeshVertexCount=%d  maxModelVertexCount=%d maxModelMeshCount=%d",
              info.maxSubtreeSize, info.maxMeshVertexCount, info.maxModelVertexCount, info.maxModelMeshCount);
 
    const std::string assetFileNam = info.assetFileNameStem + ".asset";
    if (!forceUpdate && IO::exists(assetFileNam)) {
      LOG_DEBUG(logger, "Skipping writing %s, as the output already exists.", assetFileNam.c_str());
      continue;
    }
 
    buildOctree(info);
 
    Cogs::Core::runFrames(context, 3);
  }
 
  Document hDoc;
  hDoc.SetObject();
  auto & hAlloc = hDoc.GetAllocator();
  Value entities(kArrayType);
 
  for (auto & info : infos) {
    if (info.isEmpty) {
      LOG_WARNING(logger, "Skipped linking empty %s.", info.assetFileNameStem.c_str());
      continue;
    }
 
    Value e(kObjectType);
 
    Value asset(kObjectType);
    asset.AddMember("source", Value(std::string(info.layerAndName + ".asset").c_str(), hAlloc), hAlloc);
    asset.AddMember("flags", Value("InstantiateOnDemand | RelativePaths", hAlloc), hAlloc);
 
    e.AddMember("asset", asset, hAlloc);
 
    entities.PushBack(e, hAlloc);
  }
 
  hDoc.AddMember("entities", entities, hAlloc);
 
  if (properties.getProperty("skipAsset", false)) return;
 
  {
    StringBuffer buffer;
    PrettyWriter<StringBuffer> writer(buffer);
    writer.SetIndent(' ', 2);
    writer.SetMaxDecimalPlaces(4);
    hDoc.Accept(writer);
 
    auto path = IO::combine(outDirectory.to_string(), assetFileName);
    std::ofstream file(path);
    file.write(buffer.GetString(), buffer.GetSize());
    file.close();
 
    LOG_DEBUG(logger, "Wrote layer asset %s.", assetFileName.c_str());
  }
}
 
void Cogs::Core::SparseBuildOctreeCommand::buildOctree(SparseOctree::OctreeInfo & info)
{
  const std::span<const float> params                    = getArrayProp(properties, Strings::add("params"));
  const std::span<const float> paramRemesh               = getArrayProp(properties, Strings::add("paramRemesh"));
  const std::span<const float> paramRemeshGridSpacing    = getArrayProp(properties, Strings::add("paramRemeshGridSpacing"));
  const std::span<const float> paramRemeshVolumeBlur     = getArrayProp(properties, Strings::add("paramRemeshVolumeBlur"));
  const std::span<const float> paramRemeshTriSoupBlur    = getArrayProp(properties, Strings::add("paramRemeshTriSoupBlur"));
  const std::span<const float> paramRemeshSimplification = getArrayProp(properties, Strings::add("paramRemeshSimplification"));
  const std::span<const float> paramFeatureAngle         = getArrayProp(properties, Strings::add("paramFeatureAngle"));
  const std::span<const float> paramCullDiameter         = getArrayProp(properties, Strings::add("paramCullDiameter"));
  const std::span<const float> paramCullGeometry         = getArrayProp(properties, Strings::add("paramCullGeometry"));
  const std::span<const float> paramCullLeaf             = getArrayProp(properties, Strings::add("paramCullLeaf"));
  const std::span<const float> paramSimplificationFactor = getArrayProp(properties, Strings::add("paramSimplificationFactor"));
  const std::span<const float> paramSimplificationMode   = getArrayProp(properties, Strings::add("paramSimplificationMode")); // use float array as int array doesn't exist in property store
 
  // If any parametric values provided, use last value as default.
  // Otherwise try to fetch default from non-parametric property.
  SparseOctree::Parameterization defaults{};
  defaults.remesh               = paramRemesh.empty()               ? properties.getProperty("remesh", defaults.remesh)                             : paramRemesh.back();
  defaults.remeshGridSpacing    = paramRemeshGridSpacing.empty()    ? properties.getProperty("remeshGridSpacing", defaults.remeshGridSpacing)       : paramRemeshGridSpacing.back();
  defaults.remeshVolumeBlur     = paramRemeshVolumeBlur.empty()     ? properties.getProperty("remeshVolumeBlur", defaults.remeshVolumeBlur)         : static_cast<int>(paramRemeshVolumeBlur.back());
  defaults.remeshTriSoupBlur    = paramRemeshTriSoupBlur.empty()    ? properties.getProperty("remeshTriSoupBlur", defaults.remeshVolumeBlur)        : static_cast<int>(paramRemeshTriSoupBlur.back());
  defaults.remeshSimplification = paramRemeshSimplification.empty() ? properties.getProperty("remeshSimplification", defaults.remeshSimplification) : paramRemeshSimplification.back();
  defaults.featureAngle         = paramFeatureAngle.empty()         ? properties.getProperty("featureAngle", defaults.featureAngle)                 : paramFeatureAngle.back();
  defaults.cullDiameter         = paramCullDiameter.empty()         ? properties.getProperty("cullDiameter", defaults.cullDiameter)                 : paramCullDiameter.back();
  defaults.cullGeometry         = paramCullGeometry.empty()         ? properties.getProperty("cullGeometry", defaults.cullGeometry)                 : paramCullGeometry.back();
  defaults.simplificationMode   = paramSimplificationMode.empty()   ? properties.getProperty("simplificationMode", defaults.simplificationMode)     : static_cast<int>(paramSimplificationMode.back());
 
  float maxTolerance = 0.f;
  std::vector<SparseOctree::Parameterization> parameterizations(params.size());
  for (size_t i = 0; i < params.size(); ++i) {
    parameterizations[i].tolerance            = params[i];
    parameterizations[i].remesh               = i < paramRemesh.size()               ? paramRemesh[i]                               : defaults.remesh;
    parameterizations[i].remeshGridSpacing    = i < paramRemeshGridSpacing.size()    ? paramRemeshGridSpacing[i]                    : defaults.remeshGridSpacing;
    parameterizations[i].remeshVolumeBlur     = i < paramRemeshVolumeBlur.size()     ? static_cast<int>(paramRemeshVolumeBlur[i])   : defaults.remeshVolumeBlur;
    parameterizations[i].remeshTriSoupBlur    = i < paramRemeshTriSoupBlur.size()    ? static_cast<int>(paramRemeshTriSoupBlur[i])  : defaults.remeshTriSoupBlur;
    parameterizations[i].remeshSimplification = i < paramRemeshSimplification.size() ? paramRemeshSimplification[i]                 : defaults.remeshSimplification;
    parameterizations[i].featureAngle         = i < paramFeatureAngle.size()         ? paramFeatureAngle[i]                         : defaults.featureAngle;
    parameterizations[i].cullDiameter         = i < paramCullDiameter.size()         ? paramCullDiameter[i]                         : defaults.cullDiameter;
    parameterizations[i].cullGeometry         = i < paramCullGeometry.size()         ? paramCullGeometry[i]                         : defaults.cullGeometry;
    parameterizations[i].cullLeaf             = i < paramCullLeaf.size()             ? paramCullLeaf[i]                             : defaults.cullLeaf;
    parameterizations[i].simplificationFactor = i < paramSimplificationFactor.size() ? paramSimplificationFactor[i]                 : defaults.simplificationFactor;
    parameterizations[i].simplificationMode   = i < paramSimplificationMode.size()   ? static_cast<int>(paramSimplificationMode[i]) : defaults.simplificationMode;
    maxTolerance = std::max(maxTolerance, parameterizations[i].tolerance);
  }
 
  std::span<const float> lParams = getArrayProp(properties, Strings::add("levelParams"));
  std::span<const float> lReduction = getArrayProp(properties, Strings::add("levelReduction"));
  std::span<const float> lCulling = getArrayProp(properties, Strings::add("levelCulling"));
  std::span<const float> lThresholds = getArrayProp(properties, Strings::add("levelThresholds"));
 
  // Sanity checks:
  // - lParams defines # levels, lThresholds is padded if it is too small
  // - The rest should match.
  assert(!lParams.empty() && "Need at least one level");
  assert(lReduction.size() == lParams.size() && "levelReduction must be the same size as levelParams");
  assert(lCulling.size() == lParams.size() && "levelCulling must be the same size as levelParams");
  assert(lThresholds.size() <= lParams.size() && "more thresholds than levels");
 
  SparseOctree::Octree octree;
  octree.context = state->context;
  octree.info = info;
  octree.sources.assign(std::begin(parameterizations), std::end(parameterizations));
  octree.minCellSize = properties.getProperty("minCellSize", octree.minCellSize);
  octree.numLevels = static_cast<uint32_t>(lParams.size());
 
  octree.inputs.resize(octree.numLevels);
  for (size_t i = 0; i < lParams.size(); ++i) {
    const float threshold = lThresholds.size() > i ? lThresholds[i] : -1;
    octree.inputs[i] = SparseOctree::LevelInput{ (uint32_t)lParams[i], lReduction[i], lCulling[i], threshold };
  }
  octree.grids.resize(octree.numLevels);
  octree.scenes.resize(octree.numLevels);
 
  Cogs::Timer timerTotal = Timer::startNew();
  {
 
    // Load the first (and most detailed) parameterization, it is assumed that this
    // will have the largest boundingbox, and this will be used as bounds for the
    // entire pyramid.
    size_t parameterization = octree.inputs[0].parameterization;
    {
      SparseOctree::Parameterization& p = octree.sources[parameterization];
      if (p.isLoaded == false) {
        parameterizationTriggerload(context, p, octree.info);
        parameterizationWaitForLoad(context, p);
        if (!p.isLoaded) {
          LOG_ERROR(logger, "Model load failure");
          return;
        }
      }
      SparseOctree::SceneInfo& scene = octree.scenes[0];
      scene.model = octree.sources[octree.inputs[0].parameterization].model;
      scene.bounds = Geometry::makeEmptyBoundingBox<Geometry::BoundingBox>();
      levelGetModelAndBounds(octree, scene, maxTolerance);
      if (!calculateLevelSizes(octree)) {
        LOG_ERROR(logger, "No geometries found in level 0.");
        info.isEmpty = true;
        return;
      }
    }
    Geometry::BoundingBox bounds = octree.scenes[0].bounds;
    LOG_DEBUG(logger, "Overall bounding box: [%.2f %.2f %.2f]x[%.2f %.2f %.2f]).",
              bounds.min.x, bounds.min.y, bounds.min.z,
              bounds.max.x, bounds.max.y, bounds.max.z);
 
    for (size_t level = 0; level < octree.numLevels; level++) {
 
      LOG_DEBUG(logger, "Processing level %zu", level);
      
 
      // If we have a different parameterization for this level, unload the previous one
      if (parameterization != octree.inputs[level].parameterization) {
        if (parameterization != ~0u) {
          octree.sources[parameterization].model = ModelHandle();
          octree.sources[parameterization].isLoaded = false;
        }
        parameterization = octree.inputs[level].parameterization;
      }
      SparseOctree::Parameterization& p = octree.sources[parameterization];
      if (p.isLoaded == false) {
        parameterizationTriggerload(context, p, octree.info);
        parameterizationWaitForLoad(context, p);
        if (!p.isLoaded) {
          LOG_ERROR(logger, "Model load failure");
          return;
        }
      }
 
      SparseOctree::SceneInfo& scene = octree.scenes[level];
      if (level != 0) {
 
        // Load and check bounds, but we will use the bounds of level 0 for the grid
        // to make sure the levels fit together.
        scene.model = octree.sources[octree.inputs[level].parameterization].model;
        scene.bounds = Geometry::makeEmptyBoundingBox<Geometry::BoundingBox>();
        levelGetModelAndBounds(octree, scene, maxTolerance);
        if (!((bounds.min.x <= scene.bounds.min.x) && (scene.bounds.max.x <= bounds.max.x) &&
              (bounds.min.y <= scene.bounds.min.y) && (scene.bounds.max.y <= bounds.max.y) &&
              (bounds.min.z <= scene.bounds.min.z) && (scene.bounds.max.z <= bounds.max.z)))
        {
          LOG_WARNING(logger, "Bounding box of level %zu (=[%.2f %.2f %.2f]x[%.2f %.2f %.2f]) extends outside bounding box of level 0 (=[%.2f %.2f %.2f]x[%.2f %.2f %.2f]).",
                      level,
                      scene.bounds.min.x, scene.bounds.min.y, scene.bounds.min.z,
                      scene.bounds.max.x, scene.bounds.max.y, scene.bounds.max.z,
                      bounds.min.x, bounds.min.y, bounds.min.z,
                      bounds.max.x, bounds.max.y, bounds.max.z);
        }
        scene.bounds = bounds; // Use bounds of level 0.
      }
 
      SparseOctree::Grid& grid = octree.grids[level];
      Timer passTimer = Timer::startNew();
      levelInitCells(context, grid, octree, level);
      levelFilterEntities(context, grid, octree, level);
      LOG_DEBUG(logger, "Level %zu: Determining possibly non-empty cells: %.2fs ", level, passTimer.elapsedSeconds());
 
      SparseOctree::distributeGeometryWithIds(octree, properties, level);
      octree.scenes[level].model = ModelHandle();
      octree.scenes[level].entities.clear();
      Cogs::Core::runFrames(context, 2);
 
      //levelSimplifyCells(context, state, grid, info, properties, octree, level);
    }
  }
  exportAsset(state->context, octree);
  LOG_DEBUG(logger, "Processed hierarchy in %.3fs.", timerTotal.elapsedSeconds());
 
}