tuto_mesh_shader.cpp

 
 
#include <set>
#include <map>
#include <random>
 
#include "app_camera.h"
 
#include "mesh.h"
#include "wavefront_fast.h"
#include "program.h"
#include "uniforms.h"
 
struct vec3_less
{
    bool operator() ( const vec3& a, const vec3& b ) const
    {
        if(a.x != b.x)
            return a.x < b.x;
        if(a.y != b.y)
            return a.y < b.y;
        if(a.z != b.z)
            return a.z < b.z;
        return false;
    }
};
 
struct MeshShader : public AppCamera
{
    MeshShader( const char *filename ) : AppCamera( 1024, 640, 4,6 ) 
    {
        {
            if(!GLAD_GL_EXT_mesh_shader)
            {
                printf("no mesh shaders.\n");   // pas d'extension, pas de tuto...
                exit(1);
            }
            
            printf("mesh shaders:\n");
            
            GLboolean flag;
            glGetBooleanv(GL_MESH_PREFERS_LOCAL_INVOCATION_VERTEX_OUTPUT_EXT, &flag);
            if(flag) printf("  prefers local invocation vertex output\n"); else printf("  [no] prefers local invocation vertex output\n");
            glGetBooleanv(GL_MESH_PREFERS_LOCAL_INVOCATION_PRIMITIVE_OUTPUT_EXT, &flag);
            if(flag) printf("  prefers local invocation primitive output\n"); else printf("  [no] prefers local invocation primitive output\n");
            glGetBooleanv(GL_MESH_PREFERS_COMPACT_VERTEX_OUTPUT_EXT, &flag);
            if(flag) printf("  prefers compact vertex output\n"); else printf("  [no] prefers compact vertex output\n");
            glGetBooleanv(GL_MESH_PREFERS_COMPACT_PRIMITIVE_OUTPUT_EXT, &flag);
            if(flag) printf("  prefers compact primitive output\n"); else printf("  [no] prefers compact primitive output\n");
            
            GLint n;
            glGetIntegerv(GL_MAX_PREFERRED_TASK_WORK_GROUP_INVOCATIONS_EXT, &n);
            printf("  max preferred task work group invocations %d\n", n);
            glGetIntegerv(GL_MAX_PREFERRED_MESH_WORK_GROUP_INVOCATIONS_EXT, &n);
            printf("  max preferred mesh work group invocations %d\n", n);
 
            glGetIntegerv(GL_MAX_MESH_OUTPUT_VERTICES_EXT, &n);
            printf("  max output vertices %d\n", n);
            glGetIntegerv(GL_MAX_MESH_OUTPUT_PRIMITIVES_EXT, &n);
            printf("  max output primitives %d\n", n);
            glGetIntegerv(GL_MAX_MESH_OUTPUT_COMPONENTS_EXT, &n);
            printf("  max output components %d\n", n);
            glGetIntegerv(GL_MAX_MESH_OUTPUT_LAYERS_EXT, &n);
            printf("  max output layers %d\n", n);
        }
        
        m_mesh= read_indexed_mesh_fast(filename);
    }
    
    int init( )
    {
        if(m_mesh.vertex_count() == 0)
            return 0;   // pas de mesh, pas de tuto...
 
        // mesh
        const std::vector<vec3>& positions= m_mesh.positions();
        std::vector<unsigned> indices= m_mesh.indices();    // copie les indices pour les modifier...
        
        // re-indexation des sommets uniques
        std::map<vec3, unsigned, vec3_less> vertex;
        std::vector<unsigned> remap( indices.size() );
        for(unsigned i= 0; i < positions.size(); i++)
        {
            auto v= vertex.insert( { positions[i], i } );
            remap[i]= v.first->second;
        }
        
        for(unsigned i= 0; i < indices.size(); i++)
            indices[i]= remap[ indices[i] ];
        
        printf("remap %u/%u vertices...\n", unsigned(vertex.size()), unsigned(remap.size()));
        
        // construit les groupes de triangles
        std::set<unsigned> cluster;
        std::vector<unsigned> cluster_id(indices.size(), -1);
        std::vector<unsigned> triangle_id;
        triangle_id.reserve(indices.size()/3);
        
        unsigned id= 0;
        for(unsigned i= 0; i < indices.size(); i++)
        //~ for(unsigned i= 0; i +2< indices.size(); i+= 3)
        {
            unsigned a= indices[i];
            cluster.insert(a);
            //~ unsigned b= indices[i+1];
            //~ cluster.insert(b);
            //~ unsigned c= indices[i+2];
            //~ cluster.insert(c);
            
            if(cluster.size() >= 32)
            {
                id++;
                cluster.clear();
            }
            
            triangle_id.push_back(id);
        }
        unsigned count= id+1;
        cluster.clear();
        
        // couleurs aleatoires
        std::vector<vec3> colors( count );
        
        std::random_device hwseed;
        std::default_random_engine rng( hwseed() );
        std::uniform_real_distribution<float> uniform;
        
        for(unsigned i= 0; i < colors.size(); i++)
            colors[i]= { uniform(rng), uniform(rng), uniform(rng) };
        
        // affecte une couleur a chaque triangle
        std::vector<vec3> vertex_colors;
        std::vector<vec3> vertex_positions;
        vertex_colors.reserve( indices.size() );
        vertex_positions.reserve( indices.size() );
        for(unsigned i= 0; i +2 < indices.size(); i+= 3)
        {
            unsigned a= indices[i];
            unsigned b= indices[i+1];
            unsigned c= indices[i+2];
            
            vertex_positions.push_back( positions[ a ] );
            vertex_positions.push_back( positions[ b ] );
            vertex_positions.push_back( positions[ c ] );
            
            vertex_colors.push_back( colors[ triangle_id[i/3] ] );
            vertex_colors.push_back( colors[ triangle_id[i/3] ] );
            vertex_colors.push_back( colors[ triangle_id[i/3] ] );
        }
        
        glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);
        
        glGenBuffers(1, &vertex_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
        glBufferData(GL_ARRAY_BUFFER, vertex_positions.size() * sizeof(vec3), vertex_positions.data(), GL_STATIC_DRAW);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(0);
        
        glGenBuffers(1, &cluster_buffer);
        glBindBuffer(GL_ARRAY_BUFFER, cluster_buffer);
        glBufferData(GL_ARRAY_BUFFER, vertex_colors.size() * sizeof(vec3), vertex_colors.data(), GL_STATIC_DRAW);
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(1);
        
        //
        Point pmin, pmax;
        m_mesh.bounds(pmin, pmax);
        camera().lookat(pmin, pmax);
 
        //
        m_program= read_program("gkit2_tutos/M2/mesh.glsl");
        program_print_errors(m_program);
        
        m_program_display= read_program("gkit2_tutos/M2/mesh_display.glsl");
        program_print_errors(m_program_display);
 
        // etat openGL par defaut
        glClearColor(0.2f, 0.2f, 0.2f, 1.f);        // couleur par defaut de la fenetre
 
        glClearDepth(1.f);                          // profondeur par defaut
        glDepthFunc(GL_LESS);                       // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        
        glFrontFace(GL_CCW);
        glCullFace(GL_BACK);
        //~ glEnable(GL_CULL_FACE);
 
        return 1;
    }
    
    int quit( )
    {
        return 0;
    }
    
    int render( )
    {
        if(key_state('r'))
        {
            clear_key_state('r');
            reload_program(m_program, "gkit2_tutos/M2/mesh.glsl");
            program_print_errors(m_program);
            
            reload_program(m_program_display, "gkit2_tutos/M2/mesh_display.glsl");
            program_print_errors(m_program_display);
        }
        
        glViewport(0, 0, window_width(), window_height());
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        Transform model= RotationZ(global_time() / 100);
        Transform view= camera().view();
        Transform projection= camera().projection();
        
        Transform mvp= projection * view * model;
 
#if 0
        glBindVertexArray(vao);
        glUseProgram(m_program_display);
        program_uniform(m_program_display, "mvpMatrix", mvp);
        
        glDrawArrays(GL_TRIANGLES, 0, m_mesh.index_count());
#else
        
        float r= float(int(global_time() / 40) % 40) / float(40);
        
        glBindVertexArray(0);
        glUseProgram(m_program);
        program_uniform(m_program, "color", Color(r,0,0));
        program_uniform(m_program, "mvpMatrix", mvp);
        
        glDrawMeshTasksEXT(1, 1, 1);
#endif
        
        return 1;
    }
    
protected:
    Mesh m_mesh;
    GLuint m_program;
    GLuint m_program_display;
 
    GLuint vertex_buffer;
    GLuint cluster_buffer;
    GLuint vao;
};
 
    
int main( int argc, char **argv )
{
    const char *filename= "data/bigguy.obj";
    if(argc > 1)
        filename= argv[1];
    
    MeshShader app(filename);
    app.run();
    
    return 0;
}