TP2 > challenge accepted !

récupérez le fichier scène au format gltf + textures : splash3.zip
le fichier blender correspondant, si vous souhaitez faire des retouches : splash3.blend

cette version a été fortement simplifiée pour etre affichable en temps réel sur la plupart des machines. la végétation est beaucoup plus dense dans la version originale (dispo sur blender.org)


15/12/2022 : version texturée des iles... cf splash3_bake.zip
la conversion n'est pas exacte, il a fallut faire pas mal de modifications, mais ce sera mieux que tout blanc ou marron...

Partie 1 : prise en main

avant de vous lancer dans l'affichage de la scène, il est quand même recommandé de passer un peu de temps :

• à vérifier que vous etes à l'aise avec la configuration des vao et des buffers. modifiez votre tp précédent pour n'utiliser qu'un seul buffer pour stocker position et normale. repassez dans la doc, si nécessaire,
• pour les curieux : les uniform buffers, cf doc, comment manipuler de plus gros tableaux d'uniforms.
  

exercice 1 : dessiner plusieurs copies du meme objet

utilisez glDrawInstanced pour afficher plusieurs fois data/robot.obj à des endroits différents. vous devez être à l'aise avec la version qui stocke les transformations dans un buffer. cf la doc, section "draw instanced, dessiner plusieurs copies", ie configurez un attribut d'instance.

dans un premier temps, utilisez uniquement une translation, ie un vec3.

exercice 2 : et avec une matrice ?

il va falloir trouver un moyen d'utiliser une matrice pour placer et orienter chaque copie de l'objet. comment faire ? il y a au moins 2 solutions, soit utiliser des attributs d'instance, soit utiliser un tableau uniform...

• mais on ne peut pas configurer directement un attribut d'instance de type mat4, ce type n'est pas prévu, cf la doc openGL. par contre, on peut configurer 4 vecteurs (et 4 attributs), mais c'est un peu penible à faire...
• autre solution plus simple, laisser le shader faire le travail : ie connaissant l'indice de l'instance, gl_InstanceID, il suffit de déclarer un uniform, un tableau de mat4 qui contient les transformations des instances. mais...
  

mais les uniforms ne peuvent pas occuper plus de 32Ko au total, ce qui permet de stocker au mieux 512 matrices 4x4 (1 matrice == 64octets). en pratique, il faut se limiter plutot à 128 ou 256 matrices, pour laisser de la place aux autres uniforms des shaders.

in vec3 position;

uniform mat4 projection;
uniform mat4 view;

uniform mat4 models[128];

void main( )
{
    // recuperer la transform de l'instance
    mat4 model= models[gl_InstanceID];
   
    // comme d'habitude...
    gl_Position= projection * view * model * vec4(position, 1);
}
// remarque : on peut bien sur composer view et projection dans une seule matrice...

remarque : vous pouvez utiliser program_uniform( /* program */ , /* uniform */ , std::vector<Transform>& transforms ) pour initialiser ce tableau. le vecteur doit faire la meme taille que le tableau d'uniforms dans le shader. ce n'est pas nécessaire pour openGL mais la vérification permet de trouver certaines erreurs d'indexation. pour eviter l'affichage des messages dans la console, il suffit d'utiliser glUniformMatrix4fv() directement.

Partie 2 : chargement...

mettez gkit à jour, avec git pull

les fichiers src/gKit/gltf.h et src/gKit/gltf.cpp permettent de charger une scene au format gltf. la scene est décrite par une structure toute simple, cf GLTFScene, qui contient des tableaux de maillages, de transformations pour dessiner les maillages, etc.

pour les curieux : le format gltf permet de stocker pas mal de choses, cf glTF Tutorial.

exemple de parcours des noeuds, des maillages et de leur groupes de primitives (triangles) :

#include "gltf.h"

GLTFScene scene= read_gltf_scene( "..." );

// parcours les noeuds de la scene
for(unsigned node_id= 0; node_id < scene.nodes.size(); node_id++)
{
    const GLTFNode& node= scene.nodes[node_id];

    // recupere le mesh du noeud
    const GLTFMesh& mesh= scene.meshes[node.mesh_index];
    // recupere la transform du noeud
    Transform m= node.model;

    // parcours les primitives du mesh
    for(unsigned primitive_id= 0; primitive_id < mesh.primitives.size(); primitive_id++)
    {
        const GLTFPrimitives& primitives= mesh.primitives[primitive_id];

        // matiere des primitives / groupe de triangles
        const GLTFMaterial& material= scene.materials[primitives.material_index];
        
        { ... }
    }
}

quel est le nombre max d'instances utilisé dans la scène ? combien d'objets ne sont dessinés qu'une seule fois, combien sont dessinés plus de 128 fois ? et pour les autres ? quel est le nombre moyen d'instances ?

indication : utilisez GLTFScene::instances() pour analyser tout ca...

voila le résultat en image : en gris les maillages dessinés 1 fois, en rouge ceux qui sont dessinés plus de 128 fois et en jaune ceux qui sont dessinés entre 2 et 128 fois...

for( node : nodes )
{
    mesh=  node.mesh
   
    // chaque groupe de triangles est associe a une matiere differente / shader
    for( triangles : mesh.primitives )
    {
        bind_vao(triangles)
       
        material= triangles.material
        bind_program(material)
       
        // transformations
        uniform(node.model)
        uniform(view)
        uniform(projection)
       
        // parametres de la matiere
        uniform(material.color)
        uniform(material.metallic)
        uniform(material.roughness)
       
        // textures
        bind_texture(material.color_texture)
        bind_texture(material.metallic_roughness_texture)
       
        draw(triangles)
    }
}

struct state
{
    shader
    primitives
    material
    mesh
    model
}

// construire les parametres
state states[]
for( node : nodes )
{
    mesh= node.mesh
    model= node.model
   
    for( primitives : mesh.primitives )
    {
        material= primitives.material
        shader= material.shader
        states.insert( {shader, primitives, material, mesh, model} )
    }
}

// trier les parametres, ou pas...
{ ... }

// dessiner dans l'ordre
for( state : states )
{
    // shader
    if(state.shader != last shader)
    {
        use_program(state.shader)
        // camera
        unifom(view)
        uniform(projection)
    }
     
    // parametres de la matiere
    if(state.material != last material)
    {
        // parametres de la matiere
        uniform(state.material.color)
        uniform(state.material.metallic)
        uniform(state.material.roughness)       
    }
   
    // textures
    if(state.material.color_texture != last color_texture)
        bind_texture(state.material.color_texture)
    if(state.material.metallic_roughness_texture != last metallic_roughness_texture)
        bind_texture(state.material.metallic_roughness_texture);
   
    // buffers+vao
    if(state.primitives.vao != last vao)
        bind_vao(state.primitives.vao)
       
    draw(state.primitives)
}

• pour le changement de buffers/vao : une fois que l'on a identifié les primitives que l'on peut dessiner ensemble, il n'est pas très difficile de constuire un seul buffer...et si l'on ne peut pas grouper des primitives, quelle propriété empêche de le faire ?
  
• exemple : une fois que l'on a identifé les textures qui limitent la construction de plus gros groupes de primitives, il n'est pas très difficile de construire une texture plus grande qui regroupe plusieurs textures, ou d'utiliser un tableau de textures, cf Texture2DArray, pour éliminer ce changement... par contre, il faudra modifier les coordonnées de textures des primitives pour accéder aux bons texels dans le fragment shader.
• et les autres paramètres ? la transformation model ? les paramètres de base de la matière ? couleur, métal et rugosité ? et si on construisait un tableau dans le shader ??
  

Partie 3 : c'est un peu moche non ?

diffuse_color= (1 - metal) * color
specular_color = (1 - metal) * Color(0.04) + metal * color
alpha= 2 / (roughness^4) - 2

f_r(p, n, o, l)= diffuse_color / pi + specular_color * (alpha+8)/ 8pi * (cos theta(n, h))^alpha

avec
theta(u, v) : angle entre les vecteurs u et v, et cos theta(u, v), cosinus de l'angle entre u et v, cf dot(u, v) si u et v sont de longueur 1...

F= specular_color + (Color(1) - specular_color) * (1 - cos theta(o, h))^5    // utilise l'approximation des coeffs de Fresnel...

f_r(p, n, o, l)= F * diffuse_color / pi + (1 - F) * specular_color * (alpha+8)/ 8pi * (cos theta(n, h))^alpha

Partie 4 : c'est trop éclairé !

Partie x : c'est un peu lent non ?

Partie x : mais on ne voit pas le fond ? transparence...

Annexe : estimation des changements d'états