tuto_bvh2_gltf.cpp File Reference

bvh 2 niveaux et instances, charge un fichier gltf... More...

#include <random>
#include <algorithm>
#include <vector>
#include <cfloat>
#include "vec.h"
#include "mat.h"
#include "color.h"
#include "image.h"
#include "image_io.h"
#include "orbiter.h"
#include "gltf.h"

Go to the source code of this file.

Classes
struct	Ray
	rayon. More...
struct	Hit
	intersection avec un triangle. More...
struct	BBoxHit
	intersection avec une boite / un englobant. More...
struct	BBox
	boite englobante. More...
struct	Node
	construction de l'arbre / BVH. More...
struct	BVHT< T >
	bvh parametre par le type des primitives, cf triangle et instance... More...
struct	Triangle
	triangle pour le bvh, cf fonction bounds() et intersect(). More...
struct	Instance
	instance pour le bvh, cf fonctions bounds() et intersect(). More...
struct	Sampler
	generation de nombres aleatoires entre 0 et 1. More...

Typedefs
typedef BVHT< Triangle >	BVH
typedef BVHT< Triangle >	BLAS
typedef BVHT< Instance >	TLAS

Functions
Node	make_node (const BBox &bounds, const int left, const int right)
Node	make_leaf (const BBox &bounds, const int begin, const int end)
int	main (int argc, char **argv)

Detailed Description

bvh 2 niveaux et instances, charge un fichier gltf...

Definition in file tuto_bvh2_gltf.cpp.

Typedef Documentation

BVH

typedef BVHT<Triangle> BVH

Definition at line 306 of file tuto_bvh2_gltf.cpp.

BLAS

typedef BVHT<Triangle> BLAS

Definition at line 307 of file tuto_bvh2_gltf.cpp.

TLAS

typedef BVHT<Instance> TLAS

Definition at line 361 of file tuto_bvh2_gltf.cpp.

Function Documentation

make_node()

Node make_node	(	const BBox &	bounds,
		const int	left,
		const int	right )

Definition at line 114 of file tuto_bvh2_gltf.cpp.

{
    Node node { bounds, left, right };
    assert(node.internal());    // verifie que c'est bien un noeud...
    return node;
}

make_leaf()

Node make_leaf	(	const BBox &	bounds,
		const int	begin,
		const int	end )

Definition at line 122 of file tuto_bvh2_gltf.cpp.

{
    Node node { bounds, -begin, -end };
    assert(node.leaf());        // verifie que c'est bien une feuille...
    return node;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 378 of file tuto_bvh2_gltf.cpp.

{
    const char *mesh_filename= "data/robot.gltf";
    const char *orbiter_filename= nullptr;
    
    if(argc > 1) mesh_filename= argv[1];
    if(argc > 2) orbiter_filename= argv[2];
    
    GLTFScene scene= read_gltf_scene(mesh_filename);
    
    // construit les bvh des objets de la scene, en parallele ! cf BLAS / bvh de triangles
    std::vector<BVH *> bvhs(scene.meshes.size());
    {
        // parcourir les mesh
        printf("%d meshes\n", int(scene.meshes.size()));
        
    #pragma omp parallel for
        for(unsigned mesh_id= 0; mesh_id < scene.meshes.size(); mesh_id++)
        {
            const GLTFMesh& mesh= scene.meshes[mesh_id];
            
            // groupes de triangles du mesh
            std::vector<Triangle> triangles;
            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)
                {
                    // extraire les positions des sommets du triangle
                    vec3 a= primitives.positions[primitives.indices[i]];
                    vec3 b= primitives.positions[primitives.indices[i+1]];
                    vec3 c= primitives.positions[primitives.indices[i+2]];
                    triangles.push_back( Triangle(a, b, c, mesh_id, primitive_id, i/3) );
                    // stocke aussi l'indice du triangle
                }
            }
            
            BVH *bvh= new BVH;
            bvh->build(triangles);
            bvhs[mesh_id]= bvh;
        }
    }
    
    // instancie les objets de la scene, cf TLAS / bvh d'instances
    TLAS top_bvh;
    {
        printf("%d nodes\n", int(scene.nodes.size()));
        
        // 1 instance par noeud de la scene gltf
        std::vector<Instance> instances;
        for(unsigned node_id= 0; node_id < scene.nodes.size(); node_id++)
        {
            const GLTFNode& node= scene.nodes[node_id];
            const GLTFMesh& mesh= scene.meshes[node.mesh_index];
            
            instances.push_back( Instance( BBox(mesh.pmin, mesh.pmax), node.model, bvhs[node.mesh_index], node_id ) );
        }
        
        top_bvh.build(instances);
        printf("done. %d instances\n", int(instances.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
    int width= 1024;
    int 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);
    
    
    // calcule l'image en parallele avec openMP
#pragma omp parallel for
    for(unsigned y= 0; y < image.height(); y++)
    for(unsigned x= 0; x < image.width(); x++)
    {
        // genere le rayon pour le pixel x,y
        Point o= inv( Point(x, y, 0) ); // origine
        Point e= inv( Point(x, y, 1) ); // extremite
        Ray ray(o, Vector(o, e));
        
        // intersections !
        if(Hit hit= top_bvh.intersect(ray))
        {
            assert(hit.instance_id != -1);
            assert(hit.mesh_id != -1);
            assert(hit.primitive_id != -1);
            // retrouve le triangle dans le mesh et ses primitives
            const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
            const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
            // indices des sommets du triangle
            unsigned a= primitives.indices[3*hit.triangle_id];
            unsigned b= primitives.indices[3*hit.triangle_id+1];
            unsigned c= primitives.indices[3*hit.triangle_id+2];
            // c'est a ca que servent les indices ajoutes dans triangle, instance et hit !!
            
            /* exemple : normale interpolee du point d'intersection
                assert(primitives.normals.size());
                Vector na= primitives.normals[a];
                Vector nb= primitives.normals[b];
                Vector nc= primitives.normals[c];
                
                // normale interpolee au point d'intersection, cf coordonnees barycentriques dans le triangle
                Vector n= (1 - hit.u - hit.v) * na + hit.u * nb + hit.v * nc;
                // n est dans le repere local de l'objet... 
                
                // changement de repere vers la scene !
                const Transform& model= scene.nodes[hit.instance_id].model;   // recupere la transformation de l'instance...
                
                // todo : ecrire une fonction utilitaire !!
             */ 
             
            // retrouve la couleur de base du triangle
            Color diffuse= Yellow();
            if(primitives.material_index != -1)
            {
                const GLTFMaterial& material= scene.materials[primitives.material_index];
                
                // parametres du modele pbr / gltf : couleur / metal / rugosite
                Color base= material.color;
                diffuse= base;
            }
            
            image(x, y)= Color(diffuse, 1);
        }
    }
    printf("\n");
    
    write_image(image, "render.png");
    return 0;
}