MeshoptDecompressor.cpp

#include "MeshoptDecompressor.h"
#include "GltfLoader.h"
 
#include "Foundation/Logging/Logger.h"
#include "Resources/MeshManager.h"
 
#include <span>
 
using namespace Cogs::Core;
 
#define DEBUG_MESHOPT 0
 
namespace {
   Cogs::Logging::Log logger = Cogs::Logging::getLogger("GltfLoader::MeshoptDecompress");
}
 
bool
MeshoptDecompressor::registerBufferViewCompression(uint32_t bufferViewIdx, const GltfLoader::Object& properties)
{
  BufferViewDecomp bvd;
  bvd.originalBufferViewIdx = bufferViewIdx;
  
  //
  // Required properties
  //
  if (!properties.HasMember("buffer")) {
    LOG_ERROR(logger, "EXT_meshopt_compression does not contain a 'buffer' property");
    return false;
  }
  bvd.bufferIdx = properties["buffer"].GetInt();
 
  if (!properties.HasMember("byteLength")) {
    LOG_ERROR(logger, "EXT_meshopt_compression does not contain a 'byteLength' property");
    return false;
  }
  bvd.byteLength = properties["byteLength"].GetInt();
 
  if (!properties.HasMember("byteStride")) {
    LOG_ERROR(logger, "EXT_meshopt_compression does not contain a 'byteStride' property");
    return false;
  }
  bvd.byteStride = properties["byteStride"].GetInt();
 
  if (!properties.HasMember("count")) {
    LOG_ERROR(logger, "EXT_meshopt_compression does not contain a 'count' property");
    return false;
  }
  bvd.count = properties["count"].GetInt();
 
  if (!properties.HasMember("mode")) {
    LOG_ERROR(logger, "EXT_meshopt_compression does not contain a 'mode' property");
    return false;
  }
  std::string m = properties["mode"].GetString();
  if (m == "ATTRIBUTES") { bvd.mode = Mode::ATTRIBUTES; }
  else if (m == "TRIANGLES") { bvd.mode = Mode::TRIANGLES; }
  else if (m == "INDICES") { bvd.mode = Mode::INDICES; }
  else {
    LOG_ERROR(logger, "Unknown 'mode' in glTF: '%s'", m.c_str());
    return false;
  }
 
  //
  // Optional properties
  //
  if (properties.HasMember("byteOffset")) {
    bvd.byteOffset = properties["byteOffset"].GetInt();
  }
 
  if (properties.HasMember("filter")) {
    std::string f = properties["filter"].GetString();
    if (f == "OCTAHEDRAL") { bvd.filter = Filter::OCTAHEDRAL; }
    else if (f == "QUATERNION") { bvd.filter = Filter::QUATERNION; }
    else if (f == "EXPONENTIAL") { bvd.filter = Filter::EXPONENTIAL; }
    else {
      LOG_ERROR(logger, "Unknown 'filter' in glTF: '%s'", f.c_str());
      return false;
    }
  }
  
  //
  // Validate according to spec rules
  // FIXME: Validate that the parent bufferview also follows the spec.
  //
  if (bvd.mode == Mode::ATTRIBUTES && (bvd.byteStride % 4 != 0 || bvd.byteStride > 255)) {
    LOG_ERROR(logger, "When mode is ATTRIBUTES then byteStride must divisible by 4 and less than 256");
    return false;
  }
 
  if (bvd.mode == Mode::TRIANGLES && (bvd.count % 3 != 0)) {
    LOG_ERROR(logger, "When mode is TRIANGLES then count must divisible by 3");
    return false;
  }
 
  if (bvd.mode == Mode::INDICES || bvd.mode == Mode::TRIANGLES) {
    if (bvd.byteStride != 2 && bvd.byteStride != 4) {
      LOG_ERROR(logger, "When mode is INDICES or TRIANGLES then byteStride must be 2 or 4 (is %d)", bvd.byteStride);
      return false;
    }
    if (bvd.filter != Filter::NONE) {
      LOG_ERROR(logger, "When mode is INDICES or TRIANGLES then FITLER must be NONE or omitted");
      return false;
    }
  }
 
  if (bvd.filter == Filter::OCTAHEDRAL && (bvd.byteStride != 4 && bvd.byteStride != 8)) {
    LOG_ERROR(logger, "When FILTER is OCTAHEDRAL then byteStride must be 4 or 8 (is %d)", bvd.byteStride);
    return false;
  }
 
  if (bvd.filter == Filter::QUATERNION && bvd.byteStride != 8) {
    LOG_ERROR(logger, "When FILTER is QUATERNION then byteStride must be 8 (is %d)", bvd.byteStride);
    return false;
  }
 
  if (bvd.filter == Filter::EXPONENTIAL && (bvd.byteStride % 4 != 0)) {
    LOG_ERROR(logger, "When FILTER is EXPONENTIAL then byteStride must divisible by 4");
    return false;
  }
 
#if DEBUG_MESHOPT
  LOG_DEBUG(logger, "EXT_meshopt_decompressor registered for BufferView %d", bufferViewIdx);
  LOG_DEBUG(logger, " SrcBuffer=%d, len=%d, stride=%d, count=%d, offset=%d, filter=%d", 
    bvd.bufferIdx, bvd.byteLength, bvd.byteStride, bvd.count, bvd.byteOffset, bvd.filter);
#endif 
 
  assert(!this->bufferViewDecomps.contains(bufferViewIdx) && "Bufferview already registered");  
  this->bufferViewDecomps[bufferViewIdx] = bvd;
  return true;
}
 
bool
MeshoptDecompressor::isCompressed(GltfLoader::GltfModelDefinition& loadData, int accessorIdx) const
{
  uint32_t bufferViewIdx = getBufferViewIdxFromAccessorIdx(loadData, accessorIdx);
  return this->bufferViewDecomps.contains(bufferViewIdx);  
}
 
bool
MeshoptDecompressor::decompress(GltfLoader::GltfModelDefinition& loadData, uint32_t accessorIdx)
{
  uint32_t bufferViewIdx = getBufferViewIdxFromAccessorIdx(loadData, accessorIdx);
  assert(this->bufferViewDecomps.contains(bufferViewIdx) && "BufferView not registered as Meshopt compressed");
  BufferViewDecomp & bvd = this->bufferViewDecomps[bufferViewIdx];
  
  switch (bvd.mode) {    
  case Mode::ATTRIBUTES: return this->processAttributes(bvd, loadData, accessorIdx);
  case Mode::INDICES:    return this->processIndices(bvd, loadData, accessorIdx);
  case Mode::TRIANGLES:  return this->processTriangles(bvd, loadData, accessorIdx);
  default:
    LOG_ERROR(logger, "Unknown 'EXT_meshopt_compression' mode: %d", int(bvd.mode));    
    break;
  }
 
  return false;
}
 
int
MeshoptDecompressor::getBufferViewIdxFromAccessorIdx(GltfLoader::GltfModelDefinition& loadData, int accessorIdx) const
{
  const GltfLoader::GltfAccessor& accessor = loadData.accessors[accessorIdx];
  return accessor.bufferView;
}
 
void 
MeshoptDecompressor::normalizeBBoxValue(Cogs::Core::GltfLoader::GltfAccessor& accessor, int idx) const
{
  switch (accessor.componentType) {
  case GltfLoader::AccessorComponentType::UnsignedByte:
    accessor.min.s_float[idx] = accessor.min.s_float[idx] / 255.0f;
    accessor.max.s_float[idx] = accessor.max.s_float[idx] / 255.0f;
    break;
  case GltfLoader::AccessorComponentType::Byte:
    accessor.min.s_float[idx] = std::fmax(accessor.min.s_float[idx] / 127.0f, -1.0f);
    accessor.max.s_float[idx] = std::fmax(accessor.max.s_float[idx] / 127.0f, -1.0f);
    break;
  case GltfLoader::AccessorComponentType::UnsignedShort:
    accessor.min.s_float[idx] = accessor.min.s_float[idx] / 65335.0f;
    accessor.max.s_float[idx] = accessor.max.s_float[idx] / 65335.0f;
    break;
  case GltfLoader::AccessorComponentType::Short:
    accessor.min.s_float[idx] = std::fmax(accessor.min.s_float[idx] / 32767.0f, -1.0f);
    accessor.max.s_float[idx] = std::fmax(accessor.max.s_float[idx] / 32767.0f, -1.0f);
    break;
  case GltfLoader::AccessorComponentType::UnsignedInt:
    accessor.min.s_float[idx] = accessor.min.s_float[idx] / float(0xFFFFFFFF);
    accessor.max.s_float[idx] = accessor.max.s_float[idx] / float(0xFFFFFFFF);
    break;
  default:
    LOG_ERROR(logger, "Unhandled accessor type: %s", GltfLoader::accessorTypeName[int(accessor.componentType)]);
    break;
  }
}
 
void 
MeshoptDecompressor::convertScalarAccessorBBoxToFloat(GltfLoader::GltfAccessor& accessor) const
{
  if (accessor.minCount == 0 || accessor.maxCount == 0 || accessor.componentType == GltfLoader::AccessorComponentType::Float) {
    return;
  }
 
  if (accessor.componentType == GltfLoader::AccessorComponentType::UnsignedByte ||
    accessor.componentType == GltfLoader::AccessorComponentType::UnsignedShort ||
    accessor.componentType == GltfLoader::AccessorComponentType::UnsignedInt) {
    accessor.min.s_float[0] = float(accessor.min.s_uint[0]);
    accessor.max.s_float[0] = float(accessor.max.s_uint[0]);
  }
  else if (accessor.componentType == GltfLoader::AccessorComponentType::Byte ||
    accessor.componentType == GltfLoader::AccessorComponentType::Short) {
    accessor.min.s_float[0] = float(accessor.min.s_int[0]);
    accessor.max.s_float[0] = float(accessor.max.s_int[0]);
  }
  else {
    assert(false && "Unsupported component type");
  }
 
  if (accessor.normalized) {
    normalizeBBoxValue(accessor, 0);
  }
}
 
 
bool
MeshoptDecompressor::processAttributes(BufferViewDecomp& bvd, GltfLoader::GltfModelDefinition& loadData, int accessorIdx)
{
  GltfLoader::GltfAccessor& accessor = loadData.accessors[accessorIdx];
 
#if DEBUG_MESHOPT
  LOG_DEBUG(logger, " accessor(%d): bufferView=%d, byteOffset=%d, cType=%s, count=%d, normalized=%s",
    accessorIdx, accessor.bufferView, accessor.byteOffset, GltfLoader::accessorComponentTypeName[int(accessor.componentType)], accessor.count, accessor.normalized ? "TRUE" : "FALSE");
  LOG_DEBUG(logger, " Already decompressed: %s", this->decompressedBufferViews.contains(accessor.bufferView) ? "TRUE" : "FALSE");
#endif
  
  // Only decompress buffer once. Reuse result if needed.
  if (!this->decompressedBufferViews.contains(accessor.bufferView)) {    
    this->memoryBuffers.push_back(Memory::MemoryBuffer());
    Memory::MemoryBuffer* membuf = &this->memoryBuffers.back();
 
    membuf->resize(bvd.count * bvd.byteStride);
    uint8_t * targetBuffer = static_cast<uint8_t*>(membuf->data());
 
    const unsigned char* vbuf = &(loadData.buffer_data[bvd.bufferIdx].data())[bvd.byteOffset];
    int err = meshopt_decodeVertexBuffer(targetBuffer, bvd.count, bvd.byteStride, vbuf, bvd.byteLength);
    if (err != 0) {
      LOG_ERROR(logger, "The meshopt lib failed decoding the vertex buffer. Return value: %d", err);
      switch (err) {
      case -1: LOG_ERROR(logger, " -> error(-1): Illegal header data"); break;
      case -2: LOG_ERROR(logger, " -> error(-2): Index out of bounds"); break;
      case -3: LOG_ERROR(logger, " -> error(-3): Could not process all data"); break;
      default: break;
      }
      return false;
    }
 
    if (bvd.filter != Filter::NONE) {
      int filterSize = bvd.count; 
      bool ok = this->transformData(targetBuffer, filterSize, bvd.byteStride, bvd.filter);
      if (!ok) {
        LOG_ERROR(logger, "Error filtering vertices");
        return false;
      }
    }
 
    GltfLoader::BufferDataView newBDV;
    Memory::MemoryBuffer* convertedMemBuf = membuf;
    int newStride = bvd.byteStride;
 
    if (accessor.componentType != GltfLoader::AccessorComponentType::Float) {            
      GltfLoader::BufferDataView tmpBufferDataView = GltfLoader::BufferDataView{ targetBuffer, bvd.byteStride, bvd.count };
      this->memoryBuffers.push_back(Memory::MemoryBuffer());
      convertedMemBuf = &this->memoryBuffers.back();
 
      if (accessor.type == GltfLoader::AccessorType::Vec3) {
        newBDV = GltfLoader::convertVecBufferToFloats<glm::vec3>(tmpBufferDataView, accessor.componentType, convertedMemBuf, accessor.normalized);        
      }
      else if (accessor.type == GltfLoader::AccessorType::Vec2) {
        newBDV = GltfLoader::convertVecBufferToFloats<glm::vec2>(tmpBufferDataView, accessor.componentType, convertedMemBuf, accessor.normalized);                
      }
      else if (accessor.type == GltfLoader::AccessorType::Vec4) {
        newBDV = GltfLoader::convertVecBufferToFloats<glm::vec4>(tmpBufferDataView, accessor.componentType, convertedMemBuf, accessor.normalized);                        
      }      
      
      newStride = newBDV.stride;      
    }
        
    // Mark bufferview as decompressed
    this->decompressedBufferViews.insert(accessor.bufferView);
 
    // Add a new buffer to the buffer-list and update the original BufferView to point to this buffer instead of the original
    assert(convertedMemBuf->size() > 0);
    size_t newBufferIdx = loadData.buffer_data.size();
    loadData.buffer_data.push_back(std::span<const uint8_t>(static_cast<uint8_t*>(convertedMemBuf->data()), static_cast<uint8_t*>(convertedMemBuf->data()) + convertedMemBuf->size()));
    loadData.buffer_views[accessor.bufferView].buffer = uint32_t(newBufferIdx);
    loadData.buffer_views[accessor.bufferView].byteOffset = 0;
    loadData.buffer_views[accessor.bufferView].byteLength = uint32_t(convertedMemBuf->size());
    loadData.buffer_views[accessor.bufferView].byteStride = newStride;
  }
 
  // We need to convert the accessor's BBOX to floats as the component type is changed to float.
  if (accessor.type == GltfLoader::AccessorType::Vec3) {
    this->convertVecAccessorBBoxToFloat<glm::vec3>(accessor);
  }
  else if (accessor.type == GltfLoader::AccessorType::Vec2) {
    this->convertVecAccessorBBoxToFloat<glm::vec2>(accessor);
  }
  else if (accessor.type == GltfLoader::AccessorType::Vec4) {
    this->convertVecAccessorBBoxToFloat<glm::vec4>(accessor);
  }
  else if (accessor.type == GltfLoader::AccessorType::Scalar) {
    this->convertScalarAccessorBBoxToFloat(accessor);
  }
  else {
    LOG_WARNING(logger, "Unknown bbox type: %s", GltfLoader::accessorTypeName[int(accessor.type)]);
  }
 
  // Update the Accessor with a correct "byteOffset" which matches the decompressed data.
  const int newOffset = (accessor.byteOffset / bvd.byteStride) * loadData.buffer_views[accessor.bufferView].byteStride;
  loadData.accessors[accessorIdx].byteOffset = newOffset;
  loadData.accessors[accessorIdx].componentType = GltfLoader::AccessorComponentType::Float;
 
  return true;
}
 
bool
MeshoptDecompressor::processIndices(BufferViewDecomp& bvd, GltfLoader::GltfModelDefinition& loadData, int accessorIdx)
{
  GltfLoader::GltfAccessor& accessor = loadData.accessors[accessorIdx];
 
#if DEBUG_MESHOPT
  LOG_DEBUG(logger, "processIndices (bufferIdx=%d, count=%d, stride=%d, offset=%d, byteLen=%d, filter=%d)", bvd.bufferIdx, bvd.count, bvd.byteStride, bvd.byteOffset, bvd.byteLength, bvd.filter);
  LOG_DEBUG(logger, " accessor: bufferView=%d, byteOffset=%d, cType=%s, count=%d, normalized=%s",
    accessor.bufferView, accessor.byteOffset, GltfLoader::accessorComponentTypeName[int(accessor.componentType)], accessor.count, accessor.normalized ? "TRUE" : "FALSE");
  LOG_DEBUG(logger, " Already decompressed: %s", this->decompressedBufferViews.contains(accessor.bufferView) ? "TRUE" : "FALSE");
#endif
 
  // Only decompress buffer once. Reuse result if needed.
  if (!this->decompressedBufferViews.contains(accessor.bufferView)) {
 
    const unsigned char* ibuf = &(loadData.buffer_data[bvd.bufferIdx].data())[bvd.byteOffset];
 
    this->memoryBuffers.push_back(Memory::MemoryBuffer());
    Memory::MemoryBuffer* membuf = &this->memoryBuffers.back();
 
    membuf->resize(bvd.count * bvd.byteStride);
    uint8_t* targetBuffer = static_cast<uint8_t*>(membuf->data());
 
    int err = meshopt_decodeIndexSequence(reinterpret_cast<uint32_t*>(targetBuffer), bvd.count, ibuf, bvd.byteLength);
    if (err != 0) {
      LOG_ERROR(logger, "The meshopt lib failed decoding the index sequence. Return value: %d", err);
      switch (err) {
      case -1: LOG_ERROR(logger, " -> error(-1): Illegal header data"); break;
      case -2: LOG_ERROR(logger, " -> error(-2): Index out of bounds"); break;
      case -3: LOG_ERROR(logger, " -> error(-3): Could not process all the data"); break;
      default: break;
      }
      return false;
    }
 
    // Mark bufferview as decompressed
    this->decompressedBufferViews.insert(accessor.bufferView);
 
    // Add a new buffer to the buffer-list and update the original BufferView to point to this buffer instead of the original
    size_t newBufferIdx = loadData.buffer_data.size();
    loadData.buffer_data.push_back(std::span<const uint8_t>(static_cast<uint8_t*>(membuf->data()), static_cast<uint8_t*>(membuf->data()) + membuf->size()));
    loadData.buffer_views[accessor.bufferView].buffer = uint32_t(newBufferIdx);
    loadData.buffer_views[accessor.bufferView].byteOffset = 0;
    loadData.buffer_views[accessor.bufferView].byteLength = uint32_t(membuf->size());
    loadData.buffer_views[accessor.bufferView].byteStride = bvd.byteStride;
  }
  
  // Update the Accessor with a correct "byteOffset" which matches the decompressed data.
  const int newOffset = (accessor.byteOffset / bvd.byteStride) * loadData.buffer_views[accessor.bufferView].byteStride;
  loadData.accessors[accessorIdx].byteOffset = newOffset;
  
  return true;
}
 
bool
MeshoptDecompressor::processTriangles(BufferViewDecomp& bvd, GltfLoader::GltfModelDefinition& loadData, int accessorIdx)
{
   GltfLoader::GltfAccessor& accessor = loadData.accessors[accessorIdx];
 
#if DEBUG_MESHOPT
  LOG_DEBUG(logger, "processTriangles (bufferIdx=%d, count=%d, stride=%d, offset=%d, byteLen=%d, filter=%d). accessorIdx=%d", 
    bvd.bufferIdx, bvd.count, bvd.byteStride, bvd.byteOffset, bvd.byteLength, bvd.filter, accessorIdx);
  LOG_DEBUG(logger, " accessor: bufferView=%d, byteOffset=%d, cType=%s, count=%d, normalized=%s",
    accessor.bufferView, accessor.byteOffset, GltfLoader::accessorComponentTypeName[(int)accessor.componentType], accessor.count, accessor.normalized ? "TRUE" : "FALSE");
  LOG_DEBUG(logger, " Already decompressed: %s", this->decompressedBufferViews.contains(accessor.bufferView) ? "TRUE" : "FALSE");
#endif
 
  // Only decompress buffer once. Reuse result if needed.
  if (!this->decompressedBufferViews.contains(accessor.bufferView)) {
    const unsigned char* ibuf = &(loadData.buffer_data[bvd.bufferIdx].data())[bvd.byteOffset];
 
    this->memoryBuffers.push_back(Memory::MemoryBuffer());
    Memory::MemoryBuffer* membuf = &this->memoryBuffers.back();
    membuf->resize(bvd.count * bvd.byteStride);
    uint8_t * targetBuffer = static_cast<uint8_t*>(membuf->data());
 
    int err = 0;
    switch (bvd.byteStride) {
    case 2:
      err = meshopt_decodeIndexBuffer(reinterpret_cast<uint16_t*>(targetBuffer), bvd.count, ibuf, bvd.byteLength);
      break;
    case 4:
      err = meshopt_decodeIndexBuffer(reinterpret_cast<uint32_t*>(targetBuffer), bvd.count, ibuf, bvd.byteLength);
      break;
    default:
      LOG_ERROR(logger, "Illegal byte-stride for compressed indices: %d. Must be 2 or 4.", bvd.byteStride);
      return false;
    };
 
    if (err != 0) {
      LOG_ERROR(logger, "The meshopt lib failed decoding the triangles/index buffer. Error code: %d", err);
      switch (err) {
      case -1: LOG_ERROR(logger, " error(-1): Illegal header data"); break;
      case -2: LOG_ERROR(logger, " error(-2): Index out of bounds"); break;
      case -3: LOG_ERROR(logger, " error(-3): Could not process all the data"); break;
      default: break;
      }
      return false;
    }
 
    // Mark bufferview as decompressed
    this->decompressedBufferViews.insert(accessor.bufferView);
 
    // Add a new buffer to the buffer-list and update the original BufferView to point to this buffer instead of the original
    size_t newBufferIdx = loadData.buffer_data.size();
    loadData.buffer_data.push_back(std::span<const uint8_t>(static_cast<uint8_t*>(membuf->data()), static_cast<uint8_t*>(membuf->data()) + membuf->size()));
    loadData.buffer_views[accessor.bufferView].buffer = uint32_t(newBufferIdx);
    loadData.buffer_views[accessor.bufferView].byteOffset = 0;
    loadData.buffer_views[accessor.bufferView].byteLength = uint32_t(membuf->size());
    loadData.buffer_views[accessor.bufferView].byteStride = bvd.byteStride;
  }
  
  // Update the Accessor with a correct "byteOffset" which matches the decompressed data.
  const int newOffset = (accessor.byteOffset / bvd.byteStride) * loadData.buffer_views[accessor.bufferView].byteStride;
  loadData.accessors[accessorIdx].byteOffset = newOffset;
  
  return true;
}
 
#undef DEBUG_MESHOPT