TP5 - compute shaders et rayons

Partie 1 : préparation - compute shaders, storage buffers / textures

pour démarrer en douceur, on va se concentrer sur les nouveautés techniques : les "shader storage buffers"... ce sont des buffers comme les autres (ils sont crées avec glBufferData()) mais un shader peut écrire une valeur dans ces buffers (d'ou leur nom...)

relisez la doc, sur les storage buffers, si ce n'est pas déjà fait.

si vous avez du mal à structurer le programme de départ : regardez tutos/tuto_compute_vertex.cpp et son shader tutos/vertex_compute.glsl

exercice 1 : écrivez un compute shader débile qui ajoute 10 à chaque case d'un tableau passé en paramètre.


void ajoute( std::vector<int>& entree )
{
    for(unsigned i= 0; i < entree.size(); i++)
        entree[i]= entree[i] + 10;
}

// pour relire size elements...
std::vector<int> tmp(size, 0);

// attendre que les donnees soient ecrites en memoire apres l'execution des compute shaders
glMemoryBarrier( GL_BUFFER_UPDATE_BARRIER_BIT);

// relire le contenu du buffer


glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);

glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(int) * size, tmp.data());

// afficher
for(int i= 0; i < size; i++)
    printf("%d ", tmp[i]);


printf("\n");

void divise( Image& image )
{
    for(unsigned i= 0; i < image.size(); i++)
        image(i)= image(i) / 2;
}

ou
void divise( Image& image )
{
    for(int y= 0; y < image.height(); y++)
    for(int x= 0; x < image.width(); x++)
        image(x, y)= image(x, y) / 2;
}

Image read_texture( const GLuint tex )
{
    // selectionne la texture pour la manipuler
    glBindTexture(GL_TEXTURE_2D, tex);

    // recupere les dimensions de l'image
    int width= 0;
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,  GL_TEXTURE_WIDTH, &width);
    int height= 0;
    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,  GL_TEXTURE_HEIGHT, &height);
   
    Image image(width, height);
    glGetTexImage(GL_TEXTURE_2D, /* mipmap */ 0, GL_RGBA, GL_FLOAT, image.data());
   
    return image;
}

Partie 2 : et les rayons ?

Partie 3 : et avec beaucoup de triangles ?

• soit coudre l'arbre, ie stocker le noeuds dans l'ordre du parcours en profondeur (noeud puis fils gauche puis fils droit), le parcours devient parfaitement itératif,
  
• soit manipuler explicitement une pile (d'indices) de noeuds à parcourir.

est ce qu'une solution est meilleure que l'autre ? manipuler une pile explicite permet de faire un parcours ordonné (ie de choisir dans quel sens visiter les fils en fonction du rayon), a priori plus rapide, par contre, lire et écrire constamment la pile génère un gros traffic mémoire. utiliser la couture du BVH élimine ce problème, mais le parcours ne sera pas ordonné...

// intersection avec un rayon, entre 0 et htmax
     Hit intersect( const Ray& ray, const float htmax ) const
     {
         Hit hit;
         hit.t= htmax;
         Vector invd= Vector(1 / ray.d.x, 1 / ray.d.y, 1 / ray.d.z);
         intersect(root, ray, invd, hit);
         return hit;
     }

// intersection et parcours simple
     void intersect( const int index, const Ray& ray, const Vector& invd, Hit& hit ) const
     {
         const Node& node= nodes[index];
         if(node.bounds.intersect(ray, invd, hit.t))
         {
             if(node.leaf())
             {
                 // parcours tous les triangles references par la feuille
                 for(int i= node.leaf_begin(); i < node.leaf_end(); i++)
                     if(Hit h= primitives[i].intersect(ray, hit.t))
                         hit= h;
             }
             else // if(node.internal())
             {
                 // visite les fils du noeud interne
                 intersect(node.internal_left(), ray, invd, hit);
                 intersect(node.internal_right(), ray, invd, hit);

                 // todo parcours ordonne...
             }
         }
     }

   

    const Node& node= nodes[index];                        // 1er acces memoire, chargement du noeud, + indices des fils, node.left et node.right
    bool left= nodes[node.left].bounds.intersect(...);     // 2ieme acces memoire, chargement de l'englobant du fils gauche
    bool right= nodes[node.right].bounds.intersect(...);   // 3ieme acces memoire, chargement de l'englobant du fils droit

• "Restart Trail for Stackless BVH Traversal", 2010, utilise 1 bit par niveau du bvh pour reprendre le parcours depuis la racine lorsque la pile locale est vide...
  
• "Efficient Stack-less BVH Traversal for Ray Tracing", 2011, une autre version de la couture d'arbre, mais avec un parcours ordonné,
  
• "Dynamic Stackless Binary Tree Traversal", 2013, une formulation particuliere du probleme,
  
• "Efficient Stackless Hierarchy Traversal on GPUs with Backtracking in Constant Time", 2016, une table de hachage pre-calculée à la place d'une pile...
  

• compresser les positions des sommets des triangles et des boites englobantes ? utiliser plus de fils par noeud ?
  pourquoi ces solutions permettraient d'accelerer le parcours ? dans quel cas ?
• aider l'ordonnanceur ? si un seul thread veut tester un noeud, tous les threads du sous groupe prennent cette branche aussi, comment les faire travailler dans ce cas ?
• ou, tout simplement, construire un arbre de meilleure qualité ? ou adapté au parcours parallélisé par un gpu ? le code de départ utilise une construction naive...