OpenGL antialiasing sans le tampon d'accumulation

Sur une carte NVIDIA, je peux effectuer en pleine scène de l'anti-aliasing en utilisant le tampon d'accumulation quelque chose comme ceci:

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);
}

Sur les cartes ATI le tampon d'accumulation n'est pas mis en œuvre, et tout le monde dit que vous pouvez le faire dans le langage de shader maintenant. Le problème avec ça, bien sûr, c'est que GLSL est plutôt une haute barrière à l'entrée pour un OpenGL débutant.

Quelqu'un peut-il m'indiquer quelque chose qui va me montrer comment faire toute la scène de l'anti-aliasing dans une manière que les cartes ATI peut faire, et qu'un débutant peut comprendre?

InformationsquelleAutor K. Brafford | 2012-05-09
  1. 14

    Pourquoi voudriez-vous jamais faire l'antialiasing de cette façon, indépendamment de savoir si vous avez l'accumulation des tampons ou pas? Utilisez simplement multisampling; il n'est pas libre, mais il est beaucoup moins cher que ce que vous faites.

    Tout d'abord, vous devez créer un contexte, avec une multisampled tampon. Cela signifie que vous devez utiliser WGL/GLX_ARB_multisample, ce qui signifie que sur Windows, vous devez faire deux étapes de création du contexte. Vous devriez demander un format de pixel avec 1 *_SAMPLE_BUFFERS_ARB et certains nombre de *_SAMPLES_ARB. Plus le nombre d'échantillons, le mieux l'anticrénelage (qui est aussi le plus lent). Vous pouvez obtenir le nombre maximum d'échantillons avec wglGetPixelFormatAttribfv ou glXGetConfig.

    Une fois que vous avez créé avec succès un contexte avec un multi-échantillons framebuffer, vous rendre comme d'habitude, à une exception près: appel glEnable(GL_MULTISAMPLE) dans votre code d'installation. Cela permettra d'activer multisampled rendu.

    Et c'est tout ce dont vous avez besoin.

    Alternativement, si vous utilisez GL 3.x ou avoir accès à ARB_framebuffer_object, vous pouvez ignorer le contexte de trucs et de créer un multisampled framebuffer. Votre tampon de profondeur et tampon de couleur(s) doivent toutes avoir le même nombre d'échantillons. Je dirais à l'aide de renderbuffers pour ceux-ci, puisque vous êtes toujours à l'aide de fonction fixes (et vous ne pouvez pas la texture d'un multi-échantillons de texture dans le fixe en fonction de pipeline).

    Vous créez multisampled renderbuffers de la couleur et de la profondeur (ils doivent avoir le même nombre d'échantillons). Vous les mettez dans un FBO, et de rendre à l'intérieur (avec glEnable(GL_MULTISAMPLE), bien sûr). Lorsque vous avez terminé, vous pouvez alors l'utiliser glBlitFramebuffer blit à partir de votre multi-échantillons framebuffer dans le back-buffer (qui ne devrait pas être multisampled).

    Le problème avec ça, bien sûr, c'est que GLSL est plutôt une haute barrière à l'entrée pour un OpenGL débutant.

    Dit qui? Il n'y a rien de mal avec un débutant l'apprentissage de shaders. En effet, dans mon expérience, tels les débutants apprennent souvent mieux, parce qu'ils comprennent les détails de ce qui se passe de manière plus efficace.

    • "Pourquoi voudriez-vous jamais faire l'antialiasing de cette façon," C'est une technique très ancienne de OpenGL redbook la version 1. À en juger par les performances de l'accumulation de la mémoire tampon je soupçonne le tout est entièrement non-accéléré - même sur nvidia. Je pense que redbook aussi eu de la "profondeur de champ" ou un effet similaire mis en œuvre en utilisant le tampon d'accumulation ainsi...
    • "Sinon, si vous utilisez GL 3.x ou avoir accès à ARB_framebuffer_object, vous pouvez ignorer le contexte de trucs et de créer un multisampled framebuffer." Ou EXT_framebuffer_multisample.
    • "Pourquoi ..." je n'avais aucune idée que c'était une horrible façon de faire le travail. Il est possible que je viens à ce à partir d'un point de vue rare, mais je doute que je suis unique. Je n'étais pas particulièrement intéressé par GL choses jusqu'à ce que la CL/CUDA est venu le long. Avec partagé GL/CL contextes, la possibilité de faire calculer les opérations sur les tableaux, puis les ont traités comme des vertex buffer objects ou des textures telles que vous pouvez en fait avoir une représentation visuelle de votre haute vitesse des calculs à la volée n'est rien de moins étonnant.
    • Lorsque vous êtes à l'aide de GLUT pour le contexte de la création, vous avez juste besoin d'ajouter GLUT_MULTISAMPLE à votre appel à glutInitDisplayMode.
    • Si à l'aide de SDL pour le contexte de création, de l'utilisation SDL_GL_SetAttribute pour définir SDL_GL_MULTISAMPLEBUFFERS à 1 et SDL_GL_MULTISAMPLESAMPLES à une valeur supérieure à 0, à la fois avant la création de la fenêtre.
    • Re: "Pourquoi voudriez-vous jamais faire l'antialiasing de cette façon" - parce que le multisampling n'est pas pris en charge sur certaines cartes graphiques et les pilotes - voir le rapport de bug: github.com/opentoonz/opentoonz/issues/... - bien que la situation s'améliore.

    InformationsquelleAutor Nicol Bolas