pipeline_statistics.cpp

 
#include "app_time.h"
#include "app_camera.h"
 
#include "mesh.h"
#include "wavefront_fast.h"
#include "draw.h"
 
#include "program.h"
#include "uniforms.h"
 
 
struct TP : public AppTime
{
    TP( const char *filename ) : AppTime(1024, 640)
    {
        m_mesh= read_indexed_mesh_fast( filename );
    }
    
    int init( )
    {
        if(m_mesh.vertex_count() == 0)
            return -1;
 
        m_program= read_program("gkit2_tutos/M2/statistics.glsl");
        program_print_errors(m_program);
        
        // camera
        m_camera.projection(window_width(), window_height(), 45);
        Point pmin, pmax;
        m_mesh.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // requetes
        glGenQueries(1, &m_sample_query);
        glGenQueries(1, &m_vertex_query);
        glGenQueries(1, &m_primitive_query);
        glGenQueries(1, &m_vertex_shader_query);
        glGenQueries(1, &m_culling_query);
        glGenQueries(1, &m_clipping_query);
        glGenQueries(1, &m_sample_query);
        glGenQueries(1, &m_fragment_shader_query);
        
        // 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_LEQUAL);                     // ztest, conserver l'intersection la plus proche de la camera
        glEnable(GL_DEPTH_TEST);                    // activer le ztest
        glEnable(GL_CULL_FACE);
        
        return 0;
    }
    
    int quit( )
    {
        return 0;
    }
    
    int render( )
    {
        update_camera( m_camera );
        
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
        
        static bool capture= false;
        static bool rasterizer_discard= false;
        if(key_state('d'))
        {
            clear_key_state('d');
            rasterizer_discard= !rasterizer_discard;
            capture= true;      // force une capture
            
            if(!rasterizer_discard)
                printf("rasterizer ON\n");
            else
                printf("rasterizer off\n");
        }
        if(rasterizer_discard)
            glEnable(GL_RASTERIZER_DISCARD);
        else
            glDisable(GL_RASTERIZER_DISCARD);
        
        static bool zinit= false;
        if(key_state('z'))
        {
            clear_key_state('z');
            zinit= !zinit;
            capture= true;      // force une capture
           
            if(zinit)
                printf("Z prepass ON\n");
            else
                printf("Z prepass off\n");
        }
        
        // 
        static bool cull= true;
        if(key_state('f'))
        {
            clear_key_state('f');
            cull= !cull;
            capture= true;      // force une capture
            
            if(cull)
                glEnable(GL_CULL_FACE);
            else
                glDisable(GL_CULL_FACE);
            
            if(cull)
                printf("face culling ON\n");
            else
                printf("face culling off\n");
        }
        
        static bool early_tests= false;
        static const char *early_tests_definition= "";
        if(key_state('e'))
        {
            clear_key_state('e');
            early_tests= !early_tests;
            capture= true;      // force une capture
            
            if(early_tests)
                early_tests_definition= "#define EARLY_TESTS";
            else
                early_tests_definition= "#undef EARLY_TESTS";
            
            if(early_tests)
                printf("early fragment tests ON\n");
            else
                printf("early fragment test off\n");
            
            reload_program(m_program, early_tests_definition);
            program_print_errors(m_program);            
        }
        
        // 
        Transform model;
        Transform view= m_camera.view();
        Transform projection= m_camera.projection(window_width(), window_height(), 45);
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        //
        if(zinit)
            draw( m_mesh, Identity(), m_camera );
        
        //
        glBeginQuery(GL_VERTICES_SUBMITTED, m_vertex_query);
        glBeginQuery(GL_PRIMITIVES_SUBMITTED, m_primitive_query);
        glBeginQuery(GL_VERTEX_SHADER_INVOCATIONS, m_vertex_shader_query);
        glBeginQuery(GL_CLIPPING_INPUT_PRIMITIVES, m_culling_query);         // reussi le test de front/back face culling
        glBeginQuery(GL_CLIPPING_OUTPUT_PRIMITIVES, m_clipping_query);
        glBeginQuery(GL_SAMPLES_PASSED, m_sample_query);
        glBeginQuery(GL_FRAGMENT_SHADER_INVOCATIONS, m_fragment_shader_query);
 
        glUseProgram(m_program);
        program_uniform(m_program, "mvMatrix", mv);
        program_uniform(m_program, "mvpMatrix", mvp);
        
        m_mesh.draw(m_program);
        // draw( m_mesh, model, m_camera );
        
        glEndQuery(GL_VERTICES_SUBMITTED);
        glEndQuery(GL_PRIMITIVES_SUBMITTED);
        glEndQuery(GL_VERTEX_SHADER_INVOCATIONS);
        glEndQuery(GL_CLIPPING_INPUT_PRIMITIVES);
        glEndQuery(GL_CLIPPING_OUTPUT_PRIMITIVES);
        glEndQuery(GL_SAMPLES_PASSED);
        glEndQuery(GL_FRAGMENT_SHADER_INVOCATIONS);
        
        // recuperer les resultats.
        GLint64 gpu_vertex= 0;
        glGetQueryObjecti64v(m_vertex_query, GL_QUERY_RESULT, &gpu_vertex);
        GLint64 gpu_primitive= 0;
        glGetQueryObjecti64v(m_primitive_query, GL_QUERY_RESULT, &gpu_primitive);
        GLint64 gpu_vertex_shader= 0;
        glGetQueryObjecti64v(m_vertex_shader_query, GL_QUERY_RESULT, &gpu_vertex_shader);
        GLint64 gpu_culling= 0;
        glGetQueryObjecti64v(m_culling_query, GL_QUERY_RESULT, &gpu_culling);
        GLint64 gpu_clipping= 0;
        glGetQueryObjecti64v(m_clipping_query, GL_QUERY_RESULT, &gpu_clipping);
        GLint64 gpu_samples= 0;
        glGetQueryObjecti64v(m_sample_query, GL_QUERY_RESULT, &gpu_samples);
        GLint64 gpu_fragment_shader= 0;
        glGetQueryObjecti64v(m_fragment_shader_query, GL_QUERY_RESULT, &gpu_fragment_shader);
        
        if(capture || key_state(' '))
        {
            capture= false;
            clear_key_state(' ');
            
            if(zinit) printf("Z prepass ON, ");
            else printf("Z prepass off, ");
            if(cull) printf("face culling ON, ");
            else printf("face culling off, ");
            if(early_tests) printf("early fragment tests ON");
            else printf("early fragment test off");
            printf("\n");
            
            printf("primitives %d\n", int(gpu_primitive));
            printf("positions %d, indices %d, vertex shader %d\n", m_mesh.vertex_count(), int(gpu_vertex), int(gpu_vertex_shader));
            printf("culling primitives %d, clipping primitives %d\n", int(gpu_culling), int(gpu_clipping));
            printf("samples %d, fragment shaders %d\n", int(gpu_samples), int(gpu_fragment_shader));
            printf("\n");
        }
        
        glDisable(GL_RASTERIZER_DISCARD);       // le rasterizer doit etre actif, sinon pas de clear, et de pas de texte
        return 1;
    }
    
protected:
    Mesh m_mesh;
    Orbiter m_camera;
    GLuint m_program;
 
    GLuint m_vertex_query;
    GLuint m_primitive_query;
    GLuint m_vertex_shader_query;
    GLuint m_culling_query;
    GLuint m_clipping_query;
    GLuint m_sample_query;
    GLuint m_fragment_shader_query;
};    
 
int main( int argc, char **argv )
{
    const char *filename= "data/bigguy.obj";
    if(argc > 1)
        filename= argv[1];
    
    TP app( filename );
    app.run();
    
    return 0;
}