DumpStatsCommand.cpp

#include "DumpStatsCommand.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
 
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <unordered_map>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("DumpStats");
}
 
namespace Cogs::Core
{
  struct ModelStats
  {
    size_t nodes = 0;
    size_t strings = 0;
    size_t meshes = 0;
    size_t materials = 0;
    size_t streams = 0;
    size_t streamBytes = 0;
    size_t numVerts = 0;
    size_t numIndexes = 0;
 
    std::unordered_map<Mesh *, uint32_t> usedMeshes;
    std::unordered_map<MaterialInstance *, uint32_t> usedMaterials;
  };
 
  void writeStream(ModelStats & stats, const DataStream * stream)
  {
    ++stats.streams;
 
    if (stream->format) {
      stats.streamBytes += stream->numElements * Cogs::getSize(stream->format);
    } else {
      stats.streamBytes += stream->numElements * 4; // Aproximation.
    }
  }
 
  void writeMeshStats(ModelStats & stats, Mesh * mesh)
  {
    auto it = stats.usedMeshes.find(mesh);
 
    if (it != stats.usedMeshes.end()) return;
 
    stats.usedMeshes[mesh] = 0;
 
    ++stats.meshes;
 
    if (!mesh->getName().empty()) {
      ++stats.strings;
    }
 
    for (size_t i = 0; i < Mesh::MaxStreams; ++i) {
      VertexDataType::EVertexDataType type = VertexDataType::EVertexDataType(i);
 
      if (mesh->hasStream(type)) {
        writeStream(stats, &mesh->getStream(type));
 
        if (type == VertexDataType::Positions) {
          stats.numVerts += mesh->getStream(type).numElements;
        }
      }
    }
 
    if (mesh->isIndexed()) {
      ++stats.streams;
 
      stats.streamBytes += mesh->getIndexes().size() * 4;
 
      stats.numIndexes += mesh->getIndexes().size();
    }
  }
 
  void writeStats(Context * context, ModelStats & model, uint32_t /*parent*/, ComponentModel::Entity * entity)
  {
    if (!entity) return;
 
    ++model.nodes;
 
    if (!entity->getName().empty()) {
      ++model.strings;
    }
 
    auto meshComponent = entity->getComponent<MeshComponent>();
 
    if (meshComponent && meshComponent->meshHandle) {
      auto mesh = meshComponent->meshHandle.resolve();
 
      if (mesh && mesh->streams.size()) {
        writeMeshStats(model, mesh);
      }
 
      auto renderComponent = entity->getComponent<MeshRenderComponent>();
 
      if (renderComponent && renderComponent->material) {
        auto material = renderComponent->material.resolve();
 
        auto it = model.usedMaterials.find(material);
 
        if (it == model.usedMaterials.end()) {
          ++model.materials;
 
          model.usedMaterials[material] = 0;
        }
      }
    }
 
    auto sceneComponent = entity->getComponent<SceneComponent>();
 
    for (auto & child : sceneComponent->children) {
      writeStats(context, model, (uint32_t)-1, child.get());
    }
  }
}
 
void Cogs::Core::DumpStatsCommand::apply()
{
  ModelStats stats = {};
 
  writeStats(context, stats, (uint32_t)-1, context->store->getEntityPtr(entityId));
 
  auto title = getOption(options, "title");
 
  if (!title.empty()) {
    LOG_TRACE(logger, "%s", title.data());
  } else {
    LOG_TRACE(logger, "Model Stats:");
  }
 
  LOG_TRACE(logger, "----------------------------");
  LOG_TRACE(logger, "Nodes: %zd", stats.nodes);
  LOG_TRACE(logger, "Strings: %zd", stats.strings);
  LOG_TRACE(logger, "Materials: %zd", stats.materials);
  LOG_TRACE(logger, "Meshes: %zd", stats.meshes);
  LOG_TRACE(logger, "Streams: %zd", stats.streams);
  LOG_TRACE(logger, "Stream bytes: %zd", stats.streamBytes);
  LOG_TRACE(logger, "Num vertexes: %zd", stats.numVerts);
  LOG_TRACE(logger, "Num indexes: %zd", stats.numIndexes);
}
 
void Cogs::Core::DumpStatsCommand::undo()
{
}