LCOV - code coverage report
Current view: top level - engine/model - gltfloader.h (source / functions) Coverage Total Hit
Test: Libprimis Test Coverage Lines: 85.7 % 21 18
Test Date: 2025-02-21 06:59:27 Functions: 72.7 % 11 8

            Line data    Source code
       1              : 
       2              : #ifndef GLTFLOADER_H_
       3              : #define GLTFLOADER_H_
       4              : 
       5              : class GLTFModelInfo
       6              : {
       7              :     public:
       8              :         //populates the object vectors with the data in the gltf file
       9              :         //throws std::ios_base::failure if unable to load file
      10              :         //throws std::logic_error if invalid bracketing
      11              :         //throws std::logic_error if invalid geometry data type (e.g. float vertex indices)
      12              :         GLTFModelInfo(std::string_view path, bool messages = false);
      13              :         //return list of mesh names, using one of the NodeTypes
      14              :         std::vector<std::string> getnodenames(int type) const;
      15              :         //getter functions generate vectors of arrays of the appropriate type
      16              :         //given the node name
      17              :         std::vector<std::array<float, 3>> getpositions(std::string_view name) const;
      18              :         std::vector<std::array<float, 3>> getnormals(std::string_view name) const;
      19              :         std::vector<std::array<float, 2>> gettexcoords(std::string_view name) const;
      20              :         std::vector<std::array<uint, 4>> getjoints(std::string_view name) const;
      21              :         std::vector<std::array<float, 4>> getweights(std::string_view name) const;
      22              :         std::vector<std::array<uint, 3>> getindices(std::string_view name) const;
      23              : 
      24              :         //two models are equal if their getters return the same (slow, requires loading data pointed to by file)
      25              :         bool operator==(const GLTFModelInfo &m) const;
      26              : 
      27              : 
      28              :         //Enum for selecting node types with getnodenames
      29              :         //"All" selects every node name, "Mesh", "Armature", "Bone" selects only those subsets
      30              :         enum NodeTypes
      31              :         {
      32              :             NodeType_All,
      33              :             NodeType_Mesh,
      34              :             NodeType_Armature,
      35              :             NodeType_Bone
      36              :         };
      37              :     private:
      38              : 
      39              :         struct Node
      40              :         {
      41              :             std::string name;
      42              :             std::optional<std::array<float, 3>> translation;
      43              :             std::optional<std::array<float, 4>> rotation;
      44              :             std::optional<size_t> mesh;
      45              :             std::vector<size_t> children;
      46              :         };
      47              : 
      48              :         struct Mesh
      49              :         {
      50              :             std::string name;
      51              :             //indices of accessors
      52              :             std::optional<uint> positions,
      53              :                                 normals,
      54              :                                 texcoords,
      55              :                                 joints,
      56              :                                 weights,
      57              :                                 indices;
      58              :         };
      59              : 
      60              :         struct Accessor
      61              :         {
      62              :             size_t index; //index of this accessor
      63              :             uint bufferview; //index in the binary buffer this points to
      64              :             uint componenttype; //type of individual elements
      65              :             uint count; //number of elements
      66              :             std::string type; //type of data structure (vec2/vec3/scalar/etc)
      67              :         };
      68              : 
      69              :         struct BufferView
      70              :         {
      71              :             size_t index;
      72              :             uint buffer,
      73              :                  byteoffset,
      74              :                  bytelength;
      75              :         };
      76              : 
      77              :         struct Buffer
      78              :         {
      79              :             size_t index;
      80              :             uint bytelength;
      81              :             std::string uri;
      82              :             std::vector<char> buf;
      83              :         };
      84              : 
      85              :         struct Animation
      86              :         {
      87              :             struct Channel
      88              :             {
      89              :                 size_t index;
      90              :                 size_t sampler;
      91              :                 size_t targetnode;
      92              :                 std::string targetpath;
      93              :             };
      94              :             std::vector<Channel> channels;
      95              :             struct Sampler
      96              :             {
      97              :                 size_t index;
      98              :                 size_t input;
      99              :                 std::string interpolation;
     100              :                 size_t output;
     101              :             };
     102              :             std::vector<Sampler> samplers;
     103              :             std::string name;
     104              :         };
     105              : 
     106              :         //T: the type of the output arrays in the vector
     107              :         //U: the type of the vector of input data
     108              :         //N: the number of elements in output arrays
     109              :         template<class T, class U, int N>
     110           31 :         static std::vector<std::array<T, N>> fillvector(const std::vector<U> &block)
     111              :         {
     112           31 :             std::vector<std::array<T, N>> output;
     113         1363 :             for(size_t i = 0; i < block.size(); i+=N)
     114              :             {
     115              :                 std::array<T, N> v;
     116         5392 :                 for(size_t j = 0; j < N; ++j)
     117              :                 {
     118         4060 :                     v[j] = block[i+j];
     119              :                 };
     120         1332 :                 output.push_back(v);
     121              :             }
     122           31 :             return output;
     123            0 :         }
     124              : 
     125              : 
     126              :         //index and length in bytes
     127              :         //returns a new copy of the buffer, as a vector, in the appropriate type
     128              :         template<class T>
     129           31 :         std::vector<T> gettypeblock(size_t bufindex, uint length, uint index) const
     130              :         {
     131           31 :             if(length + index > buffers[bufindex].buf.size())
     132              :             {
     133            0 :                 std::printf("indices specified out of range: %u + %u > %lu\n", length, index, buffers[bufindex].buf.size());
     134              :             }
     135           31 :             std::vector<T> outbuf;
     136         4091 :             for(uint i = index; i < index + length; i+=sizeof(T))
     137              :             {
     138              :                 //type pun the char array to T
     139         4060 :                 char *data = new char[sizeof(T)];
     140        17204 :                 for(uint j = 0; j < sizeof(T); ++j)
     141              :                 {
     142        13144 :                     data[j] = buffers[bufindex].buf[i+j];
     143              :                 }
     144         4060 :                 T *outdata = reinterpret_cast<T*>(data);
     145         4060 :                 outbuf.push_back(*outdata);
     146         4060 :                 delete[] data; //this is safe because the vector pushes back values and not pointers
     147              :             }
     148           31 :             return outbuf;
     149            0 :         }
     150              : 
     151              :         /* loadjsonfile: loads a (gltf) json file to a std::vector
     152              :          *
     153              :          * Loads a JSON file and creates a new line for each bracket level and entry.
     154              :          *
     155              :          * Parameters:
     156              :          *  - std::string name: path to the file to load
     157              :          * Returns:
     158              :          *  - std::vector<std::string> of file
     159              :          */
     160              :         std::vector<std::string> loadjsonfile(std::string_view name);
     161              :         std::vector<std::string> getblockbyname(std::string_view path, std::string_view blockname, size_t maxdepth = 0);
     162              :         static void cleanstring(std::string &s);
     163              :         size_t findnodes(std::string_view path);
     164              :         size_t findmeshes(std::string_view path);
     165              :         size_t findaccessors(std::string_view path);
     166              :         size_t findbufferviews(std::string_view path);
     167              :         size_t findbuffers(std::string_view path);
     168              :         size_t findanimations(std::string_view path);
     169              :         std::vector<std::string> getblock(const std::vector<std::string> &file, uint line);
     170              : 
     171              :         const bool messages;
     172              :         std::vector<Node> nodes;
     173              :         std::vector<Mesh> meshes;
     174              :         std::vector<Accessor> accessors;
     175              :         std::vector<BufferView> bufferviews;
     176              :         std::vector<Buffer> buffers;
     177              :         std::vector<Animation> animations;
     178              : 
     179              : };
     180              : 
     181              : #endif
        

Generated by: LCOV version 2.0-1