AssetStatsCommand.cpp

#define _USE_MATH_DEFINES
#include <cmath>
#include <queue>
#include "rapidjson/document.h"
#include "rapidjson/filewritestream.h"
#include "rapidjson/prettywriter.h"
#include "rapidjson/error/en.h"
 
#include "AssetStatsCommand.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
 
#include "Services/TaskManager.h"
#include "Resources/AssetManager.h"
#include "Resources/ModelManager.h"
#include "Resources/MeshHelper.h"
#include "Utilities/Math.h"
#include "Components/Core/AssetComponent.h" // AssetFlags
#include "Batch.h"
 
 
 
namespace {
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("AssetStats");
 
  constexpr uint32_t NoValue = static_cast<uint32_t>(-1);
  const Cogs::Core::StringRef bboxString = Cogs::Core::Strings::add("bbox");
  const Cogs::Core::StringRef errorsString = Cogs::Core::Strings::add("errors");
 
 
  struct RunningStatistics
  {
    void add(double value)
    {
      assert(std::isfinite(value));
      count++;
 
      double delta = value - mean;
      mean += delta / count;
 
      minValue = std::min(minValue, value);
      maxValue = std::max(maxValue, value);
    }
 
    void add(RunningStatistics& other)
    {
      size_t newCount = count + other.count;
      if (newCount) {
        double w0 = double(count) / double(newCount);
        double w1 = double(other.count) / double(newCount);
 
        mean = w0 * mean + w1 * other.mean;
      }
      count = newCount;
      minValue = std::min(minValue, other.minValue);
      maxValue = std::max(maxValue, other.maxValue);
    }
 
    size_t count = 0;
    double mean = 0.f;
    double minValue = std::numeric_limits<double>::max();
    double maxValue = -std::numeric_limits<double>::max();
  };
 
  struct ProjectedStatistics
  {
    float mean = 0.f;
    float minValue = std::numeric_limits<float>::max();
    float maxValue = -std::numeric_limits<float>::max();
  };
 
  struct ErrorRange;
 
  struct ErrorRanges {
    Cogs::Mutex lock;
    std::vector<std::unique_ptr<ErrorRange>> items;
  };
 
  const char* issueId[] = {
    "None",
    "TriangleMeanMaxEdgeTooSmall",
    "NearScreenCoverOutOfRange",
    "FarScreenCoverOutOfRange",
    "NearScreenCoverAtCoarsestLodTooBig",
    "TooLittleTriangleIncrease",
  };
 
  enum struct IssueId : uint32_t
  {
    None,
    TriangleMeanMaxEdgeTooSmall,
    NearScreenCoverOutOfRange,
    FarScreenCoverOutOfRange,
    NearScreenCoverAtCoarsestLodTooBig,
    TooLittleTriangleIncrease,
    Count
  };
  static_assert(sizeof(issueId) == sizeof(issueId[0]) * size_t(IssueId::Count));
 
  struct Issue
  {
    std::string message;
    IssueId id = IssueId::None;
    uint32_t severity = 0;
  };
 
  struct ErrorRange
  {
    ErrorRange(uint32_t level, float minError, float maxError) : level(level), minError(minError), maxError(maxError) {}
 
    const uint32_t level;
    const float minError;
    const float maxError;
 
    ErrorRanges childRanges;
    std::vector<Issue> issues;
 
    struct {
      Cogs::Mutex lock;
      RunningStatistics lodNodeBounds;
      RunningStatistics modelBounds;
      RunningStatistics triangleArea;
      RunningStatistics triangleMinEdge;
      RunningStatistics triangleMaxEdge;
      uint32_t modelCount = 0;
    };
 
    struct {
      ProjectedStatistics triangleArea;
      ProjectedStatistics triangleMinEdge;
      ProjectedStatistics triangleMaxEdge;
      float distance = 0.f;                 // Distance used for projection
    } pixels;
 
    float nearSplitCover = -1.f;
    float farSplitCover = -1.f;
  };
 
  ErrorRange* getErrorRange(ErrorRanges& ranges, const uint32_t level, const float minError, const float maxError)
  {
    Cogs::LockGuard guard(ranges.lock);
    std::vector<std::unique_ptr<ErrorRange>>& items = ranges.items;
 
    const size_t n = items.size();
    for (size_t i = 0; i < n; i++) {
      if (items[i]->minError == minError && items[i]->maxError == maxError && items[i]->level == level) {
        return items[i].get();
      }
    }
 
    items.emplace_back();
    items[n] = std::make_unique<ErrorRange>(level, minError, maxError);
    return items[n].get();
  }
 
  struct ResourceItem
  {
    enum struct Kind {
      None,
      AssetItem,
      ModelItem
    } kind = ResourceItem::Kind::None;
 
    enum struct State {
      None,
      Issued,
      Loading,
      Processing,
      Done,
      Failed
    } state = State::None;
 
    TaskId task = NoTask;
    std::string path;
    ResourceHandleBase handle;
    ErrorRange* errorRange = nullptr;
    struct {
      bool useRelativePaths = true;
    } asset;
 
    struct {
      uint32_t part = ::NoValue;
    } model;
  };
 
 
  struct ProcessModelScratch
  {
    Cogs::Memory::TypedBuffer<glm::vec3> worldPos;
    Cogs::Memory::MemoryBuffer posBacking;
    Cogs::Memory::MemoryBuffer idxBacking;
    Cogs::Memory::TypedBuffer<glm::mat4> worldFromModel;
    Cogs::Memory::TypedBuffer<uint32_t> dummyIndices;
  };
 
 
  struct LevelPaths
  {
    std::unordered_set<std::string> assetPaths;
    std::unordered_set<std::string> modelPaths;
  };
 
  struct Ctx
  {
    Ctx() {}
    // Just to make sure we do not get any unintended copies while capturing lambdas etc.
    Ctx(const Ctx&) = delete;
    Ctx& operator=(const Ctx&) = delete;
 
    Context* context = nullptr;
    TaskId group = NoTask;
    Cogs::Atomic<bool> failure = false;
    MemoryPoolAllocator<CrtAllocator> alloc = MemoryPoolAllocator<CrtAllocator>();
 
    struct {
      Cogs::Mutex lock;
      std::list<std::unique_ptr<ProcessModelScratch>> processModelScratch;
    } threadTemporaries;
 
    struct {
      Cogs::Mutex lock;
      std::queue<std::unique_ptr<ResourceItem>> queue;
      size_t count = 0;
    } resourceQueue;
 
    struct {
      Cogs::Mutex lock;
      std::vector<LevelPaths> levels;
    } uniquePaths;
 
    std::string source;
    float referenceFieldOfView = float(M_PI / 4.0);
    float referenceScreenSize = 1000.f;
    struct {
      float splitPointScreenCoverMin = 1.f / 2.f;
      float splitPointScreenCoverMax = 2.f;
      float splitPointScreenCoverFurthesSplitMax = 0.2f;   // screen cover of furthest split
      float splitPointMinTriangleEdgeLength = 10.f;
      float perLevelMinTriangleIncrease = 1.5f;
    } rules;
 
    ErrorRanges rootRanges;
 
    Cogs::Reflection::TypeId assetCompTypeId = Cogs::Reflection::NoType;
    Cogs::Reflection::FieldId assetCompAssetFieldId = Cogs::Reflection::NoField;
  };
 
  float infinityNormDistance(const glm::vec3& lo, const glm::vec3& hi)
  {
    glm::vec3 d = glm::abs(hi - lo);
    return std::max(std::max(d.x, d.y), d.z);
  }
 
 
  void enqueueAsset(Ctx* ctx, ErrorRange* errorRange, const std::string& path, bool useRelativePaths)
  {
    if (ctx->failure) {
      return;
    }
 
    { // scope for resourcequeue locing, and for assetItem lifetime
      std::unique_ptr<ResourceItem> assetItem = std::make_unique<ResourceItem>(ResourceItem{
        .kind = ResourceItem::Kind::AssetItem,
        .state = ResourceItem::State::Issued,
        .path = path,
        .errorRange = errorRange,
        .asset = {
          .useRelativePaths = useRelativePaths
        }
                                                                               });
 
      Cogs::LockGuard guard(ctx->resourceQueue.lock);
      ctx->resourceQueue.queue.push(std::move(assetItem));
      ctx->resourceQueue.count++;
    }
 
    { // scope for uniquepaths locking
      Cogs::LockGuard guard(ctx->uniquePaths.lock);
      if (ctx->uniquePaths.levels.size() <= errorRange->level) {
        ctx->uniquePaths.levels.resize(errorRange->level + 1);
      }
      ctx->uniquePaths.levels[errorRange->level].assetPaths.insert(path);
    }
  }
 
  void enqueueModel(Ctx* ctx, ErrorRange* errorRange, const std::string& path, uint32_t part)
  {
    if (ctx->failure) {
      return;
    }
 
    { // scope for resourcequeue locking, and for modelItem lifetime
      std::unique_ptr<ResourceItem> modelItem = std::make_unique<ResourceItem>(ResourceItem{
        .kind = ResourceItem::Kind::ModelItem,
        .state = ResourceItem::State::Issued,
        .path = path,
        .errorRange = errorRange,
        .model = {
          .part = part
         }
                                                                               });
 
      Cogs::LockGuard guard(ctx->resourceQueue.lock);
      ctx->resourceQueue.queue.push(std::move(modelItem));
      ctx->resourceQueue.count++;
    }
 
    { // scope for uniquepaths locking
      Cogs::LockGuard guard(ctx->uniquePaths.lock);
      if (ctx->uniquePaths.levels.size() <= errorRange->level) {
        ctx->uniquePaths.levels.resize(errorRange->level + 1);
      }
      ctx->uniquePaths.levels[errorRange->level].modelPaths.insert(path);
    }
  }
 
  void processAssetEntityItem(Ctx* ctx, const std::string& parentPath, const Asset* asset, ErrorRange* errorRange, const size_t entityIx, bool useRelativePaths);
 
  void processAssetEntityLodGroup(Ctx* ctx, const std::string& parentPath, const Asset* asset, ErrorRange* errorRange, const SceneEntityDefinition& entityDef, bool useRelativePaths)
  {
    const AssetDefinition& definition = asset->definition;
    const PropertyRange propertyRange = asset->definition.scene.getProperties(entityDef);
    std::span<const float> bboxValues = propertyRange.getProperty(bboxString, std::span<const float>());
    if (bboxValues.size() != 6) {
      LOG_ERROR(logger, "Lod level item bounding box has wrong number of elements (%zu != 6)", bboxValues.size());
      ctx->failure = true;
      return;
    }
 
    float bboxSize = infinityNormDistance(glm::vec3(bboxValues[0], bboxValues[1], bboxValues[2]),
                                          glm::vec3(bboxValues[3], bboxValues[4], bboxValues[5]));
    {
      Cogs::LockGuard guard(errorRange->lock);
      errorRange->lodNodeBounds.add(bboxSize);
    }
 
    if (entityDef.lod.numLods) {
      std::span<const float> errorValues = propertyRange.getProperty(errorsString, std::span<const float>());
      if (errorValues.size() != entityDef.lod.numLods) {
        LOG_ERROR(logger, "Lod level item count (=%u) does not match number of error values (=%zu)", entityDef.lod.numLods, errorValues.size());
        ctx->failure = true;
        return;
      }
 
      uint32_t childIx = entityDef.firstChild;
      for (uint32_t k = 0; k < entityDef.lod.numLods; k++) {
        if (childIx == NoValue) {
          LOG_ERROR(logger, "Empty Lod-level encountered.");
          ctx->failure = true;
          return;
        }
 
        uint32_t level = errorRange->level + entityDef.lod.numLods - k - 1;
        float minErrorLevel = k == 0 ? errorRange->minError : glm::clamp(errorValues[k], errorRange->minError, errorRange->maxError);
        float maxErrorLevel = glm::clamp(k + 1 < entityDef.lod.numLods ? errorValues[k + 1] : errorRange->maxError, errorRange->minError, errorRange->maxError);
 
        ErrorRange* childErrorRange = getErrorRange(errorRange->childRanges, level, minErrorLevel, maxErrorLevel);
        assert(childErrorRange->minError == minErrorLevel);
        assert(childErrorRange->maxError == maxErrorLevel);
 
        while (true) {
          const SceneEntityDefinition& child = definition.scene[childIx];
          processAssetEntityItem(ctx, parentPath, asset, childErrorRange, childIx, useRelativePaths);
          childIx = child.nextSibling;
          if (child.nextLodSibling == NoValue) break;
          assert(child.nextLodSibling == childIx);
        }
      }
    }
  }
 
  bool getSourcePath(Ctx* ctx, std::string& sourcePath, const std::string& parentPath, const Asset* asset,
                     const SceneEntityDefinition& entityDef, AssetResourceType assetResourceType, bool useRelativePaths)
  {
    const AssetDefinition& definition = asset->definition;
    if (entityDef.asset.index == ::NoValue) {
      LOG_ERROR(logger, "Asset without source");
      ctx->failure = true;
      return false;
    }
    const PropertyInfo& sourceInfo = definition.scene.properties.getPropertyByIndex(entityDef.asset.index);
    switch (sourceInfo.type) {
    case PropertyType::UnsignedInteger:
      sourcePath = createAssetResourcePathFromIndex(sourceInfo.uintValue, assetResourceType);
      break;
    case PropertyType::String: {
      sourcePath = definition.scene.properties.getString(sourceInfo).to_string();
      break;
    }
    default:
      LOG_ERROR(logger, "Source property is neither uint nor string");
      ctx->failure = true;
      return false;
    }
    if (useRelativePaths && Cogs::IO::isRelative(sourcePath)) {
      sourcePath = Cogs::IO::combine(parentPath, sourcePath);
    }
    return true;
  }
 
  void processAssetEntityItem(Ctx* ctx,
                              const std::string& parentPath,
                              const Asset* asset,
                              ErrorRange* errorRange,
                              const size_t entityIx,
                              bool useRelativePaths)
  {
    const AssetDefinition& definition = asset->definition;
    const SceneEntityDefinition& entityDef = asset->definition.scene.entities[entityIx];
 
    if (asset->definition.scene.entities.size() <= entityIx) {
      LOG_ERROR(logger, "Illegal entity ix %zu", entityIx);
      ctx->failure = true;
      return;
    }
    if (entityDef.isLodGroup()) {
      processAssetEntityLodGroup(ctx, parentPath, asset, errorRange, entityDef, useRelativePaths);
    }
    else if (entityDef.isAsset()) {
      std::string sourcePath;
      if (getSourcePath(ctx, sourcePath, parentPath, asset, entityDef, AssetResourceType::Asset, useRelativePaths))
      {
        enqueueAsset(ctx, errorRange, sourcePath, entityDef.asset.flags & uint32_t(AssetFlags::RelativePaths));
      }
    }
    else if (entityDef.isModel()) {
      std::string sourcePath;
      if (getSourcePath(ctx, sourcePath, parentPath, asset, entityDef, AssetResourceType::Model, useRelativePaths))
      {
        enqueueModel(ctx, errorRange, sourcePath, entityDef.model.part);
      }
    }
    else if (!entityDef.isEmpty()) {
 
      if (entityDef.numFields) {
        for (const FieldValue& entry : std::span(definition.scene.fieldValues).subspan(entityDef.firstField, entityDef.numFields)) {
 
          if (entry.componentId == ctx->assetCompTypeId && entry.fieldId == ctx->assetCompAssetFieldId && entry.type == DefaultValueType::Asset) {
 
            std::string sourcePath = entry.value;
            if (useRelativePaths && Cogs::IO::isRelative(sourcePath)) {
              sourcePath = Cogs::IO::combine(parentPath, sourcePath);
            }
 
            if (!Cogs::IO::exists(sourcePath)) {
              LOG_ERROR(logger, "Path %s does not exist", sourcePath.c_str());
              ctx->failure = true;
              return;
            }
 
            enqueueAsset(ctx, errorRange, sourcePath, useRelativePaths);
          }
        }
      }
 
    }
  }
 
  void processModel(Ctx* /*ctx*/, ProcessModelScratch* scratch, ErrorRange* errorRange, Model* model, uint32_t part)
  {
 
    size_t begin = part != ::NoValue ? part : 0;
    size_t end = part != ::NoValue ? part + 1 : model->parts.size();
    assert(end > begin && "Invalid part range");
 
    size_t count = end - begin;
    assert(count && "Invalid part range.");
 
 
    Cogs::Memory::TypedBuffer<glm::mat4>& worldFromModel = scratch->worldFromModel;
    worldFromModel.resize(count);
 
    RunningStatistics modelBounds;
    RunningStatistics triangleArea;
    RunningStatistics triangleMinEdge;
    RunningStatistics triangleMaxEdge;
    for (size_t i = 0; i < count; i++) {
      const ModelPart& modelPart = model->parts[begin + i];
 
      const glm::mat4& L = model->getPartTransform(modelPart);
      if (modelPart.parentIndex != ::NoValue) {
        assert(begin <= modelPart.parentIndex);
        assert(modelPart.parentIndex < begin + i);
        worldFromModel[i] = worldFromModel[modelPart.parentIndex - begin] * L;
      }
      else {
        worldFromModel[i] = L;
      }
 
      if (modelPart.meshIndex != ::NoValue) {
        const MeshHandle mesh = model->meshes[modelPart.meshIndex];
 
        glm::vec3 minPos = glm::vec3(std::numeric_limits<float>::max());
        glm::vec3 maxPos = glm::vec3(-std::numeric_limits<float>::max());
 
        // Transform positions from model space to world space
        Cogs::Memory::TypedBuffer<glm::vec3>& worldPos = scratch->worldPos;
        {
          std::span<const glm::vec3> modelPos = extractSemanticStreamVec3(scratch->posBacking, mesh, Cogs::ElementSemantic::Position, 0);
          worldPos.resize(modelPos.size());
 
          const glm::mat4& M = worldFromModel[i];
          for (size_t k = 0, n = modelPos.size(); k < n; k++) {
            const glm::vec4 h = M * glm::vec4(modelPos[k], 1.f);
            worldPos[k] = (1.f / h.w) * glm::vec3(h);
          }
        }
 
        // Get indices or create dummy indices
        std::span<const uint32_t> idx;
        if (mesh->isIndexed()) {
          idx = extractIndexStreamUint32(scratch->idxBacking, mesh);
        }
        else {
          size_t np = worldPos.size();
          size_t ni = scratch->dummyIndices.size();
          if (ni < np) {
            scratch->dummyIndices.resize(np, true);
            for (size_t k = ni; k < np; k++) {
              scratch->dummyIndices[k] = uint32_t(k);
            }
          }
          idx = std::span<const uint32_t>(scratch->dummyIndices.data(), np);
        }
 
        // Traverse primitives
        size_t startIndex = std::min(size_t(modelPart.startIndex), idx.size());
        size_t vertexCount = std::min(size_t(modelPart.vertexCount), idx.size() - startIndex);
 
        switch (modelPart.primitiveType) {
        case Cogs::PrimitiveType::TriangleList:
          for (size_t k = startIndex; k + 3 <= startIndex + vertexCount; k += 3) {
            const glm::vec3& a = worldPos[idx[k + 0]];
            const glm::vec3& b = worldPos[idx[k + 1]];
            const glm::vec3& c = worldPos[idx[k + 2]];
 
            const float e_ab = glm::distance(a, b);
            const float e_bc = glm::distance(b, c);
            const float e_ca = glm::distance(c, a);
            triangleMinEdge.add(std::min(std::min(e_ab, e_bc), e_ca));
            triangleMaxEdge.add(std::max(std::max(e_ab, e_bc), e_ca));
            triangleArea.add(0.5f * glm::length(glm::cross(b - a, c - a)));
            minPos = glm::min(minPos, glm::min(a, glm::min(b, c)));
            maxPos = glm::max(maxPos, glm::max(a, glm::max(b, c)));
          }
          break;
        default:
          LOG_WARNING(logger, "Unsupported primitive type %u", uint32_t(modelPart.primitiveType));
          break;
        }
 
 
        if (modelPart.boundsIndex != ::NoValue) {
          const Cogs::Geometry::BoundingBox& bbox = model->bounds[modelPart.boundsIndex];
          const glm::vec3 c0 = euclidean(worldFromModel[i] * glm::vec4(bbox.min.x, bbox.min.y, bbox.min.z, 1.f));
          const glm::vec3 c1 = euclidean(worldFromModel[i] * glm::vec4(bbox.min.x, bbox.min.y, bbox.max.z, 1.f));
          const glm::vec3 c2 = euclidean(worldFromModel[i] * glm::vec4(bbox.min.x, bbox.max.y, bbox.min.z, 1.f));
          const glm::vec3 c3 = euclidean(worldFromModel[i] * glm::vec4(bbox.min.x, bbox.max.y, bbox.max.z, 1.f));
          const glm::vec3 c4 = euclidean(worldFromModel[i] * glm::vec4(bbox.max.x, bbox.min.y, bbox.min.z, 1.f));
          const glm::vec3 c5 = euclidean(worldFromModel[i] * glm::vec4(bbox.max.x, bbox.min.y, bbox.max.z, 1.f));
          const glm::vec3 c6 = euclidean(worldFromModel[i] * glm::vec4(bbox.max.x, bbox.max.y, bbox.min.z, 1.f));
          const glm::vec3 c7 = euclidean(worldFromModel[i] * glm::vec4(bbox.max.x, bbox.max.y, bbox.max.z, 1.f));
          const glm::vec3 worldMin = glm::min(glm::min(glm::min(c0, c1),
                                                       glm::min(c2, c3)),
                                              glm::min(glm::min(c4, c5),
                                                       glm::min(c6, c7)));
          const glm::vec3 worldMax = glm::max(glm::max(glm::max(c0, c1),
                                                       glm::max(c2, c3)),
                                              glm::max(glm::max(c4, c5),
                                                       glm::max(c6, c7)));
          modelBounds.add(infinityNormDistance(worldMin, worldMax));
        }
        else if (minPos.x <= maxPos.x) {
          modelBounds.add(infinityNormDistance(minPos, maxPos));
        }
      }
    }
 
    Cogs::LockGuard guard(errorRange->lock);
 
    errorRange->triangleArea.add(triangleArea);
    errorRange->triangleMinEdge.add(triangleMinEdge);
    errorRange->triangleMaxEdge.add(triangleMaxEdge);
    errorRange->modelBounds.add(modelBounds);
    errorRange->modelCount++;
  }
 
  void processResource(Ctx* ctx, ResourceItem* item)
  {
    if (item->kind == ResourceItem::Kind::AssetItem) {
      assert(item->handle->getType() == ResourceTypes::Asset);
      Asset* asset = static_cast<Asset*>(item->handle.get());
      AssetDefinition& definition = asset->definition;
      std::string sourceDirectoryPath = Cogs::IO::parentPath(item->path);
      for (size_t i = 0; i < definition.scene.entities.size(); ++i) {
        SceneEntityDefinition& entityDef = definition.scene.entities[i];
        if (entityDef.parentIndex == ::NoValue) {
          processAssetEntityItem(ctx, sourceDirectoryPath, asset, item->errorRange, i, item->asset.useRelativePaths);
        }
      }
    }
 
    else if (item->kind == ResourceItem::Kind::ModelItem) {
      std::unique_ptr<ProcessModelScratch> scratch;
      {
        Cogs::LockGuard guard(ctx->threadTemporaries.lock);
        if (!ctx->threadTemporaries.processModelScratch.empty()) {
          scratch = std::move(ctx->threadTemporaries.processModelScratch.front());
          ctx->threadTemporaries.processModelScratch.pop_front();
          assert(scratch);
        }
      }
      if (!scratch) {
        scratch = std::make_unique<ProcessModelScratch>();
      }
 
      assert(item->handle->getType() == ResourceTypes::Model);
      Model* model = static_cast<Model*>(item->handle.get());
      processModel(ctx, scratch.get(), item->errorRange, model, item->model.part);
 
      assert(scratch);
      {
        Cogs::LockGuard guard(ctx->threadTemporaries.lock);
        ctx->threadTemporaries.processModelScratch.push_front(std::move(scratch));
      }
    }
 
    else {
      assert(false && "Illegal workitem kind");
    }
 
  }
 
  void processAssetQueueUntilDone(Ctx* ctx, size_t maxActive)
  {
    LOG_DEBUG(logger, "Processing asset files...");
    ctx->group = ctx->context->taskManager->createGroup(TaskManager::ResourceQueue);
 
    size_t processedCount = 0;
 
    double lastReport = -1000.0;
    Cogs::Timer timer = Cogs::Timer::startNew();
    std::vector<std::unique_ptr<ResourceItem>> activeResourceItems, activeResourceItemsNext;
    do {
      runFrames(ctx->context, 1, true, false);
 
      activeResourceItemsNext.clear();
      for (std::unique_ptr<ResourceItem>& assetItem : activeResourceItems) {
 
        switch (assetItem->state) {
        case ResourceItem::State::None: [[fallthrough]];
        case ResourceItem::State::Issued:
          assert(false && "Invalid state");
          break;
 
        case ResourceItem::State::Loading:
          // Check if item has finished loading
 
          if (assetItem->handle->isLoaded()) {
 
            if (assetItem->kind == ResourceItem::Kind::ModelItem) {
              Model* model = static_cast<Model*>(assetItem->handle.get());
              for (const MeshHandle& mesh : model->meshes) {
                if (!mesh->isLoaded()) {
                  if (mesh->hasFailedLoad()) {
                    assetItem->state = ResourceItem::State::Failed;
                  }
                  goto not_done_loading;
                }
              }
            }
 
            // Then try to fire off task
            assetItem->state = ResourceItem::State::Processing;
            assetItem->task = ctx->context->taskManager->enqueueChild(ctx->group,
                                                                      [ctx, item_ = assetItem.get()]()
                                                                      {
                                                                        processResource(ctx, item_);
                                                                      });
            if (!assetItem->task.isValid()) {
              assetItem->state = ResourceItem::State::Failed;
            }
          }
          else if (assetItem->handle->hasFailedLoad()) {
            assetItem->state = ResourceItem::State::Failed;
          }
        not_done_loading:
          break;
 
        case ResourceItem::State::Processing:
          // Check if item task has finished
          if (!ctx->context->taskManager->isActive(assetItem->task)) {
            assetItem->state = ResourceItem::State::Done;
          }
          break;
 
        case ResourceItem::State::Done: break;       // Handled below
        case ResourceItem::State::Failed: break;     // Handled below
 
        default:
          assert(false && "Invalid enum");
          break;
        }
 
        // Keep tasks that are running and filter out finished/failed tasks
        switch (assetItem->state) {
        case ResourceItem::State::Loading: [[fallthrough]];
        case ResourceItem::State::Processing:
          // Keep item in active set
          activeResourceItemsNext.emplace_back(std::move(assetItem));
          break;
        case ResourceItem::State::Done: break;       // Release item
        case ResourceItem::State::Failed:            // Flag failure and release item
          ctx->failure = true;
          break;
        default:
          assert(false && "Invalid enum");
          break;
        }
      }
 
      // Make queued items active
      while (activeResourceItemsNext.size() < maxActive) {
        std::unique_ptr<ResourceItem> item;
        {
          Cogs::LockGuard guard(ctx->resourceQueue.lock);
          if (ctx->resourceQueue.queue.empty()) {
            assert(ctx->resourceQueue.count == 0);
            break;
          }
          item = std::move(ctx->resourceQueue.queue.front());
          ctx->resourceQueue.queue.pop();
          ctx->resourceQueue.count--;
        }
        assert(item);
        assert(item->state == ResourceItem::State::Issued);
        item->state = ResourceItem::State::Loading;
        if (item->kind == ResourceItem::Kind::AssetItem) {
          item->handle = ctx->context->assetManager->loadAsset(item->path, NoResourceId, AssetLoadFlags::ForceUnique);
        }
        else if (item->kind == ResourceItem::Kind::ModelItem) {
          item->handle = ctx->context->modelManager->loadModel(item->path, NoResourceId, ModelLoadFlags::None);
        }
 
        activeResourceItemsNext.emplace_back(std::move(item));
        processedCount++;
      }
 
      activeResourceItems.swap(activeResourceItemsNext);
 
      double elapsed = timer.elapsedSeconds();
      if (activeResourceItems.empty() || std::floor(lastReport) != std::floor(elapsed)) {
        lastReport = elapsed;
 
        size_t queueCount = 0;
        {
          Cogs::LockGuard guard(ctx->resourceQueue.lock);
          queueCount = ctx->resourceQueue.count;
        }
 
        LOG_DEBUG(logger, "%.0fs: assets: done=%zu act=%zu queue=%zu",
                  std::floor(elapsed), processedCount, activeResourceItems.size(), queueCount);
      }
    } while (!activeResourceItems.empty());
 
    Cogs::LockGuard guard(ctx->resourceQueue.lock);
    assert(ctx->resourceQueue.count == 0);
 
    ctx->context->taskManager->wait(ctx->group);
    ctx->group = NoTask;
 
    LOG_DEBUG(logger, "Finished processing %zu asset/model items in %.1f seconds", processedCount, timer.elapsedSeconds());
  }
 
 
 
  Value getStatisticsAsJson(Ctx& ctx, const RunningStatistics& stats, bool includeCount)
  {
    Value statsJson(kObjectType);
    if (includeCount) {
      statsJson.AddMember("count", static_cast<uint64_t>(stats.count), ctx.alloc);
    }
    statsJson.AddMember("mean", stats.mean, ctx.alloc);
    statsJson.AddMember("minValue", stats.minValue, ctx.alloc);
    statsJson.AddMember("maxValue", stats.maxValue, ctx.alloc);
    return statsJson;
  }
 
  Value getStatisticsAsJson(Ctx& ctx, const ProjectedStatistics& stats)
  {
    Value statsJson(kObjectType);
    statsJson.AddMember("mean", stats.mean, ctx.alloc);
    statsJson.AddMember("minValue", stats.minValue, ctx.alloc);
    statsJson.AddMember("maxValue", stats.maxValue, ctx.alloc);
    return statsJson;
  }
 
  Value getRangesAsJson(Ctx& ctx, ErrorRanges& ranges)
  {
    Value rangesJson(kArrayType);
    for (const std::unique_ptr<ErrorRange>& range : ranges.items) {
      Value rangeJson(kObjectType);
 
      rangeJson.AddMember("minDistance", range->minError, ctx.alloc);
      if (std::isfinite(range->maxError)) { rangeJson.AddMember("maxDistance", range->maxError, ctx.alloc); }
      else { rangeJson.AddMember("maxDistance", Value("inf", ctx.alloc), ctx.alloc); }
 
      if (range->lodNodeBounds.count) {
        rangeJson.AddMember("lodNodeBounds", getStatisticsAsJson(ctx, range->lodNodeBounds, true), ctx.alloc);
      }
      if (range->modelBounds.count) {
        rangeJson.AddMember("modelBounds", getStatisticsAsJson(ctx, range->modelBounds, true), ctx.alloc);
      }
      if (range->triangleArea.count) {
        rangeJson.AddMember("triangleCount", static_cast<uint64_t>(range->triangleArea.count), ctx.alloc);
        rangeJson.AddMember("triangleArea", getStatisticsAsJson(ctx, range->triangleArea, false), ctx.alloc);
        rangeJson.AddMember("triangleMinEdge", getStatisticsAsJson(ctx, range->triangleMinEdge, false), ctx.alloc);
        rangeJson.AddMember("triangleMaxEdge", getStatisticsAsJson(ctx, range->triangleMaxEdge, false), ctx.alloc);
        if (0.f < range->pixels.distance) {
          Value projJson(kObjectType);
          projJson.AddMember("screenDistance", range->pixels.distance, ctx.alloc);
          projJson.AddMember("triangleArea", getStatisticsAsJson(ctx, range->pixels.triangleArea), ctx.alloc);
          projJson.AddMember("triangleMinEdge", getStatisticsAsJson(ctx, range->pixels.triangleMinEdge), ctx.alloc);
          projJson.AddMember("triangleMaxEdge", getStatisticsAsJson(ctx, range->pixels.triangleMaxEdge), ctx.alloc);
          rangeJson.AddMember("pixels", projJson, ctx.alloc);
        }
      }
      if (!range->issues.empty()) {
          Value issuesJson(kArrayType);
          for (const Issue& issue : range->issues) {
            Value issueJson(kObjectType);
 
            issueJson.AddMember("id", Value(issueId[size_t(issue.id)], ctx.alloc), ctx.alloc);
            issueJson.AddMember("severity", issue.severity, ctx.alloc);
            issueJson.AddMember("what", Value(issue.message.c_str(), ctx.alloc), ctx.alloc);
            issuesJson.PushBack(issueJson, ctx.alloc);
          }
          rangeJson.AddMember("issues", issuesJson, ctx.alloc);
      }
      if (!range->childRanges.items.empty()) {
        rangeJson.AddMember("children", getRangesAsJson(ctx, range->childRanges), ctx.alloc);
      }
      rangesJson.PushBack(rangeJson, ctx.alloc);
    }
    return rangesJson;
  }
 
  void writeStatsAsJson(Ctx& ctx, const std::string& path)
  {
    if (ctx.failure) return;
 
    Document doc(&ctx.alloc);
    doc.SetObject();
 
    Value rules(kObjectType);
    rules.AddMember("splitPointScreenCoverMin", ctx.rules.splitPointScreenCoverMin, ctx.alloc);
    rules.AddMember("splitPointScreenCoverMax", ctx.rules.splitPointScreenCoverMax, ctx.alloc);
    rules.AddMember("splitPointScreenCoverFurthesSplitMax", ctx.rules.splitPointScreenCoverFurthesSplitMax, ctx.alloc);
    rules.AddMember("splitPointMinTriangleEdgeLength", ctx.rules.splitPointMinTriangleEdgeLength, ctx.alloc);
    rules.AddMember("perLevelMinTriangleIncrease", ctx.rules.perLevelMinTriangleIncrease, ctx.alloc);
 
    Value input(kObjectType);
    input.AddMember("source", Value(ctx.source.c_str(), ctx.alloc), ctx.alloc);
    input.AddMember("referenceFieldOfViewDegrees", glm::degrees(ctx.referenceFieldOfView), ctx.alloc);
    input.AddMember("refenceScreenPixelSize", ctx.referenceScreenSize, ctx.alloc);
    input.AddMember("rules", rules, ctx.alloc);
 
    doc.AddMember("input", input, ctx.alloc);
    doc.AddMember("ranges", getRangesAsJson(ctx, ctx.rootRanges), ctx.alloc);
 
    FILE* file = fopen(path.c_str(), "w");
    if (!file) {
      LOG_ERROR(logger, "Error opening %s for writing", path.c_str());
      ctx.failure = true;
      return;
    }
 
    char buffer[4096];
    FileWriteStream stream(file, buffer, sizeof(buffer));
    PrettyWriter<FileWriteStream> writer(stream);
    writer.SetMaxDecimalPlaces(4);
 
    bool ok = doc.Accept(writer);
    stream.Flush();
    fclose(file);
    if (!ok) {
      LOG_ERROR(logger, "Error writing json into %s", path.c_str());
      ctx.failure = true;
    }
    else {
      LOG_DEBUG(logger, "Wrote %s", path.c_str());
    }
  }
 
  void addIssue(Ctx& /*ctx*/, ErrorRange* range, IssueId id, uint32_t severity, const char* format, ...)
  {
    thread_local static char buffer[256] = {};
    va_list args;
    va_start(args, format);
    int n = vsnprintf(buffer, sizeof(buffer), format, args);
    va_end(args);
    assert(0 <= n);
    buffer[sizeof(buffer) - 1] = '\0';
    range->issues.push_back(Issue{ .message = buffer, .id = id, .severity = severity });
  }
 
  void analyzeRanges(Ctx& ctx, ErrorRanges& ranges, float screenSizeWorld, float referenceScreenSize, size_t trianglesAtParentLevel)
  {
    size_t childBoundsCount = 0;
    size_t boundsCount = 0;
    size_t trianglesAtLevel = 0;
    for (std::unique_ptr<ErrorRange>& range : ranges.items) {
      trianglesAtLevel += range->triangleArea.count;
      boundsCount += range->lodNodeBounds.count + range->modelBounds.count;
      for (std::unique_ptr<ErrorRange>& childRange : range->childRanges.items) {
        childBoundsCount += childRange->lodNodeBounds.count + childRange->modelBounds.count;
      }
    }
 
    // If we are more than two nodes (lod node + model node) at this level, we have been refined.
    bool refinedLevel = 2 < boundsCount;
 
    // If children have more than two nodes, they are refined.
    bool refinedChildLevel = 2 < childBoundsCount;
 
    for (std::unique_ptr<ErrorRange>& range : ranges.items) {
      analyzeRanges(ctx, range->childRanges, screenSizeWorld, referenceScreenSize, trianglesAtLevel);
 
 
      if (range->lodNodeBounds.count) {
        if (std::isfinite(range->maxError)) {
          range->farSplitCover = float(range->lodNodeBounds.mean) / (screenSizeWorld * range->maxError);
 
          if (refinedChildLevel) {
            if ((2.f * range->farSplitCover < ctx.rules.splitPointScreenCoverMin) || (ctx.rules.splitPointScreenCoverMax < 2.f * range->farSplitCover))
            {
              addIssue(ctx, range.get(), IssueId::FarScreenCoverOutOfRange, 0,
                       "At %.2f: 2 x farScreenCover=%.2f is outside ideal range [%.2f, %.2f]",
                       range->maxError, 2.f * range->farSplitCover, ctx.rules.splitPointScreenCoverMin, ctx.rules.splitPointScreenCoverMax);
            }
          }
        }
      }
 
      if (range->triangleArea.count) {
 
        if (double(range->triangleArea.count) < ctx.rules.perLevelMinTriangleIncrease * double(trianglesAtParentLevel)) {
          addIssue(ctx, range.get(), IssueId::TooLittleTriangleIncrease, 0,
                   "Current level has %zu triangles that is only %.1f%% of %zu triangles on parent level",
                   range->triangleArea.count, 100.0 * double(range->triangleArea.count) / double(trianglesAtParentLevel), trianglesAtParentLevel);
        }
      }
 
 
      if (range->modelBounds.count) {
        if (0.f < range->minError) {
 
          range->nearSplitCover = float(range->modelBounds.mean) / (screenSizeWorld * range->minError);
 
          if (refinedLevel) {
            if ((range->nearSplitCover < ctx.rules.splitPointScreenCoverMin) || (ctx.rules.splitPointScreenCoverMax < range->nearSplitCover))
            {
              addIssue(ctx, range.get(), IssueId::NearScreenCoverOutOfRange, 0,
                       "At %.2f: nearScreenCover=%.2f is outside ideal range[%.2f, %.2f]",
                       range->minError, range->nearSplitCover, ctx.rules.splitPointScreenCoverMin, ctx.rules.splitPointScreenCoverMax);
            }
          }
 
          if (!std::isfinite(range->maxError) && ctx.rules.splitPointScreenCoverFurthesSplitMax < range->nearSplitCover) {
            addIssue(ctx, range.get(), IssueId::NearScreenCoverAtCoarsestLodTooBig, 0, 
                     "At %.2f: splitPointScreenCover=%.2f of coarsest level is larger than %.2f",
                     range->minError, range->nearSplitCover, ctx.rules.splitPointScreenCoverFurthesSplitMax);
          }
 
        }
 
        if (0.f < range->minError) {
          range->pixels.distance = range->minError;
          double pixelProj = referenceScreenSize / (screenSizeWorld * range->pixels.distance);
          if (range->triangleArea.count) {
            range->pixels.triangleArea.mean = float(pixelProj * pixelProj * range->triangleArea.mean);
            range->pixels.triangleArea.minValue = float(pixelProj * pixelProj * range->triangleArea.minValue);
            range->pixels.triangleArea.maxValue = float(pixelProj * pixelProj * range->triangleArea.maxValue);
          }
          if (range->triangleMinEdge.count) {
            range->pixels.triangleMinEdge.mean = float(pixelProj * range->triangleMinEdge.mean);
            range->pixels.triangleMinEdge.minValue = float(pixelProj * range->triangleMinEdge.minValue);
            range->pixels.triangleMinEdge.maxValue = float(pixelProj * range->triangleMinEdge.maxValue);
          }
          if (range->triangleMaxEdge.count) {
            range->pixels.triangleMaxEdge.mean = float(pixelProj * range->triangleMaxEdge.mean);
            range->pixels.triangleMaxEdge.minValue = float(pixelProj * range->triangleMaxEdge.minValue);
            range->pixels.triangleMaxEdge.maxValue = float(pixelProj * range->triangleMaxEdge.maxValue);
 
            if (range->pixels.triangleMaxEdge.mean < ctx.rules.splitPointMinTriangleEdgeLength) {
              addIssue(ctx, range.get(), IssueId::TriangleMeanMaxEdgeTooSmall, 0, "Triangle mean max edge length=%.2f is less than %.2f pixels",
                       range->pixels.triangleMaxEdge.mean, ctx.rules.splitPointMinTriangleEdgeLength);
            }
          }
        }
      }
    }
  }
 
  void dumpRanges(ErrorRanges& ranges, uint32_t indent)
  {
    const char* indents = "                                                                                ";
 
    for (size_t i = ranges.items.size(); 0 < i; --i) {
      const std::unique_ptr<ErrorRange>& range = ranges.items[i - 1];
      float rangeSize = range->maxError - range->minError;
      LOG_DEBUG(logger, "");
      LOG_DEBUG(logger, "%.*s+- errorRange=[%f, %f), errorRangeSize=%f", 4 * indent, indents, range->minError, range->maxError, rangeSize);
      if (range->lodNodeBounds.count) {
        LOG_DEBUG(logger, "%.*s   lodNodeBounds: count=%zu world={ mean=%.1f min=%.1f max=%.1f }",
                  4 * indent, indents, range->lodNodeBounds.count,
                  range->lodNodeBounds.mean, range->lodNodeBounds.minValue, range->lodNodeBounds.maxValue);
      }
      if (range->modelBounds.count) {
        LOG_DEBUG(logger, "%.*s   modelBounds: count=%zu world={ mean=%.1f min=%.1f max=%.1f }",
                  4 * indent, indents, range->modelBounds.count,
                  range->modelBounds.mean, range->modelBounds.minValue, range->modelBounds.maxValue);
 
      }
      if (0.f < range->nearSplitCover) {
        LOG_DEBUG(logger, "%.*s   nearSplitCover=%f", 4 * indent, indents, range->nearSplitCover);
      }
      if (0.f < range->farSplitCover) {
        LOG_DEBUG(logger, "%.*s   farSplitCover=%f", 4 * indent, indents, range->farSplitCover);
      }
      if (range->triangleArea.count) {
        LOG_DEBUG(logger, "%.*s   triangleArea: count=%zu mean=%.1f min=%.1f max=%.1f",
                  4 * indent, indents, range->triangleArea.count,
                  range->triangleArea.mean, range->triangleArea.minValue, range->triangleArea.maxValue);
        if (0.f < range->pixels.distance) {
          LOG_DEBUG(logger, "%.*s   pixelTriangleArea: distance=%.1f mean=%.1f min=%.1f max=%.1f",
                    4 * indent, indents, range->pixels.distance,
                    range->pixels.triangleArea.mean, range->pixels.triangleArea.minValue, range->pixels.triangleArea.maxValue);
 
        }
      }
      if (range->triangleMinEdge.count) {
        LOG_DEBUG(logger, "%.*s   triangleMinEdge: count=%zu mean=%.1f min=%.1f max=%.1f",
                  4 * indent, indents, range->triangleMinEdge.count,
                  range->triangleMinEdge.mean, range->triangleMinEdge.minValue, range->triangleMinEdge.maxValue);
        if (0.f < range->pixels.distance) {
          LOG_DEBUG(logger, "%.*s   pixelTriangleMinEdge: distance=%.1f mean=%.1f min=%.1f max=%.1f",
                    4 * indent, indents, range->pixels.distance,
                    range->pixels.triangleMinEdge.mean, range->pixels.triangleMinEdge.minValue, range->pixels.triangleMinEdge.maxValue);
        }
      }
      if (range->triangleMaxEdge.count) {
        LOG_DEBUG(logger, "%.*s   triangleMaxEdge: count=%zu mean=%.1f min=%.1f max=%.1f",
                  4 * indent, indents, range->triangleMaxEdge.count,
                  range->triangleMaxEdge.mean, range->triangleMaxEdge.minValue, range->triangleMaxEdge.maxValue);
        if (0.f < range->pixels.distance) {
          LOG_DEBUG(logger, "%.*s   pixelsTriangleMaxEdge: distance=%.1f mean=%.1f min=%.1f max=%.1f",
                    4 * indent, indents, range->pixels.distance,
                    range->pixels.triangleMaxEdge.mean, range->pixels.triangleMaxEdge.minValue, range->pixels.triangleMaxEdge.maxValue);
        }
      }
      for (const Issue& issue : range->issues) {
        LOG_WARNING(logger, "%.*s   id=%s severity=%u %s",
                    4 * indent, indents,
                    issueId[size_t(issue.id)],  issue.severity, issue.message.c_str());
      }
      dumpRanges(range->childRanges, indent + 1);
    }
  }
 
  void writeStatsAsLogger(Ctx& ctx, const char* source)
  {
    LOG_DEBUG(logger, "source: %s", source);
    for (size_t i = 0; i < ctx.uniquePaths.levels.size(); i++) {
      LOG_DEBUG(logger, "Level %zu: %zu unique asset files, %zu unique models files", i, ctx.uniquePaths.levels[i].assetPaths.size(), ctx.uniquePaths.levels[i].modelPaths.size());
    }
    LOG_DEBUG(logger, "");
    LOG_DEBUG(logger, "Reference FOV: %f radians, screen size: %f pixels", ctx.referenceFieldOfView, ctx.referenceScreenSize);
    dumpRanges(ctx.rootRanges, 0);
  }
 
}
 
 
void Cogs::Core::AssetStatsCommand::apply()
{
  LOG_ERROR(logger, "Use in post");
}
 
void Cogs::Core::AssetStatsCommand::undo()
{
  LOG_ERROR(logger, "Use in post");
}
 
bool Cogs::Core::AssetStatsCommand::calculateStats(Context* context,
                                                   PropertyStore& properties,
                                                   const StringView& source_,
                                                   const StringView& destination_)
{
  Ctx ctx;
  ctx.context = context;
 
  ctx.source = IO::absolute(source_.to_string());
  const std::string destination = IO::absolute(destination_.to_string());
 
  ctx.referenceFieldOfView                       = properties.getProperty("referenceFieldOfView", ctx.referenceFieldOfView);
  ctx.referenceScreenSize                        = properties.getProperty("referenceScreenSize", ctx.referenceScreenSize);
  ctx.rules.splitPointScreenCoverMin             = properties.getProperty("splitPointScreenCoverMin", ctx.rules.splitPointScreenCoverMin);
  ctx.rules.splitPointScreenCoverMax             = properties.getProperty("splitPointScreenCoverMax", ctx.rules.splitPointScreenCoverMax);
  ctx.rules.splitPointScreenCoverFurthesSplitMax = properties.getProperty("splitPointScreenCoverFurthesSplitMax", ctx.rules.splitPointScreenCoverFurthesSplitMax);
  ctx.rules.splitPointMinTriangleEdgeLength      = properties.getProperty("splitPointMinTriangleEdgeLength", ctx.rules.splitPointMinTriangleEdgeLength);
  ctx.rules.perLevelMinTriangleIncrease          = properties.getProperty("perLevelMinTriangleIncrease", ctx.rules.perLevelMinTriangleIncrease);
 
  const Cogs::Reflection::Type& assetCompType = Cogs::Reflection::TypeDatabase::getType<AssetComponent>();
  ctx.assetCompTypeId = assetCompType.getTypeId();
 
  const Cogs::Reflection::Field* assetCompAssetFieldType = assetCompType.getField("asset");
  ctx.assetCompAssetFieldId = assetCompAssetFieldType ? assetCompType.getFieldId(assetCompAssetFieldType) : Cogs::Reflection::NoField;
 
  if (!IO::isFile(ctx.source)) {
    LOG_ERROR(logger, "'source' (=\"%s\") must point to the root asset file.", ctx.source.c_str());
    return false;
  }
 
  size_t maxActive = 2 * Threads::hardwareConcurrency();
 
  enqueueAsset(&ctx, getErrorRange(ctx.rootRanges, 0, 0.f, std::numeric_limits<float>::infinity()), ctx.source, true);
  processAssetQueueUntilDone(&ctx, maxActive);
 
  float screenSizeWorld = 2.f * std::tan(0.5f * ctx.referenceFieldOfView);
  analyzeRanges(ctx, ctx.rootRanges, screenSizeWorld, ctx.referenceScreenSize, 0);
 
 
  writeStatsAsLogger(ctx, ctx.source.c_str());
 
  if (Cogs::IO::isDirectory(destination)) {
    std::string outfile = IO::fileName(ctx.source);
    const char* stripEndings[] = { ".asset", ".zst" };
    for (const char* ending : stripEndings) {
      if (size_t o = outfile.find(ending); o != std::string::npos) {
        outfile = outfile.substr(0, o);
      }
    }
    writeStatsAsJson(ctx, Cogs::IO::combine(destination, outfile + "_stats.json"));
  }
  else {
    writeStatsAsJson(ctx, destination);
  }
 
  LOG_DEBUG(logger, "Done, failure=%s", ctx.failure ? "true" : "false");
  return !ctx.failure;
}
 
 
void Cogs::Core::AssetStatsCommand::applyPost()
{
  calculateStats(context,
                 properties,
                 properties.getProperty("source", StringView()),
                 properties.getProperty("destination", StringView()));
}