DracoMeshDecompressor.h

#pragma once
 
#include "GltfLoader.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/mesh/mesh.h"
#if defined ( _WIN32 )
#pragma warning(pop)
#elif defined ( __clang__ )
#pragma clang diagnostic pop
#endif
 
#include "Serialization/JsonParser.h"
#include "Foundation/Memory/MemoryBuffer.h"
 
namespace Cogs::Core {
 
  class DracoMeshDecompressor
  {
  public:
    DracoMeshDecompressor();
    ~DracoMeshDecompressor();
 
    void initAttributes(const GltfLoader::Object& properties);
    bool decompress(GltfLoader::GltfModelDefinition& loadData, GltfLoader::VertexStreamsState& streamsState, std::vector<GltfLoader::VertexStream>& vertexStreams,
                    const GltfLoader::Object& attributeObject, bool skipNormals);
  private:    
    void processVertexColors(draco::Mesh* dmesh, std::vector<Cogs::Core::GltfLoader::VertexStream>& vertexStreams, GltfLoader::VertexStreamsState& streamsState);
    void processTextureCoords(draco::Mesh* dmesh, std::vector<Cogs::Core::GltfLoader::VertexStream>& vertexStreams, GltfLoader::VertexStreamsState& streamsState);
    void processNormals(draco::Mesh* dmesh, std::vector<Cogs::Core::GltfLoader::VertexStream>& vertexStreams, Cogs::Core::GltfLoader::VertexStreamsState& streamsState);
    void processTangents(draco::Mesh* dmesh, std::vector<Cogs::Core::GltfLoader::VertexStream>& vertexStreams, Cogs::Core::GltfLoader::VertexStreamsState& streamsState);
 
    template<typename T>
    void getAttributeData(const draco::Mesh* dmesh, const draco::PointAttribute* attr, GltfLoader::VertexStream& targetVertexStream)
    {
      assert(attr->IsValid() && "Internal error");
 
      const uint32_t numComponents = attr->num_components();
      const uint32_t numPoints = dmesh->num_points();
      const uint32_t numValues = numPoints * numComponents;
      const uint32_t stride = static_cast<uint32_t>(attr->byte_stride());
 
      std::vector<T> vectors;
      vectors.reserve(numValues);
      std::vector<T> value(numComponents, -2);
 
      for (draco::PointIndex i(0); i < numPoints; ++i) {
        const draco::AttributeValueIndex val_index = attr->mapped_index(i);
        if (!attr->ConvertValue<T>(val_index, &value[0])) {
          assert(false && "Internal error. Could not convert Draco attribute value.");
          return;
        }
        for (uint32_t j = 0; j < numComponents; ++j) {
          vectors.emplace_back(value[j]);
        }
      }
      
      this->decompressedAttributes.push_back(Memory::MemoryBuffer(numValues * sizeof(T)));
      uint8_t* buf = reinterpret_cast<uint8_t*>(this->decompressedAttributes.back().data());
      memcpy(buf, &vectors[0], numValues * sizeof(T));
      
      targetVertexStream.dataView = GltfLoader::BufferDataView{ buf, stride, numPoints};
      targetVertexStream.formatSize = stride;
      targetVertexStream.offset = 0;      
    }
 
    int bufferViewIdx = -1;
    int attrPositionIdx = -1;    
    int attrNormalIdx = -1;
    int attrTangentIdx = -1;
    std::vector<int> attrTexCoordIndices; // TEX_0, TEX_1 etc.
    std::vector<int> attrColorIndices; // COLOR_0, COLOR_1 etc.    
    
    // These are additional buffers which has been allocated. They will be deleted by the 
    // class destructor prevent memleaks.
    Memory::MemoryBuffer decompressedIndices;
    std::vector<Memory::MemoryBuffer> decompressedAttributes;
  };
 
}