objloader.h

Go to the documentation of this file.

#pragma once
 
#ifndef OBJLOADER_H
#define OBJLOADER_H
 
#include <vector>
#include <string>
#include "meshinfo.h"
 
namespace Eigen {}
 
 
 
// [nanoRT]
namespace HF::nanoGeom {
    bool LoadObj(Mesh& mesh, const char* filename);
}
// end [nanoRT]
 
 
 
namespace HF::Geometry{
    enum GROUP_METHOD {
        ONLY_FILE = 0, 
        BY_GROUP = 1, 
        BY_MATERIAL = 2, 
        MATERIAL_AND_FILE = 3 
    };
 
    template <typename T>
    struct tinyobj_attr {
        std::vector<T> vertices;
    };
 
 
    template <typename T>
    struct tinyobj_shape {
        std::string name;
        std::vector<int> indices;
        std::vector<int> mat_ids;
    };
 
    struct tinyobj_material {
        std::string name;
    };
 
    template <typename T> 
    struct tinyobj_geometry{
        std::vector<tinyobj_shape<T>> shapes;
        tinyobj_attr<T> attributes;
        std::vector<tinyobj_material> materials;
    };
 
    tinyobj_geometry<double> LoadMeshesFromTinyOBJ(std::string path);
 
    template <typename T>
    HF::Geometry::MeshInfo<T> LoadTMPMeshObjects(const std::string & path) {
 
        // Load the mesh from tinyobj
        tinyobj_geometry<double> geom = LoadMeshesFromTinyOBJ(path);
 
        // Count total indexes
        int index_count = 0;
        for (const auto & shape : geom.shapes)
            index_count +=shape.indices.size();
 
 
        // Copy all indices into one big array
        int last_index = 0;
        std::vector<int> complete_indices(index_count);
        for (const auto& shape : geom.shapes) {
            std::copy(shape.indices.begin(), shape.indices.end(), complete_indices.begin() + last_index);
            last_index += shape.indices.size();
        }
 
        //std::vector<T> converted_vertices = ConvertVertices<T, double>(geom.attributes.vertices);
 
        //Convert vertices to T
        std::vector<T> out_vertices(geom.attributes.vertices.size());
        for (int i = 0; i < geom.attributes.vertices.size(); i++)
            out_vertices[i] = static_cast<T>(geom.attributes.vertices[i]);
 
        return HF::Geometry::MeshInfo<T>(out_vertices, complete_indices, 1, std::string("DoubleMesh"));
    }
 
 
 
    std::vector<MeshInfo<float>> LoadMeshObjects(
        std::string path,
        GROUP_METHOD gm = ONLY_FILE,
        bool change_coords = false,
        int scale = 1
    );
 
 
    std::vector<MeshInfo<float>> LoadMeshObjects(
        std::vector<std::string>& path,
        GROUP_METHOD gm = ONLY_FILE,
        bool change_coords = false,
        int scale = 1
    );
 
    std::vector<std::array<float, 3>> LoadRawVertices(std::string path);
    
 
    std::string GetTestOBJPath(std::string key);
}
 
#endif