DracoMeshDecompressor.cpp

#include "DracoMeshDecompressor.h"
#include "GltfLoader.h"
 
#include "Foundation/Logging/Logger.h"
#include "Resources/MeshManager.h"
 
#if defined ( _WIN32 )
#pragma warning(push)
#pragma warning(disable:4127 4804)
#elif defined ( __clang__ )
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wignored-qualifiers"
#pragma clang diagnostic ignored "-Wdeprecated-this-capture"
#pragma clang diagnostic ignored "-Wignored-qualifiers"
#endif
#include <draco/compression/decode.h>
#include <draco/core/decoder_buffer.h>
#if defined ( _WIN32 )
#pragma warning(pop)
#elif defined ( __clang__ )
#pragma clang diagnostic pop
#endif
 
#include <string>
 
using namespace Cogs::Core;
 
namespace {
   Cogs::Logging::Log logger = Cogs::Logging::getLogger("GltfLoader::DracoMeshDecompress");
}
 
DracoMeshDecompressor::DracoMeshDecompressor() = default;
 
DracoMeshDecompressor::~DracoMeshDecompressor() = default;
 
void 
DracoMeshDecompressor::initAttributes(const GltfLoader::Object& properties)
{
  if (properties.HasMember("bufferView")) {
    this->bufferViewIdx = properties["bufferView"].GetInt();
  }
 
  if (properties.HasMember("attributes")) {
    auto attrSection = properties["attributes"].GetObject();
    this->attrPositionIdx = attrSection["POSITION"].GetInt();
 
    if (attrSection.HasMember("NORMAL")) {
      this->attrNormalIdx = attrSection["NORMAL"].GetInt();
    }
 
    if (attrSection.HasMember("TANGENT")) {
      this->attrTangentIdx = attrSection["TANGENT"].GetInt();
    }
    
    // Search for TEXCOORD_n attributes
    int n = 0;
    this->attrTexCoordIndices.resize(16);
    for (n = 0; n < 16; ++n) {
      std::string key = "TEXCOORD_" + std::to_string(n);
      if (attrSection.HasMember(key.c_str())) {        
        this->attrTexCoordIndices[n] = attrSection[key.c_str()].GetInt();        
      }
      else {
        break;
      }
    }
    this->attrTexCoordIndices.resize(n);
 
    // Search for COLOR_n attributes    
    this->attrColorIndices.resize(16);
    for (n=0; n<16; ++n) {
      std::string key = "COLOR_" + std::to_string(n);
      if (attrSection.HasMember(key.c_str())) {                
        this->attrColorIndices[n] = attrSection[key.c_str()].GetInt();        
      }
      else {
        break;
      }
    }
    this->attrColorIndices.resize(n);
 
    // Add support for JOINTS_n and WEIGHTS_n? Are those even compressed?
  }
  else {
    assert(false && "The KHR_draco_mesh_compression section does not have an 'attributes' property.");
  }
 
#if 0 // Debug helper
  LOG_DEBUG(logger, "BufferViewIdx=%d, PositionIdx=%d, NormalIdx=%d, TangentIdx=%d", 
    this->bufferViewIdx, this->attrPositionIdx, this->attrNormalIdx, this->attrTangentIdx);
  if (this->attrTexCoordIndices.size() > 0) {
    for (int i = 0; i < this->attrTexCoordIndices.size();++i) {
      printf(" TEXCOORD_%d=%d\n", i, this->attrTexCoordIndices[i]);
    }
  }
  if (this->attrColorIndices.size() > 0) {
    for (int i = 0; i < this->attrColorIndices.size(); ++i) {
      printf(" COLOR_%d=%d\n", i, this->attrColorIndices[i]);
    }
  }
#endif 
}
 
 
bool 
DracoMeshDecompressor::decompress(GltfLoader::GltfModelDefinition& loadData, GltfLoader::VertexStreamsState& streamsState, std::vector<GltfLoader::VertexStream>& vertexStreams,
                                  const GltfLoader::Object& attributeObject, bool skipNormals)
{   
  GltfLoader::GltfBufferView bufferView = loadData.buffer_views[this->bufferViewIdx];
  const char* buffer = reinterpret_cast<const char*>(&(loadData.buffer_data[bufferView.buffer].data())[bufferView.byteOffset]);
  
  const size_t bufferSize = bufferView.byteLength;
 
  draco::DecoderBuffer decoderBuffer;
  decoderBuffer.Init(buffer, bufferSize);
 
  // Decode the input data into a geometry.
  std::unique_ptr<draco::PointCloud> pointCloud;
  draco::Mesh* dmesh = nullptr;
  draco::Decoder decoder;
 
  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&decoderBuffer);
  if (!type_statusor.ok()) {
    LOG_ERROR(logger, "Draco: %s", type_statusor.status().error_msg_string().c_str());
    return false;
  }
  const draco::EncodedGeometryType geom_type = type_statusor.value();
 
  if (geom_type == draco::TRIANGULAR_MESH) {
    auto statusor = decoder.DecodeMeshFromBuffer(&decoderBuffer);
    if (!statusor.ok()) {
      LOG_ERROR(logger, "Draco: %s", statusor.status().error_msg_string().c_str());
      return false;
    }
    std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
    if (in_mesh) {
      dmesh = in_mesh.get();
      pointCloud = std::move(in_mesh);
    }
  }
  else if (geom_type == draco::POINT_CLOUD) {
    auto statusor = decoder.DecodePointCloudFromBuffer(&decoderBuffer);
    if (!statusor.ok()) {
      LOG_ERROR(logger, "Draco: %s", statusor.status().error_msg_string().c_str());
      return false;
    }
    pointCloud = std::move(statusor).value();
  }
 
  assert(dmesh && "Internal error");
 
  if (pointCloud->num_points() > 0 && dmesh->num_points() == 0) {
    // FIXME: A decompressed pointcloud is not handled yet. To be implemented.
    LOG_WARNING(logger, "Point-cloud decompression not implemented yet.");
    return false;
  }
  
        
#if 0 // Debug helper
  int numattrs = dmesh->num_attributes();
  int numPosAttr = dmesh->NumNamedAttributes(draco::GeometryAttribute::POSITION);
  printf("Num draco mesh attributes: %d\n", numPosAttr);
  for (int i = 0; i < numattrs; ++i) {
    auto attr = dmesh->attribute(i);
    int idx = attr->unique_id();
    printf(" %s: idx=%d, datasize=%d items=%d, stride=%d\n",  
      draco::GeometryAttribute::TypeToString(attr->attribute_type()).c_str(), 
      idx,
      attr->buffer()->data_size(), 
      attr->size(),
      attr->byte_stride());
  }
#endif
  
  
  // 
  // Build index buffer   
  //   NOTE: Cogs/GltfLoader will only handle index lists of type uint32_t, so we'll convert to this format.  
  //
  assert(this->decompressedIndices.size() == 0 && "decompressedIndices buffer was reused");
  this->decompressedIndices.resize(static_cast<unsigned long long>(dmesh->num_faces()) * 3 * sizeof(uint32_t));  
  uint32_t* buf = reinterpret_cast<uint32_t *>(this->decompressedIndices.data());
 
  for (size_t n=0; n<dmesh->num_faces(); ++n) {
    const draco::Mesh::Face face = dmesh->face(draco::FaceIndex((uint32_t) n));
    buf[n * 3] = face[0].value();
    buf[n * 3 + 1] = face[1].value();
    buf[n * 3 + 2] = face[2].value();
  }
  
  streamsState.indexData = GltfLoader::BufferDataView{ 
    .data = reinterpret_cast<uint8_t*>(buf),
    .stride = sizeof(uint32_t), 
    .count = dmesh->num_faces() * 3 
  };
  streamsState.indexType = GltfLoader::AccessorComponentType::UnsignedInt;
  streamsState.indexSize = sizeof(uint32_t);
 
  //
  // Move decompressed vertices to the "streamsState" object
  //   
  int32_t attrId = dmesh->GetAttributeIdByUniqueId(this->attrPositionIdx);
  const draco::PointAttribute* positionAttribute = dmesh->attribute(attrId);    
  assert(positionAttribute->IsValid() && "Internal error");
  assert(positionAttribute->data_type() == draco::DT_FLOAT32 && "Only vertices using float32 is supported for now.");
  assert(positionAttribute->num_components() == 3 && "Only 3-component float arrays are supported for vertices.");
  
  GltfLoader::VertexStream vertexStream;
  this->getAttributeData<float>(dmesh, positionAttribute, vertexStream);
  vertexStream.format = Cogs::DataFormat::R32G32B32_FLOAT;
  vertexStream.semantic = Cogs::ElementSemantic::Position;
  vertexStream.semanticIndex = 0;
  vertexStreams.push_back(vertexStream);
 
#if 0 // Debug helper
  printf("INDICES (%d, min=%d, max=%d):\n", numIndices, minIndexValue, maxIndexValue);
  for (int i = 0; i < dmesh->num_faces() * 3; ++i) {
    printf("%d, ", indices[i]);
  }
  printf("\n");
  if (vertexStream.dataView.count < maxIndexValue) {
    LOG_ERROR(logger, "Number of decompressed verices (%d) is less than highest index value (%d)", vertexStream.dataView.count, maxIndexValue);
  }
#endif
 
#if 0 // Debug helper
  printf("POSITION (%d, num items=%d): \n", vertexStream.dataView.count, vertexStream.dataView.count / vertexStream.dataView.stride);
  int numcomps = positionAttribute->num_components();
  float* buf = (float*)vertexStream.dataView.data;
  for (int i = 0; i < vertexStream.dataView.count; ++i) {
    float x = buf[i * numcomps];
    float y = buf[i * numcomps + 1];
    float z = buf[i * numcomps + 2];
    printf("<%f, %f, %f>, ", x, y, z);
  }
  printf("\n");
#endif
  
  streamsState.positionPresent = true;
  streamsState.positionCount = vertexStream.dataView.count;
  streamsState.positionData = vertexStream.dataView;
 
  // Some materials does not need normals at all (eg. 'KHR_materials_unlit' materials). We'll therefore skip
  // decompressing the normals as they won't be used anyways.
  if (!skipNormals && this->attrNormalIdx != -1) {
    processNormals(dmesh, vertexStreams, streamsState);
  }
 
  if (this->attrTangentIdx != -1) {
    processTangents(dmesh, vertexStreams, streamsState);
  }
 
  processTextureCoords(dmesh, vertexStreams, streamsState);  
  processVertexColors(dmesh, vertexStreams, streamsState);  
 
  //
  // Setup correct BBOX from accessor (or recalc from scratch)
  //
  uint32_t modelPositionAttrIdx = attributeObject["POSITION"].GetInt();
  const GltfLoader::GltfAccessor& positionAccessor = loadData.accessors[modelPositionAttrIdx];
  if (positionAccessor.minCount == 3 && positionAccessor.maxCount == 3) {
    streamsState.bbox.min = glm::make_vec3(positionAccessor.min.s_float);
    streamsState.bbox.max = glm::make_vec3(positionAccessor.max.s_float);
  }
  else {
    LOG_WARNING(logger, "%.*s: POSITION attribute has missing or malformed min and max values", StringViewFormat(loadData.path));
    streamsState.bbox.min = glm::vec3(std::numeric_limits<float>::max());
    streamsState.bbox.max = -streamsState.bbox.min;
    for (size_t i=0; i<streamsState.positionCount; i++) {
      const glm::vec3 &p = *(reinterpret_cast<const glm::vec3 *>((streamsState.positionData.data + streamsState.positionData.stride * i)));
      if (std::isfinite(p.x) && std::isfinite(p.y) && std::isfinite(p.z)) {
        streamsState.bbox.min = glm::min(streamsState.bbox.min, p);
        streamsState.bbox.max = glm::max(streamsState.bbox.max, p);        
      }       
    }
  } 
 
  return true;
}
 
void 
DracoMeshDecompressor::processVertexColors(draco::Mesh* dmesh, std::vector<GltfLoader::VertexStream>& vertexStreams, GltfLoader::VertexStreamsState& streamsState)
{
  for (size_t colorNum = 0; colorNum<this->attrColorIndices.size(); ++colorNum) {
    uint32_t cAttrId = dmesh->GetAttributeIdByUniqueId(this->attrColorIndices[colorNum]);
    const draco::PointAttribute* colorAttr = dmesh->attribute(cAttrId);
    assert(colorAttr->IsValid() && "Internal error");
    assert(colorAttr->data_type() == draco::DT_FLOAT32 && "Only texture coords using float32 is supported for now.");
 
    GltfLoader::VertexStream colorStream;
    this->getAttributeData<float>(dmesh, colorAttr, colorStream);
 
    uint32_t numComponents = colorAttr->num_components();
    assert(numComponents == 3 || numComponents == 4 && "Only Vec3 or Vec4 supported for color attributes.");
 
    colorStream.format = numComponents == 3 ? Cogs::DataFormat::R32G32B32_FLOAT : Cogs::DataFormat::R32G32B32A32_FLOAT;
    colorStream.semantic = Cogs::ElementSemantic::Color;
    colorStream.semanticIndex = (uint32_t)colorNum;
 
#if 0 // Debug helper
    printf("COLOR_%d (%d, num items=%d): \n", colorNum, colorStream.dataView.count, colorStream.dataView.count / colorStream.dataView.stride);
    float* buf = (float*)colorStream.dataView.data;
    for (int i = 0; i < colorStream.dataView.count; ++i) {
      float r = buf[i * numComponents];
      float g = buf[i * numComponents + 1];
      float b = buf[i * numComponents + 2];
      if (numComponents == 4) {
        float a = buf[i * numComponents + 3];
        printf("<%f, %f, %f, %f>, ", r, g, b, a);
      }
      else {
        printf("<%f, %f, %f>, ", r, g, b);
      }
    }
    printf("\n");
#endif
 
    vertexStreams.push_back(colorStream);
  }
 
  streamsState.colorStreamCount = static_cast<uint32_t>(this->attrColorIndices.size());
}
 
void 
DracoMeshDecompressor::processTextureCoords(draco::Mesh* dmesh, std::vector<GltfLoader::VertexStream>& vertexStreams, GltfLoader::VertexStreamsState& streamsState)
{
  for (size_t texNum = 0; texNum<this->attrTexCoordIndices.size(); ++texNum) {
    uint32_t tcAttrId = dmesh->GetAttributeIdByUniqueId(this->attrTexCoordIndices[texNum]);
    const draco::PointAttribute* texAttr = dmesh->attribute(tcAttrId);
    assert(texAttr->IsValid() && "Internal error");
    assert(texAttr->data_type() == draco::DT_FLOAT32 && "Only texture coords using float32 is supported for now.");
 
    uint32_t numComponents = texAttr->num_components();
    assert(numComponents == 2 && "Only Vec2 is supported for texcoord attributes.");
 
    GltfLoader::VertexStream texStream;
    this->getAttributeData<float>(dmesh, texAttr, texStream);
    texStream.format = Cogs::DataFormat::R32G32_FLOAT;
    texStream.semantic = Cogs::ElementSemantic::TextureCoordinate;
    texStream.semanticIndex = (uint32_t)texNum;
 
#if 0 // Debug helper
    printf("TEX_%d (%d, num items=%d): \n", texNum, texStream.dataView.count, texStream.dataView.count / texStream.dataView.stride);
    float* buf = (float*)texStream.dataView.data;
    for (int i = 0; i < texStream.dataView.count; ++i) {
      float x = buf[i * numComponents];
      float y = buf[i * numComponents + 1];
      printf("<%f, %f>, ", x, y);
    }
    printf("\n");
#endif
 
    vertexStreams.push_back(texStream);
  }
 
  // Is this the correct way to add multiple arrays/datasets of texture coordinates? The VertexStreamsState 
  // object only has ONE 'texcoordData' member.
  streamsState.texcoordStreamCount = static_cast<uint32_t>(this->attrTexCoordIndices.size());
}
 
void 
DracoMeshDecompressor::processNormals(draco::Mesh* dmesh, std::vector<GltfLoader::VertexStream>& vertexStreams, GltfLoader::VertexStreamsState& streamsState)
{
  uint32_t nAttrId = dmesh->GetAttributeIdByUniqueId(this->attrNormalIdx);
  const draco::PointAttribute* normalAttribute = dmesh->attribute(nAttrId);
  assert(normalAttribute->IsValid() && "Internal error");
  assert(normalAttribute->data_type() == draco::DT_FLOAT32 && "Only normals using float32 is supported for now.");
  assert(normalAttribute->num_components() == 3 && "Only 3-component float arrays are supported for normals.");
 
 
  GltfLoader::VertexStream normalStream;
  this->getAttributeData<float>(dmesh, normalAttribute, normalStream);
  normalStream.format = Cogs::DataFormat::R32G32B32_FLOAT;
  normalStream.semantic = Cogs::ElementSemantic::Normal;
  normalStream.semanticIndex = 0;
 
#if 0 // Debug helper  
  printf("NORMALS (%d, num items=%d): \n", normalStream.dataView.count, normalStream.dataView.count / normalStream.dataView.stride);
  int numcomps = normalAttribute->num_components();
  float* buf = (float*)normalStream.dataView.data;
  for (int i = 0; i < normalStream.dataView.count; ++i) {
    float x = buf[i * numcomps];
    float y = buf[i * numcomps + 1];
    float z = buf[i * numcomps + 2];
    printf("<%f, %f, %f>, ", x, y, z);
  }
  printf("\n");
#endif
 
  vertexStreams.push_back(normalStream);
  streamsState.normalPresent = true;
  streamsState.normalData = normalStream.dataView;
}
 
void 
DracoMeshDecompressor::processTangents(draco::Mesh* dmesh, std::vector<GltfLoader::VertexStream>& vertexStreams, GltfLoader::VertexStreamsState& streamsState)
{
  uint32_t tAttrId = dmesh->GetAttributeIdByUniqueId(this->attrTangentIdx);
  const draco::PointAttribute* tangentAttribute = dmesh->attribute(tAttrId);
  assert(tangentAttribute->IsValid() && "Internal error");
  assert(tangentAttribute->data_type() == draco::DT_FLOAT32 && "Only tangents using float32 is supported for now.");
  assert(tangentAttribute->num_components() == 4 && "Only 4-component generic float arrays are supported for tangents for now.");
 
 
  GltfLoader::VertexStream tangentStream;
  this->getAttributeData<float>(dmesh, tangentAttribute, tangentStream);
  tangentStream.format = Cogs::DataFormat::R32G32B32A32_FLOAT;
  tangentStream.semantic = Cogs::ElementSemantic::Tangent;
  tangentStream.semanticIndex = 0;
 
#if 0 // Debug helper
  printf("TANGENTS (%d, num items=%d): \n", tangentStream.dataView.count, tangentStream.dataView.count / tangentStream.dataView.stride);
  int numcomps = tangentAttribute->num_components();
  float* buf = (float*)tangentStream.dataView.data;
  for (int i = 0; i < tangentStream.dataView.count; ++i) {
    float x = buf[i * numcomps];
    float y = buf[i * numcomps + 1];
    float z = buf[i * numcomps + 2];
    if (accessor.type == GltfLoader::AccessorType::Vec4) {
      float a = buf[i * numcomps + 3];
      printf("<%f, %f, %f, %f>, ", x, y, z, a);
    }
    else {
      printf("<%f, %f, %f>, ", x, y, z);
    }
  }
  printf("\n");
#endif
 
  vertexStreams.push_back(tangentStream);
  streamsState.tangentPresent = true;
}