Comment rendre offscreen sur OpenGL? [dupliquer]

tout commence par glReadPixels , que vous utiliserez pour transférer les pixels stockés dans un tampon spécifique sur le GPU vers la mémoire principale (RAM). Comme vous le remarquerez dans la documentation, il n'existe aucun argument pour choisir tampon. Comme D'habitude avec OpenGL, le tampon courant à lire est un État, que vous pouvez définir avec glReadBuffer .

donc une méthode très basique de rendu hors écran serait quelque chose comme ce qui suit. J'utilise c++ pseudo-code donc il contiendra probablement des erreurs, mais devrait rendre le flux général clair:

//Before swapping
std::vector<std::uint8_t> data(width*height*4);
glReadBuffer(GL_BACK);
glReadPixels(0,0,width,height,GL_BGRA,GL_UNSIGNED_BYTE,&data[0]);

cela Lira le tampon de retour courant (habituellement le tampon vers lequel vous dessinez). Vous devriez l'appeler avant de changer les tampons. Notez que vous pouvez également lire parfaitement le tampon arrière avec la méthode ci-dessus, le vider et dessiner quelque chose de totalement différent avant de l'échanger. Techniquement, vous pouvez aussi lire le tampon frontal, mais cela est souvent déconseillé en théorie. les implémentations ont été autorisées à faire certaines optimisations qui pourraient rendre votre tampon frontal inutile.

il y a quelques inconvénients à cela. Tout d'abord, nous ne faisons pas vraiment de rendu offscreen, n'est-ce pas? Nous rendons aux tampons d'écran et lisons à partir de ceux-ci. Nous pouvons émuler le rendu offscreen en ne changeant jamais le tampon arrière, mais cela ne semble pas juste. Ensuite, les tampons avant et arrière sont optimisés pour afficher les pixels, pas pour les relire. C'est là Framebuffer Objets entrent en jeu.

essentiellement, un FBO vous permet de créer un framebuffer non par défaut (comme les buffers avant et arrière) qui vous permet de tirer sur un tampon mémoire au lieu des buffers écran. En pratique, vous pouvez dessiner sur une texture ou sur un renderbuffer . La première est optimale lorsque vous voulez réutiliser les pixels dans OpenGL lui-même comme une texture (par exemple une naïve "caméra de sécurité" dans un jeu), la seconde si vous voulez juste pour rendre/lecture en arrière. Avec cela le code ci-dessus deviendrait quelque chose comme ceci, encore une fois le pseudo-code, alors ne me tuez pas si mal écrit ou oublié quelques déclarations.

//Somewhere at initialization
GLuint fbo, render_buf;
glGenFramebuffers(1,&fbo);
glGenRenderbuffers(1,&render_buf);
glBindRenderbuffer(render_buf);
glRenderbufferStorage(GL_RENDERBUFFER, GL_BGRA8, width, height);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER​,fbo);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, render_buf);

//At deinit:
glDeleteFramebuffers(1,&fbo);
glDeleteRenderbuffers(1,&render_buf);

//Before drawing
glBindFramebuffer(GL_DRAW_FRAMEBUFFER​,fbo);
//after drawing
std::vector<std::uint8_t> data(width*height*4);
glReadBuffer(GL_COLOR_ATTACHMENT0);
glReadPixels(0,0,width,height,GL_BGRA,GL_UNSIGNED_BYTE,&data[0]);
// Return to onscreen rendering:
glBindFramebuffer(GL_DRAW_FRAMEBUFFER​,0);

ceci est un exemple simple, en réalité vous voulez probablement aussi du stockage pour le tampon de profondeur (et de pochoir). Vous pourriez aussi vouloir rendre à la texture, mais je vais laisser cela comme un exercice. Dans tous les cas, vous allez maintenant effectuer un rendu réel hors écran et il pourrait fonctionner plus rapidement que la lecture de la tampon d'arrière-plan.

enfin, vous pouvez utiliser pixel buffer objects pour rendre les pixels de lecture asynchrones. Le problème est que glReadPixels bloque jusqu'à ce que les données du pixel soient complètement transférées, ce qui peut retarder votre CPU. Avec PBO, l'implémentation peut revenir immédiatement car elle contrôle de toute façon le buffer. Ce n'est que lorsque vous cartographiez la zone tampon que le pipeline bloquera. Cependant, PBO peut être optimisé pour amortir les données uniquement sur la RAM, de sorte que ce bloc pourrait prendre beaucoup moins de temps. Le code de pixels lu deviendra quelque chose comme ceci:

//Init:
GLuint pbo;
glGenBuffers(1,&pbo);
glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo);
glBufferData(GL_PIXEL_PACK_BUFFER, width*height*4, NULL, GL_DYNAMIC_READ);

//Deinit:
glDeleteBuffers(1,&pbo);

//Reading:
glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo);
glReadPixels(0,0,width,height,GL_BGRA,GL_UNSIGNED_BYTE,0); // 0 instead of a pointer, it is now an offset in the buffer.
//DO SOME OTHER STUFF (otherwise this is a waste of your time)
glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo); //Might not be necessary...
pixel_data = glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);

la partie en capuchons est essentielle. Si vous envoyez juste un glReadPixels à un PBO, suivi d'un glMapBuffer de ce PBO, vous n'avez rien gagné sauf beaucoup de code. Bien sûr le glReadPixels pourrait revenir immédiatement, mais maintenant le glMapBuffer va décrocher parce qu'il doit en toute sécurité mapper les données de la zone de lecture au PBO et à un bloc de mémoire dans la RAM principale.

S'il vous plaît noter également que J'utilise GL_BGRA partout, c'est parce que de nombreuses cartes graphiques utilisent en interne ce format comme format de rendu optimal (ou la version GL_BGR sans alpha). Il devrait être le format le plus rapide pour les transferts de pixels comme celui-ci. Je vais essayer de trouver l'article de nvidia que j'ai lu il y a quelques mois.

lorsque vous utilisez OpenGLES 2.0, GL_DRAW_FRAMEBUFFER peut ne pas être disponible, vous devez simplement utiliser GL_FRAMEBUFFER dans ce cas.