vertices.cpp

 
#include <algorithm>
#include <random>
 
#include "mat.h"
#include "mesh.h"
#include "wavefront.h"
#include "wavefront_fast.h"
#include "gltf.h"
 
#include "orbiter.h"
#include "program.h"
#include "uniforms.h"
#include "texture.h"
#include "draw.h"
 
#include "app_time.h"        // classe Application a deriver
#include "app_camera.h"
 
// oui c'est moche...
#include "M2/meshoptimizer/meshoptimizer.h"
#include "M2/meshoptimizer/indexanalyzer.cpp"
#include "M2/meshoptimizer/vcacheoptimizer.cpp"
#include "M2/meshoptimizer/vfetchoptimizer.cpp"
 
 
void vcache( const Mesh& mesh )
{
    meshopt_VertexCacheStatistics stats= meshopt_analyzeVertexCache( mesh.indices().data(), mesh.indices().size(), mesh.positions().size(), 
        /* cache size */ 14, /* warp size */ 64, /* primgroup size*/ 128 );     // amd
        //~ /* cache size */ 16, /* warp size */ 32, /* primgroup size*/ 32 );      // nvidia
    
    printf("[vertex cache]\n");
    printf("  transformed vertices %u\n", stats.vertices_transformed);
    printf("  warps %u\n", stats.warps_executed);
    printf("  acmr transformed vertices / triangle  %f\n", stats.acmr);
    printf("  atvr transformed vertices / vertex %f\n", stats.atvr);
    printf("\n");
    /* acmr : transformed vertices / triangle count; best case 0.5, worst case 3.0, optimum depends on topology */
    /* atvr : transformed vertices / vertex count; best case 1.0, worst case 6.0, optimum is 1.0 (each vertex is transformed once) */
}
 
void vfetch( const Mesh& mesh )
{
    unsigned vertex_size= sizeof(vec3);
    meshopt_VertexFetchStatistics stats= meshopt_analyzeVertexFetch( mesh.indices().data(), mesh.indices().size(), mesh.positions().size(), vertex_size );
    
    printf("[vertex fetch]\n");
    printf("  bytes %u, %uMB\n", stats.bytes_fetched, stats.bytes_fetched / 1024 / 1024);
    printf("  overfetch %f\n", stats.overfetch);
    printf("\n");    
}
 
 
Mesh shuffle( const Mesh& data )
{
    struct triangle
    {
        unsigned a, b, c;
    };
    
    std::vector<triangle> triangles;
    triangles.reserve(data.triangle_count());
    
    std::vector<unsigned> indices= data.indices();
    for(unsigned i= 0; i +2 < indices.size(); i+= 3)
    {
        triangle t= { indices[i], indices[i+1], indices[i+2] };
        triangles.push_back( t );
    }
    
    std::random_device hwseed;
    std::default_random_engine rng( hwseed() );
    std::shuffle(triangles.begin(), triangles.end(), rng);
    
    indices.resize(triangles.size() * 3);
    for(unsigned i= 0; i < triangles.size(); i++)
    {
        triangle t= triangles[i];
        indices[3*i]= t.a;
        indices[3*i+1]= t.b;
        indices[3*i+2]= t.c;
    }
    
    return Mesh( data.primitives(), data.positions(), indices );
}
 
 
Mesh optimize_vcache( const Mesh& mesh )
{
    std::vector<unsigned> indices( mesh.index_count() );
    meshopt_optimizeVertexCache( indices.data(), mesh.indices().data(), mesh.indices().size(), mesh.positions().size() );
    
    return Mesh( mesh.primitives(), mesh.positions(), indices );
}
 
Mesh optimize_vfetch( const Mesh& mesh )
{
    std::vector<vec3> positions( mesh.vertex_count() );
    std::vector<unsigned> indices= mesh.indices();
    meshopt_optimizeVertexFetch( positions.data(), indices.data(), indices.size(), mesh.positions().data(), mesh.positions().size(), sizeof(vec3) );
    
    return Mesh( mesh.primitives(), positions, indices );
}
 
 
class TP : public AppTime
{
public:
    // constructeur : donner les dimensions de l'image, et eventuellement la version d'openGL.
    TP( const char *filename ) : AppTime(1024, 576, 4,4)
    {
        m_objet= read_indexed_mesh_fast(filename);
    }
    
    int init( )
    {
        if(m_objet.vertex_count() == 0)
            return -1;
        
        // conserve une copie de l'original...
        m_objet_reference= m_objet;
        
        // projection par defaut, adaptee a la fenetre
        m_camera.projection(window_width(), window_height(), 45);
        
        // placer la camera
        Point pmin, pmax;
        m_objet.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // creer le shader program, uniquement necessaire pour l'option 2, cf render()
        m_program= read_program("gkit2_tutos/M2/vertex.glsl");
        program_print_errors(m_program);
        
        m_display_program= read_program("gkit2_tutos/M2/vertex_display.glsl");
        program_print_errors(m_display_program);
        
        // etat openGL par defaut
        glClearColor(0.2, 0.2, 0.2, 1);        // couleur par defaut de la fenetre
        
        glClearDepth(1);                          // profondeur par defaut
        glDepthFunc(GL_LEQUAL);                       // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        glEnable(GL_CULL_FACE);
        
        glGenQueries(1, &m_query_vertex_shaders);
        
        glGenBuffers(1, &m_buffer);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(unsigned) * m_objet.vertex_count(), nullptr, GL_STREAM_DRAW);
        
        // compte le nombre de triangles referencant chaque sommet
        const std::vector<unsigned> &indices= m_objet.indices();
        m_shared.resize( m_objet.vertex_count() );
        
        for(unsigned i= 0; i < indices.size(); i++)
            m_shared[ indices[i] ]++;
        
        return 0;   // ras, pas d'erreur
    }
    
    // destruction des objets de l'application
    int quit( )
    {
        release_program(m_program);
        m_objet.release();
        return 0;
    }
    
    // dessiner une nouvelle image
    int render( )
    {
        update_camera( m_camera );      // pour screenshot, temps gpu inclu...
        
        //
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        static int optimize= 0;
        static bool capture= true;
        static const char *export_filename= "export.obj";
        
        if(key_state('o'))
        {
            clear_key_state('o');
            optimize= (optimize +1) % 4;
            
            if(optimize == 0)
            {
                capture= true;     // force une nouvelle capture
                printf("reference...\n");
                m_objet= m_objet_reference;
                export_filename= "reference.obj";
            }
            
            if(optimize == 1)
            {
                capture= true;     // force une nouvelle capture
                printf("optimize...\n");
                m_objet= optimize_vcache(m_objet_reference);
                m_objet= optimize_vfetch(m_objet);
                export_filename= "optimize.obj";
            }
            
            if(optimize == 2)
            {
                capture= true;     // force une nouvelle capture
                printf("shuffle...\n");
                m_objet= shuffle(m_objet_reference);
                export_filename= "shuffle.obj";
            }
            
            if(optimize == 3)
            {
                capture= false;     // pas de capture !! on modifie directement le buffer
                printf("shared...\n");
                m_objet= m_objet_reference;
                
                glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffer);
                glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(unsigned) * m_shared.size(), m_shared.data(), GL_STREAM_DRAW);
                export_filename= "reference.obj";
            }
            
            // analyse l'objet
            vcache(m_objet);
            vfetch(m_objet);
        }
        
        // export
        if(key_state('x'))
        {
            clear_key_state('x');
            write_mesh(m_objet, export_filename);
        }
        
        if(key_state('r'))
        {
            capture= true;     // force une nouvelle capture
            clear_key_state('r');
 
            // recharger le shader
            reload_program(m_program);
            program_print_errors(m_program);
            
            reload_program(m_display_program);
            program_print_errors(m_display_program);            
        }
        
        static bool rotate= false;
        if(key_state(' '))
        {
            clear_key_state(' ');
            rotate= !rotate;
        }
        
        static Transform model= Identity();
        if(rotate)
            model= RotationY(global_time() / 40);
        
        Transform view= m_camera.view();
        Transform projection= m_camera.projection(window_width(), window_height(), 45);
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        // capture les transformations
        if(capture)
        {
            capture= false;     // 1 seule fois
            
            int zeros[4]= { 0, 0, 0, 0 };
            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
            glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, zeros);
        
            glBeginQuery(GL_VERTEX_SHADER_INVOCATIONS, m_query_vertex_shaders);
            
                glUseProgram(m_program);
                program_uniform(m_program, "mvpMatrix", mvp);
                
                m_objet.draw(m_program);
 
            glEndQuery(GL_VERTEX_SHADER_INVOCATIONS);
            
            GLuint64 vertices= m_objet.vertex_count();
            GLuint64 vertex_shaders= 0; glGetQueryObjectui64v(m_query_vertex_shaders, GL_QUERY_RESULT, &vertex_shaders);
            printf("%lu transformed vertices / %lu vertex atvr %f\n", vertex_shaders, vertices, float(vertex_shaders) / float(vertices));
            
            glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
            glClear(GL_COLOR_BUFFER_BIT);
        }
        
        // affiche  la capture / nombre de sommets transformes
        {
            glUseProgram(m_display_program);
            program_uniform(m_display_program, "mvpMatrix", mvp);
            program_uniform(m_display_program, "mvMatrix", mv);
            
            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
            
            m_objet.draw( m_display_program);
        }
        
        return 1;
    }
 
protected:
    Transform m_model;
    Orbiter m_camera;
    Mesh m_objet;
    Mesh m_objet_reference;
 
    std::vector<unsigned> m_shared;
    
    GLuint m_program;
    GLuint m_display_program;
    GLuint m_buffer;
 
    GLuint m_query_vertices;
    GLuint m_query_vertex_shaders;
    GLuint m_query_fragment_shaders;
};
 
 
int main( int argc, char **argv )
{
    const char *filename= "data/bigguy.obj";
    //~ const char *filename= "bunny.obj";
    
    if(argc > 1)
        filename= argv[1];
    
    TP tp( filename );
    tp.run();
    
    return 0;
}