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. More...
Node	make_leaf (const BBox &bounds, const int begin, const int end)
	creation d'une feuille. More...
Point	hit_position (const Hit &hit, const Ray &ray)
	renvoie la position du point d'intersection sur le rayon. More...
bool	has_normals (const Hit &hit, const GLTFScene &scene)
	verifie la presence des normales par sommet. More...
Vector	hit_normal (const Hit &hit, const GLTFScene &scene)
	renvoie la normale interpolee au point d'intersection dans le repere de la scene. More...
Vector	triangle_normal (const Hit &hit, const GLTFScene &scene)
	normale geometrique du triangle, si necessaire... ie si has_normals(hit, scene) == false... More...
bool	has_texcoords (const Hit &hit, const GLTFScene &scene)
	verifie la presence des coordonnees de texture... More...
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 More...
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. More...
Color	hit_color (const Hit &hit, const GLTFScene &scene)
	renvoie la couleur de base de la matiere du point d'intersection. More...
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 More...
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)

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;
}