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

[FlaMMe]

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;

}