Que signifie "mode immédiat" dans OpenGL?
Qu'est-ce que le "mode immédiat"? Donnez un exemple de code.
Quand dois-je utiliser le mode immédiat au lieu du mode conservé? Quels sont les avantages et les inconvénients de l'utilisation de chaque méthode?
Un exemple de "mode immédiat" utilise glBegin et glEnd avec glVertex entre eux. Un autre exemple de "mode immédiat" consiste à utiliser glDrawArrays avec un tableau de sommets client (c'est-à-dire pas un objet tampon de sommets).
Vous ne voudrez généralement jamais utiliser le mode immédiat (sauf peut-être pour votre premier programme "hello world") car il est obsolète et n'offre pas de performances optimales.
La raison pour laquelle le mode immédiat n'est pas optimal est que la carte graphique est directement liée au flux de votre programme. Le pilote ne peut pas dire au GPU de démarrer le rendu avant glEnd, car il ne sait pas quand vous aurez fini de soumettre les données, et il doit également transférer ces données (ce qu'il peut seulement après glEnd).
De même, avec un tableau de sommets client, le pilote ne peut extraire une copie de votre tableau qu'au moment où vous appelez glDrawArrays, et il doit bloquer votre application. La raison en est que sinon vous pourriez modifier (ou libérer) la mémoire de la baie avant que le pilote ne l'ait capturée. Il ne peut pas planifier cette opération plus tôt ou plus tard, car il sait seulement que les données sont valides exactement à un moment donné.
Contrairement à cela, si vous utilisez par exemple un objet tampon de sommet, vous remplissez un tampon de données et le remettez à OpenGL. Votre processus ne possède plus ces données et ne peut donc plus les modifier. Le conducteur peut compter sur ce fait et peut (même de manière spéculative) télécharger les données chaque fois que le bus est libre.
N'importe lequel de vos appels glDrawArrays ou glDrawElements ultérieurs ira simplement dans une file d'attente de travail et reviendra immédiatement (avant de terminer!). en même temps, le conducteur travaille un par un. Ils n'auront probablement pas non plus besoin d'attendre que les données arrivent, car le conducteur pourrait déjà le faire beaucoup plus tôt.
Ainsi, le thread de rendu et le GPU s'exécutent de manière asynchrone, chaque composant est occupé à tout moment, ce qui donne de meilleures performances.
Le mode immédiat a l'avantage d'être très simple à utiliser, mais encore une fois, utiliser OpenGL correctement de manière non obsolète n'est pas non plus précisément la science des fusées - cela ne prend que très peu de travail supplémentaire.
Voici le code OpenGL "Hello World" typique en mode immédiat:
glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(0.0f, 1.0f);
glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(0.87f, -0.5f);
glColor3f(0.0f, 0.0f, 1.0f); glVertex2f(-0.87f, -0.5f);
glEnd();
Modifier:
À la demande commune, la même chose en mode conservé ressemblerait un peu à ceci:
float verts = {...};
float colors = {...};
static_assert(sizeof(verts) == sizeof(colors), "");
// not really needed for this example, but mandatory in core profile after GL 3.2
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLuint buf[2];
glGenBuffers(2, buf);
// assuming a layout(location = 0) for position and
// layout(location = 1) for color in the vertex shader
// vertex positions
glBindBuffer(GL_ARRAY_BUFFER, buf[0]);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
// copy/paste for color... same code as above. A real, non-trivial program would
// normally use a single buffer for both -- usually with stride (5th param) to
// glVertexAttribPointer -- that presumes interleaving the verts and colors arrays.
// It's somewhat uglier but has better cache performance (ugly does however not
// matter for a real program, since data is loaded from a modelling-tool generated
// binary file anyway).
glBindBuffer(GL_ARRAY_BUFFER, buf[1]);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
Exemple conservé exécutable
Damon a fourni les éléments clés, mais les newbs comme moi chercheront un exemple exécutable complet.
#include <stdio.h>
#include <stdlib.h>
#define GLEW_STATIC
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#define INFOLOG_LEN 512
static const GLuint WIDTH = 800, HEIGHT = 600;
/* vertex data is passed as input to this shader
* ourColor is passed as input to the to the fragment shader.
*/
static const GLchar* vertexShaderSource =
"#version 330 core\n"
"layout (location = 0) in vec3 position;\n"
"layout (location = 1) in vec3 color;\n"
"out vec3 ourColor;\n"
"void main() {\n"
" gl_Position = vec4(position, 1.0f);\n"
" ourColor = color;\n"
"}\n";
static const GLchar* fragmentShaderSource =
"#version 330 core\n"
"in vec3 ourColor;\n"
"out vec4 color;\n"
"void main() {\n"
" color = vec4(ourColor, 1.0f);\n"
"}\n";
GLfloat vertices[] = {
/* Positions Colors */
0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f
};
int main(void) {
glfwInit();
GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, __FILE__, NULL, NULL);
glfwMakeContextCurrent(window);
glewExperimental = GL_TRUE;
glewInit();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glViewport(0, 0, WIDTH, HEIGHT);
/* Build and compile shader program. */
/* Vertex shader */
GLint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);
GLint success;
GLchar infoLog[INFOLOG_LEN];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(vertexShader, INFOLOG_LEN, NULL, infoLog);
printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n%s\n", infoLog);
}
/* Fragment shader */
GLint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(fragmentShader, INFOLOG_LEN, NULL, infoLog);
printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n%s\n", infoLog);
}
/* Link shaders */
GLint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, INFOLOG_LEN, NULL, infoLog);
printf("ERROR::SHADER::PROGRAM::LINKING_FAILED\n%s\n", infoLog);
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
GLuint vbo, vao;
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
/* Position attribute */
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
/* Color attribute */
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glBindVertexArray(0);
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shaderProgram);
glBindVertexArray(vao);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &vbo);
glfwTerminate();
return EXIT_SUCCESS;
}
Sur Ubuntu 18.10:
Sudo apt-get install libglew-dev libglfw3-dev
gcc main.c -lGL -lGLEW -lglfw
"Équivalent" immédiat:
glBegin(GL_TRIANGLES);
glColor3f(1.0f, 0.0f, 0.0f);
glVertex3f(0.5f, -0.5.0f, 0.0f);
glColor3f(0.0f, 1.0f, 0.0f);
glVertex3f(-0.5f, -0.5f, 0.0f);
glColor3f(0.0f, 0.0f, 1.0f);
glVertex3f(0.0f, 0.5f, 0.0f);
glEnd();
Cet exemple est adapté de ici .
La plupart des didacticiels OpenGL "modernes" conservent normalement le mode et GLFW, vous trouverez de nombreux exemples sur: