gltf.h

Go to the documentation of this file.

 
 
#ifndef _GLTF_MESH_H
#define _GLTF_MESH_H
 
#include <vector>
 
#include "vec.h"
#include "color.h"
#include "mesh.h"
#include "image_io.h"
 
 
Mesh read_gltf_mesh( const char *filename );
 
struct GLTFCamera
{
    float fov;
    float aspect;
    float znear;
    float zfar;
    
    Transform view;
    Transform projection;
};
 
std::vector<GLTFCamera> read_gltf_cameras( const char *filename );
 
struct GLTFLight
{
    Point position;
    Color emission;
    float intensity;
    
    // \todo transform et les autres parametres...
};
 
std::vector<GLTFLight> read_gltf_lights( const char *filename );
 
struct GLTFMaterial
{
    Color color;                    
    Color emission;                 
    float metallic;                 
    float roughness;                
    float transmission;             
    float ior;                      
    float specular;                 
    Color specular_color;           
    float thickness;                
    float attenuation_distance;     
    Color attenuation_color;        
    // \todo coating
    
    int color_texture;              
    int metallic_roughness_texture; 
    int emission_texture;           
    int occlusion_texture;          
    int normal_texture;             
    int transmission_texture;       
    int specular_texture;           
    int specular_color_texture;     
    int thickness_texture;
    
    GLTFMaterial( ) :
        color(White()), emission(), metallic(), roughness(0.8), transmission(), ior(), specular(), specular_color(), thickness(), attenuation_distance(), attenuation_color(), 
        color_texture(-1), metallic_roughness_texture(-1), emission_texture(-1), occlusion_texture(-1), normal_texture(-1),
        transmission_texture(-1), specular_texture(-1), specular_color_texture(-1), thickness_texture(-1)
    {}
};
 
std::vector<GLTFMaterial> read_gltf_materials( const char *filename );
 
std::vector<ImageData> read_gltf_images( const char *filename );
 
 
struct GLTFPrimitives
{
    int primitives_mode;    
    int primitives_index;   
    int material_index;     
    
    Point pmin, pmax;        
    
    // buffers...
    std::vector<unsigned> indices;
    std::vector<vec3> positions;
    std::vector<vec2> texcoords;
    std::vector<vec3> normals;
};
 
struct GLTFMesh
{
    std::vector<GLTFPrimitives> primitives; 
    Point pmin, pmax;        
};
 
struct GLTFInstances
{
    std::vector<Transform> transforms;      
    int mesh_index;                         
};
 
struct GLTFNode
{
    Transform model;                        
    int mesh_index;                         
};
 
 
struct GLTFScene
{
    std::vector<GLTFMesh> meshes;           
    std::vector<GLTFNode> nodes;            
    
    std::vector<GLTFMaterial> materials;    
    std::vector<GLTFLight> lights;          
    std::vector<GLTFCamera> cameras;        
    
    void bounds( Point& pmin, Point& pmax) const;   
    std::vector<GLTFInstances> instances( ) const;  
};
 
GLTFScene read_gltf_scene( const char *filename );
 
#endif