CscGlTFParser.h

Go to the documentation of this file.

#ifndef CscGlTFParser_h
#define CscGlTFParser_h
 
#include "CscCommon.h"
 
#include "Util/json.h"
 
#include <Eigen/Dense>
#include <cmath>
#include <fstream>
#include <iostream>
#include <limits>
#include <set>
#include <tuple>
#include <unordered_set>
#include <Axiomes/Csc3dTypes.h>
 
using std::numeric_limits, std::unordered_set, std::set;
using namespace conscience_core::axiomes;
using namespace conscience_utils::JSON;
 
namespace conscience_core::core_objects::exchange {}
namespace conscience_core::core_objects::exchange::gltf {
 
struct GltfParseContext {
public:
    CscJsonObjectReader &gltfJsonRoot;
    const optional<fs::path> binFilePath;
 
    map<unsigned, unsigned> nodeParents;
    
    set<unsigned> sceneRootNodeIndices;
 
    map<size_t, vector<unsigned char> *> bufferDataCache;
    map<size_t, CscJsonObjectReader *> nodesJsonByIndex;
    map<size_t, CscJsonObjectReader *> accessorsJsonByIndex;
    map<size_t, CscJsonObjectReader *> buffersJsonByIndex;
    map<size_t, CscJsonObjectReader *> bufferViewsJsonByIndex;
 
    set<size_t> sceneNodeIndices;
 
    GltfParseContext(CscJsonObjectReader *gltfJsonRootPtr, optional<fs::path> binFilePath);
    ~GltfParseContext();
private:
    CscJsonObjectReader *gltfJsonRootPtr = nullptr;
};
 
struct BoundingBox {
    Vec3 min;
    Vec3 max;
 
    BoundingBox();
 
    void update(const Vec3 &point);
    void update(double x, double y, double z);
    string toString() const;
};
 
class CscGlTFParser {
 
public:
    CscGlTFParser();
    GltfParseContext *load(const fs::path &filePath);
 
    void computeBoundingBoxAndVerticesAndPolygons(GltfParseContext &context, BoundingBox &globalBBox, bool collectVerticesAndPolygons, vector<const CscPoint3d *> *vertices, vector<const CscPolygon *> *polygons, unsigned nodeIndex, CscJsonObjectReader &node);
 
    vector<pair<unsigned, CscJsonObjectReader *>> findNodesStartingBy(GltfParseContext &context, const vector<string> &searchNamePrefixes);
 
    void sortByName(vector<pair<unsigned, CscJsonObjectReader *>> &nodes);
 
    inline CscJsonObjectReader *getNode(GltfParseContext &context, size_t nodeIndex) {
        if (context.nodesJsonByIndex.find(nodeIndex) != context.nodesJsonByIndex.end()) {
            return context.nodesJsonByIndex.at(nodeIndex);
        }
 
        auto nodeJson = context.gltfJsonRoot.getRequiredArrayItemValue<CscJsonObjectReader *>("nodes", nodeIndex);
        context.nodesJsonByIndex[nodeIndex] = nodeJson;
        return nodeJson;
    }
 
private:
    unique_ptr<CscLogger> logger = CscLogger::getForCategory("CscGlTFParser");
 
    void processMesh(GltfParseContext &context, unsigned meshIndex, CscJsonObjectReader &mesh, BoundingBox &globalBBox, bool collectVerticesAndPolygons, vector<const CscPoint3d *> *vertices, vector<const CscPolygon *> *polygons, const double transform[4][4]);
 
    void processNode(GltfParseContext &context, unsigned nodeIndex, CscJsonObjectReader &node, BoundingBox &globalBBox, bool collectVerticesAndPolygons, vector<const CscPoint3d *> *vertices, vector<const CscPolygon *> *polygons, const double parentTransform[4][4], int currentDepth, int maxDepth);
 
    void fillSceneNodeIndices(GltfParseContext &context, CscJsonObjectReader *currentNode = nullptr, unsigned nodeIndex = -1);
};
 
}
 
#endif