antialiasing OpenGL senza il buffer di accumulo

Question

su una scheda NVIDIA posso eseguire piena Scene Antialiasing utilizzando il buffer di accumulo qualcosa di simile:

if(m_antialias) 
{ 
    glClear(GL_ACCUM_BUFFER_BIT); 
    for(int j = 0; j < antialiasing; j++) 
    { 
     accPerspective(m_camera.FieldOfView(), // Vertical field of view in degrees. 
      aspectratio, // The aspect ratio. 
      20., // Near clipping 
      1000., 
      JITTER[antialiasing][j].X(), JITTER[antialiasing][j].Y(), 
      0.0, 0.0, 1.0); 

     m_camera.gluLookAt(); 

     ActualDraw(); 

     glAccum(GL_ACCUM, float(1.0/antialiasing)); 

     glDrawBuffer(GL_FRONT); 
     glAccum(GL_RETURN, float(antialiasing)/(j + 1)); 
     glDrawBuffer(GL_BACK); 
    } 

    glAccum(GL_RETURN, 1.0); 
} 

Sulla schede ATI il buffer di accumulo non è implementata, e tutti dicono che puoi farlo ora in linguaggio shader. Il problema con questo, ovviamente, è che il GLSL è una barriera piuttosto alta per l'ingresso per un principiante OpenGL.

Qualcuno può indicarmi qualcosa che mi mostrerà come fare l'anti-aliasing in tutta la scena in un modo che le schede ATI possono fare e che un principiante può capire?

Answer 1

Perché dovresti mai fare l'antialiasing in questo modo, indipendentemente dal fatto che tu abbia o meno buffer di accumulo? Basta usare multisampling; non è gratuito, ma è molto più economico di quello che stai facendo.

Prima di tutto, è necessario creare un contesto con un buffer multicampionato. Ciò significa che è necessario utilizzare WGL/GLX_ARB_multisample, il che significa che su Windows, è necessario fare two-stage context creation. È necessario richiedere un formato pixel con 1 *_SAMPLE_BUFFERS_ARB e un numero di *_SAMPLES_ARB. Maggiore è il numero di campioni, migliore è l'antialiasing (anche il più lento). È possibile ottenere il numero massimo di campioni con wglGetPixelFormatAttribfv o glXGetConfig.

Dopo aver creato correttamente un contesto con un framebuffer multisample, il rendering viene eseguito normalmente, con una eccezione: chiamare glEnable(GL_MULTISAMPLE) nel codice di configurazione. Questo attiverà il rendering multicampionato.

E questo è tutto ciò che serve.

In alternativa, se si utilizza GL 3.x o si ha accesso a ARB_framebuffer_object, è possibile saltare il contesto e creare un framebuffer a campionamento multiplo. Il tuo depth buffer e il/i color buffer devono avere tutti lo stesso numero di campioni. Vorrei suggerire per questi, dal momento che stai ancora usando la funzione fissa (e non puoi tessere da una trama di multisample nella pipeline a funzione fissa).

Si creano buffer di rendering multisampling per colore e profondità (devono avere lo stesso numero di campioni). Li si imposta in un FBO e si esegue il rendering su di essi (con glEnable(GL_MULTISAMPLE), ovviamente). Quando hai finito, puoi usare glBlitFramebuffer per blittare dal framebuffer multisample nel buffer posteriore (che non dovrebbe essere multisampling).

Il problema con questo, ovviamente, è che GLSL è una barriera piuttosto alta per l'ingresso per un principiante OpenGL.

Dice chi? Non c'è niente di sbagliato in un principiante che apprende dagli shader. Infatti, nella mia esperienza, questi principianti spesso imparano meglio, perché capiscono i dettagli di ciò che sta accadendo in modo più efficace.