MeshoptDecompressor.h

#pragma once
 
#include "GltfLoader.h"
 
#include "Serialization/JsonParser.h"
 
#include <meshoptimizer/meshoptimizer.h>
 
#include <unordered_set>
 
namespace Cogs::Core {
  class MeshoptDecompressor
  {
  public:
    MeshoptDecompressor() = default;
    ~MeshoptDecompressor() = default;
 
    enum class Mode { UNKNOWN, ATTRIBUTES, TRIANGLES, INDICES };
    enum class Filter { NONE, OCTAHEDRAL, QUATERNION, EXPONENTIAL };
 
    bool registerBufferViewCompression(uint32_t bufferViewIdx, const GltfLoader::Object& properties);
    [[nodiscard]] bool isCompressed(GltfLoader::GltfModelDefinition& loadData, int accessorIdx) const;
 
    bool decompress(GltfLoader::GltfModelDefinition& loadData, uint32_t accessorIdx);
    
  private:
    struct BufferViewDecomp {      
      int bufferIdx = -1;
      uint32_t byteLength = 0;
      uint32_t byteStride = 0;
      uint32_t count = 0;
      uint32_t byteOffset = 0;
      Mode mode = Mode::UNKNOWN;
      Filter filter = Filter::NONE;
 
      uint32_t originalBufferViewIdx = 0;
    };
 
    bool processAttributes(BufferViewDecomp& bvd, GltfLoader::GltfModelDefinition& loadData, int accessorIdx);
    bool processIndices(BufferViewDecomp& bvd, GltfLoader::GltfModelDefinition& loadData, int accessorIdx);
    bool processTriangles(BufferViewDecomp& bvd, GltfLoader::GltfModelDefinition& loadData, int accessorIdx);    
    
    [[nodiscard]] int getBufferViewIdxFromAccessorIdx(GltfLoader::GltfModelDefinition& loadData, int accessorIdx) const;
    void normalizeBBoxValue(Cogs::Core::GltfLoader::GltfAccessor& accessor, int idx) const;
    void convertScalarAccessorBBoxToFloat(GltfLoader::GltfAccessor& accessor) const;
 
    template <typename T>
    void convertVecAccessorBBoxToFloat(GltfLoader::GltfAccessor& accessor) const
    {
      if (accessor.minCount == 0 || accessor.maxCount == 0 || accessor.componentType == GltfLoader::AccessorComponentType::Float) {
        return;
      }
      
      T v;
      constexpr int n = v.length();
 
      if (accessor.componentType == GltfLoader::AccessorComponentType::UnsignedByte ||
        accessor.componentType == GltfLoader::AccessorComponentType::UnsignedShort ||
        accessor.componentType == GltfLoader::AccessorComponentType::UnsignedInt) {
        for (int i = 0; i < n; ++i) {
          accessor.min.s_float[i] = float(accessor.min.s_uint[i]);
          accessor.max.s_float[i] = float(accessor.max.s_uint[i]);          
        }
      }
      else if (accessor.componentType == GltfLoader::AccessorComponentType::Byte ||
        accessor.componentType == GltfLoader::AccessorComponentType::Short) {
        for (int i = 0; i < n; ++i) {
          accessor.min.s_float[i] = float(accessor.min.s_int[i]);
          accessor.max.s_float[i] = float(accessor.max.s_int[i]);         
        }
      }
      else {
        assert(false && "Unsupported component type");
      }
 
      if (accessor.normalized) {
        for (int i = 0; i < n; ++i) {
          normalizeBBoxValue(accessor, i);
        }
      }
    }
          
    template<typename T>
    bool transformData(T data, int size, int stride, MeshoptDecompressor::Filter filter) const {
      switch (filter) {        
      case Filter::EXPONENTIAL:
        meshopt_decodeFilterExp(data, size, stride); // The API says "filter" but is it more of a transformation.
        return true;
      case Filter::OCTAHEDRAL:
        meshopt_decodeFilterOct(data, size, stride);
        return true;
      case Filter::QUATERNION:
        meshopt_decodeFilterQuat(data, size, stride);
        return true;
      case Filter::NONE:
        break;
      }
 
      return false;
    }
 
    std::unordered_map<uint32_t, BufferViewDecomp> bufferViewDecomps; // map[bufferViewIdx]=BufferViewDecomp
    std::vector<Memory::MemoryBuffer> memoryBuffers;
    std::unordered_set<uint32_t> decompressedBufferViews; 
  };
}