tuto_bvh2_gltf_brdf.cpp File Reference

bvh 2 niveaux et instances, charge un fichier gltf... + utilitaires... 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	Brdf
	regroupe tous les parametres de la matiere du point d'intersection. 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)
	creation d'un noeud interne.
Node	make_leaf (const BBox &bounds, const int begin, const int end)
	creation d'une feuille.
Point	hit_position (const Hit &hit, const Ray &ray)
	renvoie la position du point d'intersection sur le rayon.
bool	has_normals (const Hit &hit, const GLTFScene &scene)
	verifie la presence des normales par sommet.
Vector	hit_normal (const Hit &hit, const GLTFScene &scene)
	renvoie la normale interpolee au point d'intersection dans le repere de la scene.
Vector	triangle_normal (const Hit &hit, const GLTFScene &scene)
	normale geometrique du triangle, si necessaire... ie si has_normals(hit, scene) == false...
bool	has_texcoords (const Hit &hit, const GLTFScene &scene)
	verifie la presence des coordonnees de texture...
vec2	hit_texcoords (const Hit &hit, const GLTFScene &scene)
	renvoie les coordonnees de texture du point d'intersection, suppose que has_texcoords(hit, scene) == true
Color	sample_texture (const vec2 &t, const ImageData &texture)
const GLTFMaterial &	hit_material (const Hit &hit, const GLTFScene &scene)
	renvoie la matiere du point d'intersection.
Color	hit_color (const Hit &hit, const GLTFScene &scene)
	renvoie la couleur de base de la matiere du point d'intersection.
Brdf	hit_brdf (const Hit &hit, const GLTFScene &scene, const std::vector< ImageData > &textures)
	evalue les parametres pbr (couleur, metal, rugosite) de la matiere au point d'intersection, en fonction des textures aussi, si necessaire
int	main (int argc, char **argv)

Detailed Description

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

Definition in file tuto_bvh2_gltf_brdf.cpp.

---

Class Documentation

Brdf

struct Brdf

regroupe tous les parametres de la matiere du point d'intersection.

Definition at line 534 of file tuto_bvh2_gltf_brdf.cpp.

Class Members
Vector	n	normale interpolee du point d'intersection
Color	diffuse	color.
Color	F0	fresnel.
Color	emission	emission pour les sources de lumieres ou pas (= noir).
float	metallic	metallic / dielectrique.
float	alpha	rugosite de la micro surface.
float	transmission	transmission, transparent ou pas (= 0)

Typedef Documentation

BVH

typedef BVHT<Triangle> BVH

Definition at line 306 of file tuto_bvh2_gltf_brdf.cpp.

BLAS

typedef BVHT<Triangle> BLAS

Definition at line 307 of file tuto_bvh2_gltf_brdf.cpp.

TLAS

typedef BVHT<Instance> TLAS

Definition at line 361 of file tuto_bvh2_gltf_brdf.cpp.

Function Documentation

make_node()

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

creation d'un noeud interne.

Definition at line 114 of file tuto_bvh2_gltf_brdf.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 )

creation d'une feuille.

Definition at line 122 of file tuto_bvh2_gltf_brdf.cpp.

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

hit_position()

Point hit_position	(	const Hit &	hit,
		const Ray &	ray )

renvoie la position du point d'intersection sur le rayon.

Definition at line 365 of file tuto_bvh2_gltf_brdf.cpp.

{ assert(hit.triangle_id != -1); return ray.o + hit.t * ray.d; }

has_normals()

bool has_normals	(	const Hit &	hit,
		const GLTFScene &	scene )

verifie la presence des normales par sommet.

Definition at line 368 of file tuto_bvh2_gltf_brdf.cpp.

{
    assert(hit.mesh_id != -1);
    assert(hit.primitive_id != -1);
    const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
    const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
    return primitives.normals.size() > 0;
}

hit_normal()

Vector hit_normal	(	const Hit &	hit,
		const GLTFScene &	scene )

renvoie la normale interpolee au point d'intersection dans le repere de la scene.

Definition at line 378 of file tuto_bvh2_gltf_brdf.cpp.

{
    assert(hit.instance_id != -1);
    assert(hit.mesh_id != -1);
    assert(hit.primitive_id != -1);
    assert(hit.triangle_id != -1);
    const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
    const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
    
    // indice des sommets
    int a= primitives.indices[3*hit.triangle_id];
    int b= primitives.indices[3*hit.triangle_id+1];
    int c= primitives.indices[3*hit.triangle_id+2];
 
    // normales des sommets
    assert(primitives.normals.size());
    Vector na= primitives.normals[a];
    Vector nb= primitives.normals[b];
    Vector nc= primitives.normals[c];
    
    // interpole la normale au point d'intersection
    // attention : il faut utiliser la meme convetion barycentrique que la fonction d'intersection rayon/triangle !!
    Vector n= (1 - hit.u - hit.v) * na + hit.u * nb + hit.v * nc;
    
    // transforme la normale dans le repere de la scene
    const GLTFNode& node= scene.nodes[hit.instance_id];
    // les normales ne se transforment pas exactement comme les positions... 
    // les sommets sont transformes par node.model, comment transformer la normale pour quelle reste perpendiculaire au triangle ? cf Transform::normal()
    Transform T= node.model.normal();   
 
    n= normalize( T(n) );
    return n;
}

triangle_normal()

Vector triangle_normal	(	const Hit &	hit,
		const GLTFScene &	scene )

normale geometrique du triangle, si necessaire... ie si has_normals(hit, scene) == false...

Definition at line 413 of file tuto_bvh2_gltf_brdf.cpp.

{
    assert(hit.instance_id != -1);
    assert(hit.mesh_id != -1);
    assert(hit.primitive_id != -1);
    assert(hit.triangle_id != -1);
    const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
    const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
    
    // indice des sommets
    int a= primitives.indices[3*hit.triangle_id];
    int b= primitives.indices[3*hit.triangle_id+1];
    int c= primitives.indices[3*hit.triangle_id+2];
 
    // postion des sommets
    assert(primitives.positions.size());
    Point pa= primitives.positions[a];
    Point pb= primitives.positions[b];
    Point pc= primitives.positions[c];
    
    // normale geometrique
    Vector n= cross( Vector(pa, pb), Vector(pa, pc) );
    
    // transforme la normale dans le repere de la scene
    const GLTFNode& node= scene.nodes[hit.instance_id];
    // les normales ne se transforment pas exactement comme les positions... 
    // les sommets sont transformes par node.model, comment transformer la normale pour quelle reste perpendiculaire au triangle ? cf Transform::normal()
    Transform T= node.model.normal();   
 
    n= normalize( T(n) );
    return n;
}

has_texcoords()

bool has_texcoords	(	const Hit &	hit,
		const GLTFScene &	scene )

verifie la presence des coordonnees de texture...

Definition at line 447 of file tuto_bvh2_gltf_brdf.cpp.

{
    assert(hit.mesh_id != -1);
    assert(hit.primitive_id != -1);
    const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
    const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
    return primitives.texcoords.size() > 0;
}

hit_texcoords()

vec2 hit_texcoords	(	const Hit &	hit,
		const GLTFScene &	scene )

renvoie les coordonnees de texture du point d'intersection, suppose que has_texcoords(hit, scene) == true

Definition at line 457 of file tuto_bvh2_gltf_brdf.cpp.

{
    assert(hit.instance_id != -1);
    assert(hit.mesh_id != -1);
    assert(hit.primitive_id != -1);
    assert(hit.triangle_id != -1);
    const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
    const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
    
    // indice des sommets
    int a= primitives.indices[3*hit.triangle_id];
    int b= primitives.indices[3*hit.triangle_id+1];
    int c= primitives.indices[3*hit.triangle_id+2];
    
    // texcoords des sommets
    assert(primitives.texcoords.size());
    vec2 ta= primitives.texcoords[a];
    vec2 tb= primitives.texcoords[b];
    vec2 tc= primitives.texcoords[c];
    
    // interpole au point d'intersection
    // attention : il faut utiliser la meme convention barycentrique que la fonction d'intersection rayon/triangle !!
    vec2 t= vec2( (1 - hit.u - hit.v) * ta.x + hit.u * tb.x + hit.v * tc.x, (1 - hit.u - hit.v) * ta.y + hit.u * tb.y + hit.v * tc.y );
    return t;
}

sample_texture()

Color sample_texture	(	const vec2 &	t,
		const ImageData &	texture )

renvoie la couleur d'un pixel d'une texture/image chargee par read_gltf_images() todo : interpolation bilineaire des texels autour de t...

Definition at line 486 of file tuto_bvh2_gltf_brdf.cpp.

{
    // retrouve les coordonnes de t dans l'image
    int tx= int(t.x * texture.width) % texture.width;
    int ty= int(t.y * texture.height) % texture.height;
    // attention aux repetitions, les coordoornees ne sont pas toujours entre 0 et 1 !!
    if(tx < 0) tx= -tx;
    if(ty < 0) ty= -ty;
    
    // respecte la convention gltf, origine en haut de l'image...
    ty= texture.height - 1 - ty;    
    // position du pixel dans l'image
    size_t offset= texture.offset(tx, ty);
    
    // recupere la couleur du pixel
    Color color= Color(texture.pixels[offset], texture.pixels[offset+1], texture.pixels[offset+2], 255) / 255; 
    if(texture.channels > 3)
        // alpha / transparence, si disponible
        color.a= float(texture.pixels[offset+3]) / float(255);
    
    return color;
}

hit_material()

const GLTFMaterial & hit_material	(	const Hit &	hit,
		const GLTFScene &	scene )

renvoie la matiere du point d'intersection.

Definition at line 513 of file tuto_bvh2_gltf_brdf.cpp.

{
    assert(hit.mesh_id != -1);
    assert(hit.primitive_id != -1);
    const GLTFMesh& mesh= scene.meshes[hit.mesh_id];
    const GLTFPrimitives& primitives= mesh.primitives[hit.primitive_id];
    if(primitives.material_index == -1)
        return default_material;
    
    assert(primitives.material_index < int(scene.materials.size()));
    return scene.materials[primitives.material_index];
}

hit_color()

Color hit_color	(	const Hit &	hit,
		const GLTFScene &	scene )

renvoie la couleur de base de la matiere du point d'intersection.

Definition at line 527 of file tuto_bvh2_gltf_brdf.cpp.

{
    return hit_material(hit, scene).color;
}

hit_brdf()

Brdf hit_brdf	(	const Hit &	hit,
		const GLTFScene &	scene,
		const std::vector< ImageData > &	textures )

evalue les parametres pbr (couleur, metal, rugosite) de la matiere au point d'intersection, en fonction des textures aussi, si necessaire

Definition at line 548 of file tuto_bvh2_gltf_brdf.cpp.

{
    // recupere la description de la matiere...
    const GLTFMaterial& material= hit_material(hit, scene);
    
    // et les coordonnees de textures, si elles existent...
    vec2 texcoords= vec2(.5, .5);
    bool use_texture= has_texcoords(hit, scene) && textures.size();
    if(use_texture)
        texcoords= hit_texcoords(hit, scene);
    
    Color color= material.color;
    if(use_texture && material.color_texture != -1 && material.color_texture < int(textures.size()))
        color= color * sample_texture(texcoords, textures[material.color_texture]);
    
    float metallic= material.metallic;
    float roughness= material.roughness;
    if(use_texture && material.metallic_roughness_texture != -1 && material.metallic_roughness_texture < int(textures.size()))
    {
        Color texel= sample_texture(texcoords, textures[material.metallic_roughness_texture]);
        metallic= metallic * texel.b;
        roughness= roughness * texel.g;
    }
    
    float transmission= material.transmission;
    if(use_texture && material.transmission_texture != -1 && material.transmission_texture < int(textures.size()))
        transmission= transmission * sample_texture(texcoords, textures[material.transmission_texture]).r;
    
    Brdf brdf;
    {
        if(has_normals(hit, scene))
            // normale interpolee
            brdf.n= hit_normal(hit, scene);
        else
            // normale geometrique du triangle
            brdf.n= triangle_normal(hit, scene);
        
        brdf.diffuse= (1 - metallic) * color;
        brdf.F0= (1 - metallic) * Color(0.04) + metallic * color;
        // todo utiliser material.ior a la place de 0.04, si metal==0 et ior != 0
        // todo utiliser material.specular a la place de F0, si metal==0 et specular != black
        brdf.emission= material.emission;
        brdf.metallic= metallic;
        brdf.alpha= roughness * roughness;
        brdf.transmission= transmission;
    }
    
    return brdf;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 614 of file tuto_bvh2_gltf_brdf.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()));
    }
    
    // charge les textures...
    std::vector<ImageData> textures= read_gltf_images(mesh_filename);
    
    
    // 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, Color(0.2));
    
    // 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))
        {
            // evalue les parametres de la matiere au point d'intersection
            Brdf fr= hit_brdf(hit, scene, textures);
            
            float cos_theta= std::abs(dot(fr.n, normalize(ray.d)));
            Color color= fr.diffuse * cos_theta;
            
            image(x, y)= Color(color, 1);
        }
    }
    printf("\n");
    
    write_image(image, "render.png");
    return 0;
}