aaquads.cpp

Go to the documentation of this file.

 
#include "app_time.h"
#include "app_camera.h"     // gestion camera
 
#include "vec.h"
#include "mat.h"
 
#include "draw.h"
#include "program.h"
#include "uniforms.h"
#include "texture.h"
 
#include "mesh.h"
#include "wavefront_fast.h"
 
#include "orbiter.h"
 
 
class Quads : public AppTime
{
public:
    // application openGL 4.4
    Quads( const char *filename ) : AppTime(1024, 1024,  4,4)
    {
        m_mesh= read_indexed_mesh_fast( filename );
    }
    
    int init( )
    {
        if(m_mesh.vertex_count() == 0)
            return -1;  // pas de geometrie
        
        Point pmin, pmax;
        m_mesh.bounds(pmin, pmax);
        m_camera.lookat(pmin, pmax);
        
        // cree la texture, 1 canal, entiers 32bits non signes
        m_aatexture= make_uint_texture(0, 8192, 8192);    // ou 8x8 sur une image de base 1024x1024
        m_aadepth= make_depth_texture(0, 8192, 8192);    // ou 8x8 sur une image de base 1024x1024
        
        glGenFramebuffers(1, &m_framebuffer);
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebuffer);
        glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_aatexture, 0);
        glFramebufferTexture(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_aadepth, 0);
        
        GLenum buffers[]= { GL_COLOR_ATTACHMENT0 };
        glDrawBuffers(1, buffers);        
        
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
        
        // resultat
        m_texture= make_uint_texture(0, 1024, 1024);
        
        // 
        m_program= read_program("gkit2_tutos/M2/aaquads.glsl");
        program_print_errors(m_program);
        m_program_count= read_program("gkit2_tutos/M2/aaquads_count.glsl");
        program_print_errors(m_program_count);
        
        m_program_display= read_program("gkit2_tutos/M2/aaquads_display.glsl");
        program_print_errors(m_program_display);
        
        // 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 m_camera
        glEnable(GL_DEPTH_TEST);                // activer le ztest
        
        glFrontFace(GL_CCW);
        glCullFace(GL_BACK);
        glEnable(GL_CULL_FACE);                 // active le back face culling
        
        return 0;   // ras, pas d'erreur
    }
    
    // destruction des objets de l'application
    int quit( )
    {
        m_mesh.release();
        release_program(m_program);
        release_program(m_program_count);
        release_program(m_program_display);
        glDeleteTextures(1, &m_texture);
        glDeleteTextures(1, &m_aatexture);
        glDeleteTextures(1, &m_aadepth);
        glDeleteFramebuffers(1, &m_framebuffer);
        return 0;
    }
    
    // dessiner une nouvelle image
    int render( )
    {
        static bool zinit= false;
        if(key_state('z'))
        {
            clear_key_state('z');
            zinit= !zinit;
            
            if(zinit)
                printf("Z prepass ON\n");
            else
                printf("Z prepass off\n");
        }
        // plus tres utile...
        
        static bool cull= true;
        if(key_state('f'))
        {
            clear_key_state('f');
            
            cull= !cull;
            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= "";
        static bool reload= false;
        if(key_state('e'))
        {
            clear_key_state('e');
            
            early_tests= !early_tests;
            if(early_tests)
                early_tests_definition= "#define EARLY_TESTS";
            else
                early_tests_definition= "#undef EARLY_TESTS";
            reload= true;
            
            if(early_tests)
                printf("early fragment tests ON\n");
            else
                printf("early fragment test off\n");
        }
        
        if(reload || key_state('r'))
        {
            reload= false;
            clear_key_state('r');
            
            reload_program(m_program, early_tests_definition);
            program_print_errors(m_program);
            
            reload_program(m_program_count);
            program_print_errors(m_program_count);
            
            reload_program(m_program_display);
            program_print_errors(m_program_display);            
        }
        
        
        // passe 1 : stocker les ids des triangles 
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebuffer);
        glViewport(0, 0, 8192, 8192);
        
        float one[]= { 1 };
        glClearBufferfv(GL_DEPTH, /* draw buffer */ 0, one);          // profondeur par defaut
        GLuint zero[]= { 0, 0, 0, 0 };
        glClearBufferuiv(GL_COLOR, /* draw buffer */ 0, zero);          // valeur par defaut
        
        // transformations
        Transform view= m_camera.view();
        Transform projection= m_camera.projection(8192, 8192, 60);
        
        Transform model;
        if(key_state(' '))
            model= RotationY(global_time() / 60);
        
        Transform mv= view * model;
        Transform mvp= projection * mv;
        
        // Z prepass, si necessaire...
        if(zinit)
        {
            draw(m_mesh, model, view, projection);
        }
        
        glUseProgram(m_program);
        program_uniform(m_program, "mvpMatrix", mvp);
        
        m_mesh.draw(m_program);
        
        //
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
        glViewport(0, 0, window_width(), window_height());
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        glClearTexImage(m_texture, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, zero);
        
        {
            // passe 2 : compter le nombre de triangles par pixel
            glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
            glUseProgram(m_program_count);
            
            glBindImageTexture(0, m_texture, 0, GL_TRUE, 0, GL_WRITE_ONLY, GL_R32UI);
            program_uniform(m_program, "counters", 0);
            
            glBindImageTexture(1, m_aatexture, 0, GL_TRUE, 0, GL_READ_ONLY, GL_R32UI);
            program_uniform(m_program, "primitives", 1);
            
            glDispatchCompute(1024, 1024, 1);
            
            // passe 3 : visualiser le compteur de fragments
            glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
            glUseProgram(m_program_display);
            
            program_uniform(m_program_display, "image", 0);
            
            glDrawArrays(GL_TRIANGLES, 0, 3);
        }
        
        // gestion mouvements camera
        update_camera( m_camera );
        
        return 1;
    }
 
protected:
    Mesh m_mesh;
    Orbiter m_camera;
 
    GLuint m_program;
    GLuint m_program_count;
    GLuint m_program_display;
 
    GLuint m_framebuffer;
    GLuint m_aatexture;
    GLuint m_aadepth;
 
    GLuint m_texture;
};
 
 
int main( int argc, char **argv )
{
    const char *filename= "data/bigguy.obj";
    //~ const char *filename= "data/ccbigguy.obj";
    if(argc > 1)
        filename= argv[1];
    
    Quads app( filename );
    app.run();
    
    return 0;
}