Problème d'affichage openGL suite a changement de version QT



  • Bonjour,

    dans mon logiciel j'ai 3 zones d'affichages openGL.
    Lorsque j'utilisais la version de QT 5.3 (compilateur MSVC 2013 OpenGL 64 bits) tout se passait bien. L'affichage de mes 3 zones se passe sans soucis.
    Cependant lorsque je passe à la version Qt 5.5.1 (Compilateur MSVC 2013 64 bits) je n'ai plus qu'une de mes zones d'affichages qui affiche bien se quelle doit, les 2 autres elles restent noires.

    J'ai essayer de mettre un appel a MakeCurrent() dans ma fonction paintGL mais sans succès.
    Pourriez vous m'indiquer ce qui peut changer entre ces deux versions?

    Voici la fonction PaintGL qui correspond au deux zones qui ne s'affichent pas :

    void PetiteZone::paintGL()
    {
       makeCurrent();
    
       glViewport(0, 0, width(), height());
    
       glClearColor(clearColor.redF(), clearColor.greenF(), clearColor.blueF(), 0.5f);
       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    //gestion de la lumière
    
       m_program.bind();
       m_program.setUniformValue("ambientCoeff", 1.0f);
       m_program.setUniformValue("specCoeff", 0.0f);
       m_program.setUniformValue("diffuseCoeff", 0.0f);
       m_program.setUniformValue("lightColor",  QVector3D(1.0f, 1.0f, 1.0f));
       m_program.setUniformValue("lightPos",  QVector3D(camera.getX(), camera.getY(), camera.getZ()));
       m_program.setUniformValue("viewPos", QVector3D(camera.getX(), camera.getY(), camera.getZ()));
    
       m_program.setUniformValue("view", camera.getMatrix());
       QMatrix4x4 projection;
       projection.perspective(PERSPECTIVE_ANGLE, (GLfloat)width() / (GLfloat)height(), PERSPECTIVE_NEAR, PERSPECTIVE_FAR);
       m_program.setUniformValue("projection", projection);
    
    //Affichage de la scene
    
       glEnable(GL_BLEND);
       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       AfficheDecor();
    
    //Affichage des objets avec plan de coupe 
       
    glEnable(GL_CLIP_PLANE0);
    
    
    m_program.setUniformValue("hauteurDeCouche", float(0.001));
    m_program.setUniformValue("objectColor", coupeColor);
    m_program.setUniformValue("clipPlane1", QVector4D(equationCoupe[0], equationCoupe[1], equationCoupe[2], hauteurCoupe));
    m_program.setUniformValue("z", (float)(hauteurCoupe));
    
    unsigned int nbObjet = listeDesObjets.GetNbObject();
    for (unsigned int i = 0; i < nbObjet; ++i)
    {
    	QMatrix4x4 model = listeDesObjets.GetObjectByID(i).GetMatriceTransformation();
    	m_program.setUniformValue("model", model);
    	AfficheObjet3D(i);
    }
    glDisable(GL_CLIP_PLANE0);
       
       m_program.setUniformValue("activeCouche", false);
       m_program.setUniformValue("model", QMatrix4x4());
      m_program.release();
    
       glDisable(GL_BLEND);
    
    }
    

    Merci d'avance pour votre aide :)

    EDIT : je viens de me rappeler que pour ma 1ere zone qui elle marche j'avais déjà été obligé de la faire passer par ma fonction de sélection (Picking) Pour que cela fonctionne.
    Je n'ai jamais compris ce qui dans ma fonction Picking résou le problème.
    Je viens d'ailleurs de voir que si j'appel ma fonction Picking dans mes zones qui ne fonctionnent pas elle se mettent a fonctionner. Mais j'aimerais comprendre ce qu'il me manque dans ma fonction PaintGl ou initializeGL pour que je soit obligé de faire ça.
    voici ma fonction de Picking si ca peut aider et je met en dessous ma fonction initializeGL ( la meme pour toute mes zones) :

    bool Zone::Picking()
    {
        QMatrix4x4 projection;
    
        glEnable(GL_TEXTURE_RECTANGLE);
        pickingFbo->bind();
        glClearColor(0, 0, 0, 0.5f);   // Black background
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        projection.perspective(PERSPECTIVE_ANGLE, (GLfloat)width() / (GLfloat)height(), PERSPECTIVE_NEAR, PERSPECTIVE_FAR);
    
        int nbObjet =0;
        pickingProgram.bind();
        pickingProgram.setUniformValue("projection", projection);
        pickingProgram.setUniformValue("view", camera.getMatrix());
        if (vueEnCoupeActive)
        {
            glEnable(GL_CLIP_PLANE0);
            glEnable(GL_CLIP_PLANE1);
            pickingProgram.setUniformValue("clipPlane", QVector4D(equationCoupe[0], equationCoupe[1], equationCoupe[2], equationCoupe[3]));
            pickingProgram.setUniformValue("clipPlane2", QVector4D(equationCoupeMin[0], equationCoupeMin[1], equationCoupeMin[2], equationCoupeMin[3]));
        }
        else
        {
            glDisable(GL_CLIP_PLANE0);
            glDisable(GL_CLIP_PLANE1);
        }
    
        nbObjet = listeDesObjets.GetNbObject();
        for (unsigned int i = 0; i < listeDesObjets.GetNbObject(); ++i)
        {
            pickingProgram.setUniformValue("model", listeDesObjets.GetObjectByIndice(i).GetMatriceTransformation());
            pickingProgram.setUniformValue("objectColor", QVector4D((i + 1.0) / (double)nbObjet, (i + 1.0) / (double)nbObjet, (i + 1) / (double)nbObjet, 1));
            AfficheObjet3D(i, true);
        }
    
        float pixelPicked[4];
        glReadPixels(lastPos.x(), height() - lastPos.y(), 1, 1, GL_RGBA, GL_FLOAT, &pixelPicked);
        elementSelectionner = (int)((pixelPicked[0] + 0.01) * (float)nbObjet) - 1;
    
        pickingFbo->release();
        pickingProgram.release();
        glDisable(GL_CLIP_PLANE0);
        glDisable(GL_CLIP_PLANE1);
        return (elementSelectionner != -1);
    }
    
    
    void Apercu3D::initializeGL()
    {
        initializeOpenGLFunctions();
        glEnable(GL_TEXTURE_RECTANGLE);
    
        gluPerspective(PERSPECTIVE_ANGLE, (GLfloat)width() / (GLfloat)height(), PERSPECTIVE_NEAR, PERSPECTIVE_FAR);
        glShadeModel(GL_SMOOTH);                // Enable smooth shading
        glClearColor(1.0f, 1.0f, 1.0f, 0.5f);   // White background
        glDepthRange(0.1, 1);
        glClearDepth(1.0f);                     // Depth buffer setup
        glEnable(GL_DEPTH_TEST);                // Enables depth testing
        glDepthFunc(GL_LEQUAL);                 // The type of depth testing to do
    
    
        glDepthMask(GL_TRUE);
    
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Really nice perspective calculations
        makeCurrent();
    
        pickingFbo = new QOpenGLFramebufferObject(width(), height(), GL_TEXTURE_RECTANGLE);
        pickingFbo->setAttachment(QOpenGLFramebufferObject::Depth);
        
    	if (!m_program.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/shaderAffichageObject/ressources/shaders/AffichageObjet/vertex_shader.glsl"))
            qDebug() <<__FILE__<<__FUNCTION__ << __LINE__  << m_program.log();
    
        if (!m_program.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/shaderAffichageObject/ressources/shaders/AffichageObjet/fragment_shader.glsl"))
            qDebug() <<__FILE__<<__FUNCTION__ << __LINE__  << m_program.log();
    
        if (!m_program.link())
            qDebug() <<__FILE__<<__FUNCTION__ << __LINE__  << m_program.log();
    
    
    
        qDebug() << "Version" << this->format().majorVersion() << "." << this->format().minorVersion();
        qDebug() << "OpenGL" << (char *)glGetString(GL_VERSION);
        qDebug() << (char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
       
    
        if (!pickingProgram.addShaderFromSourceFile(QOpenGLShader::Vertex,":/shadersPicking/Ressources/shaders/Picking/vertex_shader.glsl"))
            qDebug() <<__FILE__<<__FUNCTION__ << __LINE__  << pickingProgram.log();
    
        if (!pickingProgram.addShaderFromSourceFile(QOpenGLShader::Fragment,":/shadersPicking/Ressources/shaders/Picking/fragment_shader.glsl"))
            qDebug() <<__FILE__<<__FUNCTION__ << __LINE__  << pickingProgram.log();
    
        if (!pickingProgram.link())
            qDebug() <<__FILE__<<__FUNCTION__ << __LINE__  << pickingProgram.log();
        initialized = true;
    
    }
    

Log in to reply
 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.