TP 1 - Méthodes de monte carlo
et lancer de rayons.

• geometry
• shadow
• emission
• secondary
• matières nécessaires pour charger les scènes de test.

Partie 1 : lancer de rayons et visibilité

exercice 1 : visualisation par lancer de rayons

• gk::Ray permet de représenter et de manipuler facilement un rayon. 
• gk::Hit permet de représenter simplement une intersection,
  
• les fonctions d'intersections rayon / triangle et rayon / bbox sont déjà écrites : gk::RTTriangle::intersect( ) et gk::BBox::intersect( ).

exercice 2 : structures accélératrices

Construisez un arbre permettant de grouper les objets / les primitives de la scène en utilisant le premier algorithme décrit en cours.

Comparer les temps d'execution avec et sans la structure accélératrice. Est-elle rentable pour toutes les scènes ?

il faut fournir un prédicat à std::partition, la manière la plus souple consiste à créer un foncteur :

struct compareTriangle
{
    int axe;
    float coupe;
   
    compareTriangle( const int _axe, const float _coupe )
        :
        axe(_axe),
        coupe(_coupe)
    {}
   
    bool operator( )( const gk::RTTriangle& triangle ) const
    {
        return (triangle.getBBoxCenter(axe) < coupe);
    }
};

on peut utiliser ce predicat avec std::partition :

gk::RTTriangle *pivot= std::partition( &triangles[triangle_start], &triangles[triangle_end], compareTriangle(axe, milieu) );

utilisation de la structure accélératrice :

Ecrivez la fonction intersect( const gk::Ray& ray, gk::Hit& hit ) qui teste les intersections entre le rayon et les triangles stockés dans l'arbre.

Utilisez les champs de la structure gk::Hit pour stocker le point d'intersection, sa normale, sa matiere, etc.

indication : pour retrouver facilement la matière d'un triangle lors du calcul d'éclairage, le plus simple est de la récuperer dans le gk::Mesh, mais il faut stocker l'indice du triangle... cf gk::RTTriangle::id

	// charger un objet
	gk::Mesh *mesh= gk::MeshIO::read("bigguy.obj");
	if(mesh == NULL)
		return "erreur";
	
	// recupere les triangles 
	int n= mesh->triangleCount();
	for(int i= 0; i < n; i++)
	{
		gk::RTTriangle triangle= mesh->getTriangle(i);
		triangle.id= i;	// conserver l'indice du triangle dans l'objet

		triangles.push_back( triangle );
	}

	for(unsigned int i= debut; i < fin; i++)
	{
		float t, u, v;
		if(triangles[i].Intersect(ray, hit.t, t, u, v))
		{
			hit.t= t;
			hit.u= u;
			hit.v= v;
			hit.p= ray(t);
			hit.object_id= triangles[i].id;	// permet de retrouver toutes les infos associees au triangle
		}
	}

gk::MeshMaterial& material= mesh->getTriangleMaterial(hit.object_id);
gk::Normal normal= mesh->getTriangleNormal(hit.object_id);

// ou la normale interpolée à l'interieur du triangle, au lieu de la normale géométrique
gk::Normal normal= mesh->getUVNormal(hit.object_id, hit.u, hit.v);



Partie 2 : éclairage direct et méthode de Monte Carlo

Reprenez l'exemple du cours et écrivez la fonction direct( ) qui estime l'énergie directe réfléchie par un point p. :

           

exercice 1 : 1 source

exercice 2 : toutes les sources

Partie 3 : éclairage indirect et méthode de Monte Carlo

• solution 1 : choisissez un point uniformément sur les triangles des objets de la scène, quelle est la probabilité de choisir de ce point ?
  
• solution 2 : choisissez une direction, trouvez le point visible dans cette direction, quelle est la probabilité de choisir cette direction ? quelle est la probabilité de choisir le point visible ?

rappel : pensez à exprimer toutes les probabilités sur le même domaine / mesure...

Annexe : squelette d'application pour démarrer.

// calcule l'intersection d'un rayon et de tous les triangles
bool intersect( const gk::Ray& ray, gk::Hit& hit )
{
    for(unsigned int i= 0; i < triangles.size(); i++)
    {
	float t, u, v;
	if(triangles[i].Intersect(ray, hit.t, t, u, v))
	{
	     hit.t= t;
	     hit.u= u;
	     hit.v= v;
	     hit.p= ray(t);
	     hit.object_id= triangles[i].id;	// permet de retrouver toutes les infos associees au triangle
	}
    }

    return (hit.object_id != -1);
}