Qual è l'inizializzazione OpenGL corretta su Intel HD 3000?

Question

Ho un problema con grafica Intel HD 3000 su Toshiba notebook (OS Win7 x32, lingua C++).

Classical unico contesto OpenGL applicazioni funzionano bene, ma su più OpenGL contesti in un'unica App crea strano comportamento:

1. su versioni precedenti di mie applicazioni del driver Intel non può creare secondo contesto di rendering a tutti.

2. dopo grandi cambiamenti nella mia OpenGL comportamento un'architettura software basata cambiato

   ora sono in grado di creare secondo contesto di rendering, ma dopo rilasciarlo (dopo l'uso chiudere la finestra /) il conducente non può creare qualsiasi contesto di rendering successiva. Questo è stato testato su più di un'app e si comporta sempre nello stesso modo. Volevo superarlo facendo in modo che il secondo contesto fosse sempre attivo, ma non funziona (in qualche modo il contesto di rendering è invalidato su Intel). Per chiarezza, il secondo contesto di rendering OpenGL viene utilizzato per finestre di dialogo Apri/Salva (finestre secondarie di anteprima). Informazioni

driver:

Intel(R) HD Graphics 3000 
OpenGL ver: 3.1.0 - Build 9.17.10.2932 

Init e uscire OpenGL codice (dal mio motore OpenGL):

//------------------------------------------------------------------------------ 
int OpenGLscreen::init(void *f,int textures) 
    { 
    if (_init) exit(); 
    frm=(formtype*)f; 
    hdc = GetDC(frm->Handle);  // get device context 
    int i; 
    if (!_used) 
     { 
     int i,_pfid=-1,_zbit=0; 
     PIXELFORMATDESCRIPTOR _pfd; 
     #define pfd_test i=ChoosePixelFormat(hdc,&pfd); DescribePixelFormat(hdc,i,sizeof(_pfd),&_pfd); if (_zbit<_pfd.cDepthBits) { _zbit=_pfd.cDepthBits; _pfid=i; } 
     pfd.cColorBits = 32; pfd.cDepthBits = 32; pfd_test; 
     pfd.cColorBits = 24; pfd.cDepthBits = 32; pfd_test; 
     pfd.cColorBits = 16; pfd.cDepthBits = 32; pfd_test; 
     pfd.cColorBits = 32; pfd.cDepthBits = 24; pfd_test; 
     pfd.cColorBits = 24; pfd.cDepthBits = 24; pfd_test; 
     pfd.cColorBits = 16; pfd.cDepthBits = 24; pfd_test; 
     pfd.cColorBits = 32; pfd.cDepthBits = 16; pfd_test; 
     pfd.cColorBits = 24; pfd.cDepthBits = 16; pfd_test; 
     pfd.cColorBits = 16; pfd.cDepthBits = 16; pfd_test; 
     #undef pfd_test 
     pfd.cDepthBits = _zbit; // iba koli warningu 
     DescribePixelFormat(hdc,_pfid,sizeof(pfd),&pfd); 
     pfid=ChoosePixelFormat(hdc,&pfd); 
     SetPixelFormat(hdc,pfid,&pfd); 
     DescribePixelFormat(hdc,pfid,sizeof(pfd),&pfd); 

     znum=1<<(pfd.cDepthBits-1); 
     } 

    // create current rendering context 
    hrc = wglCreateContext(hdc); 

    if(hrc == NULL) 
     { 
     ShowMessage("Could not initialize OpenGL Rendering context !!!"); 
     _init=0; 
     return 0; 
     } 
    if(wglMakeCurrent(hdc, hrc) == false) 
     { 
     ShowMessage("Could not make current OpenGL Rendering context !!!"); 
     wglDeleteContext(hrc);   // destroy rendering context 
     _init=0; 
     return 0; 
     } 
    if (!_used) glewInit(); 
    _init=1; 
    _used=1; 
    resize(0,0,128,128); 

// glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); 
// glFrontFace(GL_CCW);     // predna strana je proti smeru hod. ruciciek 
// glEnable(GL_CULL_FACE);     // vynechavaj odvratene steny 
// glEnable(GL_TEXTURE_2D);    // pouzivaj textury, farbu pouzivaj z textury 
// glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
// glEnable(GL_BLEND);      // priehladnost 
// glBlendFunc(GL_SRC_ALPHA,GL_DST_ALPHA); 
/* 
    glEnable(GL_LIGHTING); 
    glEnable(GL_LIGHT0); 
    glEnable(GL_COLOR_MATERIAL); 

    GLdouble MaterialAmbient [] = {0.25, 0.25, 0.25, 1.00}; 
    GLdouble MaterialDiffuse [] = {0.25, 0.25, 0.25, 1.00}; 
    GLdouble MaterialSpecular [] = {0.50, 0.50, 0.50, 1.00}; 
    GLdouble MaterialShininess[] = {15.0};     // 0-ufocused, 128 max focus 
    glMaterialfv(GL_FRONT, GL_AMBIENT , MaterialAmbient ); 
    glMaterialfv(GL_FRONT, GL_DIFFUSE , MaterialDiffuse ); 
    glMaterialfv(GL_FRONT, GL_SPECULAR , MaterialSpecular); 
    glMaterialfv(GL_FRONT, GL_SHININESS, MaterialShininess); 
    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); 

    GLdouble LightPosition [] = {0.00, 0.00, 0.00, 0.0}; 
    GLdouble LightAmbient [] = {0.10, 0.10, 0.10, 1.0}; 
    GLdouble LightDiffuse [] = {0.20, 0.20, 0.20, 1.0}; 
    GLdouble LightSpecular [] = {1.00, 1.00, 1.00, 1.0}; 
    glLightfv(GL_LIGHT0,GL_AMBIENT ,LightAmbient); 
    glLightfv(GL_LIGHT0,GL_DIFFUSE ,LightDiffuse); 
    glLightfv(GL_LIGHT0,GL_SPECULAR,LightSpecular); 
    glLightfv(GL_LIGHT0,GL_POSITION,LightPosition); 
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, LightAmbient); 
*/ 
    glEnable(GL_DEPTH_TEST);    // Zbuf 
    glShadeModel(GL_SMOOTH);    // gourard shading 
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // background color 
    glDepthFunc(GL_LEQUAL); 

    const GLubyte *p; char a;    // get extensions list 
    extensions=""; 
    #define ext_add if ((extensions!="")&&(extensions[extensions.Length()]!=' ')) extensions+=' '; for (i=0;;i++) { a=p[i]; if (!a) break; extensions+=a; } 
    p=glGetString(GL_EXTENSIONS); ext_add; 
    if (wglGetExtensionsStringARB) p=wglGetExtensionsStringARB(hdc); ext_add; 
    if (wglGetExtensionsStringEXT) p=wglGetExtensionsStringEXT(); ext_add; 

// int hnd=FileCreate("glext.txt"); FileWrite(hnd,scr.extensions.c_str(),scr.extensions.Length()); FileClose(hnd); 

    OpenGLtexture txr; 
    txrs.alloc(textures);   // allocate textures name space 
    font_init(txr); 
    font=txrs.add(txr); 
    s3dl=txrs.add(txr); txrs.sizes[s3dl]._mode=GL_MODULATE; 
    s3dr=txrs.add(txr); txrs.sizes[s3dr]._mode=GL_MODULATE; 
    return 1; 
    } 
//------------------------------------------------------------------------------ 
void OpenGLscreen::exit() 
    { 
    if (!_init) return; 
    wglMakeCurrent(hdc,hrc);  // use this context if multiple OpenGLs are used 
    txrs.free(); 
    wglMakeCurrent(NULL, NULL);  // release current rendering context 
    wglDeleteContext(hrc);   // destroy rendering context 
    hrc=NULL; 
    _init=0; 
    } 
//------------------------------------------------------------------------------ 

ora alle domande:

01.235.164,106174 millions

1. Sto facendo qualcosa di sbagliato?

   Il motore è completamente funzionante GL, GLSL, VBO, VAO, ... e testato per anni. Comportamento strano è presente solo su Intel. Carte da nVidia funziona bene e ATI/AMD funziona quasi bene (ci sono alcuni problemi, ma sono driver buggy legate come sempre per ATI soprattutto per VBO con gli indici di tutto il resto funziona bene)

2. C'è un modo migliore per avviare/uscire da OpenGL?

3. Come passare correttamente tra diversi contesti di rendering?

   Sto usando wglMakeCurrent(hdc,hrc) per ora ma potrebbe essere mi manca qualcosa o c'è qualche soluzione su Intel per questo.

Answer 1

L'utilizzo del WGL sembra corretto a me (compreso l'uso di wglMakeCurrent), ma io non l'ho usato in un po ', quindi la mia memoria potrebbe essere nebbia (per rispondere Q1 e Q3).

Tuttavia, v'è un modo migliore per inizializzare OpenGL: utilizzare una libreria caricatore, as detailed here. Come dice la wiki, è altamente raccomandato usare una libreria di caricatori piuttosto che tentare di farlo da soli.

Mi piace usare SFML per creare il contesto e la finestra OpenGL, più GLEW (necessario solo per Windows) per configurare le funzioni di contesto nucleo OpenGL. Ho anche avuto successo con glfw, che è buono per caricare OpenGL 3.2+