tuto_ray_gltf.cpp File Reference

#include <vector>
#include <cfloat>
#include <chrono>
#include "gltf.h"

Go to the source code of this file.

Classes
struct	Ray
	rayon. More...
struct	Hit
	intersection avec un triangle. More...
struct	Triangle
	triangle pour le bvh, cf fonction bounds() et intersect(). More...

Functions
int	main (const int argc, const char **argv)

Function Documentation

main()

int main	(	const int	argc,
		const char **	argv )

Definition at line 88 of file tuto_ray_gltf.cpp.

{
    const char *filename= "data/cornell.glb";
    if(argc > 1)
        filename= argv[1];
    
    // charge la scene
    GLTFScene scene= read_gltf_scene(filename);
    
    // recupere les triangles
    std::vector<Triangle> triangles;
    for(unsigned node_id= 0; node_id < scene.nodes.size(); node_id++)
    {
        const GLTFNode& node= scene.nodes[node_id];
        
        const Transform& model= node.model;
        int mesh_id= node.mesh_index;
        
        const GLTFMesh& mesh= scene.meshes[mesh_id];
        for(unsigned primitive_id= 0; primitive_id < mesh.primitives.size(); primitive_id++)
        {
            const GLTFPrimitives& primitives= mesh.primitives[primitive_id];
            for(unsigned i= 0; i +2 < primitives.indices.size(); i+= 3)
            {
                // indice des sommets
                int a= primitives.indices[i];
                int b= primitives.indices[i+1];
                int c= primitives.indices[i+2];
                
                // position des sommets
                Point pa= primitives.positions[a];
                Point pb= primitives.positions[b];
                Point pc= primitives.positions[c];
                
                // transforme les sommets dans le repere de la scene
                pa= model( pa );
                pb= model( pb );
                pc= model( pc );
                
                triangles.push_back( Triangle(pa, pb, pc, mesh_id, primitive_id, i/3) );
            }
        }
    }
    assert(triangles.size());
    
    // recupere les matrices de la camera gltf
    assert(scene.cameras.size());
    Transform view= scene.cameras[0].view;
    Transform projection= scene.cameras[0].projection;
    
    // cree l'image en respectant les proportions largeur/hauteur de la camera gltf
    unsigned width= 1024;
    unsigned height= width / scene.cameras[0].aspect;
    Image image(width, height);
    
    // transformations
    Transform model= Identity();
    Transform viewport= Viewport(image.width(), image.height());
    Transform inv= Inverse(viewport * projection * view * model);
    
    // c'est parti, parcours tous les pixels de l'image
    for(unsigned y= 0; y < image.height(); y++)
    for(unsigned x= 0; x < image.width(); x++)
    {
        // generer le rayon
        Point origine= inv(Point(x, y, 0));
        Point extremite= inv(Point(x, y, 1));
        Ray ray(origine, extremite);
        
        // calculer les intersections avec tous les triangles
        Hit hit;
        for(unsigned i= 0; i < triangles.size(); i++)
        {
            if(Hit h= triangles[i].intersect(ray, hit.t))
                // ne conserve que l'intersection la plus proche de l'origine du rayon
                // attention !! h.t <= hit.t !! sinon ca ne marche pas...
                hit= h;
        }
        
        if(hit)
            // coordonnees barycentriques de l'intersection
            image(x, y)= Color(1 - hit.u - hit.v, hit.u, hit.v);
    }
    
    write_image(image, "render.png");
    return 0;
}