El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Ús de Buffers

Següent ►
►

En aquest tema, aprendrem sobre els buffers en OpenGL, que són fonamentals per a la renderització eficient de gràfics. Els buffers ens permeten emmagatzemar dades com les coordenades dels vèrtexs, colors, normals, etc., i enviar-les a la GPU per al processament.

Conceptes Clau

  1. Buffers de Vèrtexs (VBOs): Emmagatzemen les dades dels vèrtexs.
  2. Buffers d'Índexs (EBOs o IBOs): Emmagatzemen els índexs dels vèrtexs per a la renderització d'elements.
  3. Buffers de Color: Emmagatzemen les dades de color per als vèrtexs.
  4. Buffers de Profunditat: Emmagatzemen la informació de profunditat per a la prova de profunditat.
  5. Buffers de Plantilla: Emmagatzemen dades per a la prova de plantilla.

  1. Buffers de Vèrtexs (VBOs)

Els VBOs són utilitzats per emmagatzemar les dades dels vèrtexs en la memòria de la GPU. Això permet a la GPU accedir ràpidament a aquestes dades durant la renderització.

Crear un VBO

GLuint VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

Explicació del Codi

  1. glGenBuffers(1, &VBO);: Genera un buffer i emmagatzema l'identificador en VBO.
  2. glBindBuffer(GL_ARRAY_BUFFER, VBO);: Enllaça el buffer com a GL_ARRAY_BUFFER.
  3. glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);: Emmagatzema les dades dels vèrtexs en el buffer.

  1. Buffers d'Índexs (EBOs o IBOs)

Els EBOs són utilitzats per emmagatzemar els índexs dels vèrtexs, permetent la reutilització dels vèrtexs i reduint la quantitat de dades necessàries.

Crear un EBO

GLuint EBO;
glGenBuffers(1, &EBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

Explicació del Codi

  1. glGenBuffers(1, &EBO);: Genera un buffer i emmagatzema l'identificador en EBO.
  2. glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);: Enllaça el buffer com a GL_ELEMENT_ARRAY_BUFFER.
  3. glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);: Emmagatzema les dades dels índexs en el buffer.

  1. Buffers de Color

Els buffers de color emmagatzemen les dades de color per als vèrtexs. Aquests es poden utilitzar per aplicar colors als vèrtexs durant la renderització.

Crear un Buffer de Color

GLuint colorBuffer;
glGenBuffers(1, &colorBuffer);
glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);

Explicació del Codi

  1. glGenBuffers(1, &colorBuffer);: Genera un buffer i emmagatzema l'identificador en colorBuffer.
  2. glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);: Enllaça el buffer com a GL_ARRAY_BUFFER.
  3. glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);: Emmagatzema les dades de color en el buffer.

  1. Buffers de Profunditat

Els buffers de profunditat emmagatzemen la informació de profunditat per a la prova de profunditat, que és utilitzada per determinar quins píxels són visibles en funció de la seva profunditat.

Crear un Buffer de Profunditat

GLuint depthBuffer;
glGenRenderbuffers(1, &depthBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);

Explicació del Codi

  1. glGenRenderbuffers(1, &depthBuffer);: Genera un renderbuffer i emmagatzema l'identificador en depthBuffer.
  2. glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);: Enllaça el renderbuffer com a GL_RENDERBUFFER.
  3. glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);: Defineix l'emmagatzematge del renderbuffer com a component de profunditat.

  1. Buffers de Plantilla

Els buffers de plantilla emmagatzemen dades per a la prova de plantilla, que permeten controlar quins píxels es dibuixen en funció de certs criteris.

Crear un Buffer de Plantilla

GLuint stencilBuffer;
glGenRenderbuffers(1, &stencilBuffer);
glBindRenderbuffer(GL_RENDERBUFFER, stencilBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);

Explicació del Codi

  1. glGenRenderbuffers(1, &stencilBuffer);: Genera un renderbuffer i emmagatzema l'identificador en stencilBuffer.
  2. glBindRenderbuffer(GL_RENDERBUFFER, stencilBuffer);: Enllaça el renderbuffer com a GL_RENDERBUFFER.
  3. glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);: Defineix l'emmagatzematge del renderbuffer com a índex de plantilla.

Exercici Pràctic

Objectiu

Crear un programa OpenGL que dibuixi un triangle utilitzant VBOs i EBOs.

Passos

  1. Inicialitzar OpenGL i crear una finestra.
  2. Definir els vèrtexs i els índexs del triangle.
  3. Crear i enllaçar els VBOs i EBOs.
  4. Escriure i compilar els shaders.
  5. Configurar els atributs dels vèrtexs.
  6. Dibuixar el triangle.

Codi Exemple

// 1. Inicialitzar OpenGL i crear una finestra (utilitzant GLFW i GLEW)
glfwInit();
GLFWwindow* window = glfwCreateWindow(800, 600, "Triangle", NULL, NULL);
glfwMakeContextCurrent(window);
glewInit();

// 2. Definir els vèrtexs i els índexs del triangle
GLfloat vertices[] = {
    0.0f,  0.5f, 0.0f,
   -0.5f, -0.5f, 0.0f,
    0.5f, -0.5f, 0.0f
};

GLuint indices[] = {
    0, 1, 2
};

// 3. Crear i enllaçar els VBOs i EBOs
GLuint VBO, VAO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

// 4. Escriure i compilar els shaders
const char* vertexShaderSource = "#version 330 core\n"
    "layout (location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos, 1.0);\n"
    "}\0";

const char* fragmentShaderSource = "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "   FragColor = vec4(1.0, 0.5, 0.2, 1.0);\n"
    "}\0";

GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);

GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

// 5. Configurar els atributs dels vèrtexs
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

// 6. Dibuixar el triangle
while (!glfwWindowShouldClose(window))
{
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shaderProgram);
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);

    glfwSwapBuffers(window);
    glfwPollEvents();
}

glfwTerminate();

Explicació del Codi

  1. Inicialització: Inicialitza GLFW i GLEW, i crea una finestra.
  2. Definició de Vèrtexs i Índexs: Defineix les coordenades dels vèrtexs i els índexs del triangle.
  3. Creació de Buffers: Crea i enllaça els VBOs i EBOs.
  4. Shaders: Escriu i compila els shaders de vèrtexs i fragments.
  5. Configuració d'Atributs: Configura els atributs dels vèrtexs.
  6. Renderització: Dibuixa el triangle en un bucle fins que es tanqui la finestra.

Conclusió

En aquesta secció, hem après sobre els diferents tipus de buffers en OpenGL i com utilitzar-los per emmagatzemar i gestionar dades de vèrtexs, índexs, colors, profunditat i plantilla. També hem vist un exemple pràctic de com crear un programa OpenGL que dibuixa un triangle utilitzant VBOs i EBOs. Amb aquests coneixements, estem preparats per avançar a tècniques de renderització més complexes.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats