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

Què és OpenGL?

Següent ►
►

Introducció

OpenGL (Open Graphics Library) és una API (Application Programming Interface) estàndard per a la renderització de gràfics 2D i 3D. És àmpliament utilitzada en aplicacions que requereixen gràfics d'alt rendiment, com ara videojocs, simuladors, aplicacions de realitat virtual i aplicacions científiques.

Conceptes Clau

  1. API Gràfica

OpenGL proporciona una interfície de programació que permet als desenvolupadors interactuar amb el maquinari gràfic de manera eficient. Això inclou funcions per a la creació de formes, aplicació de textures, il·luminació, i molt més.

  1. Plataforma Independent

Una de les característiques més importants d'OpenGL és la seva independència de la plataforma. Això significa que el codi escrit amb OpenGL pot ser executat en diferents sistemes operatius, com Windows, macOS, Linux, i altres.

  1. Estàndard Industrial

OpenGL és mantingut per l'OpenGL Architecture Review Board (ARB), que és un consorci de diverses empreses tecnològiques. Això assegura que OpenGL segueixi sent un estàndard industrial robust i actualitzat.

Història d'OpenGL

OpenGL va ser desenvolupat originalment per Silicon Graphics Inc. (SGI) a principis dels anys 90. Des de llavors, ha evolucionat significativament, amb múltiples versions que han afegit noves funcionalitats i millores de rendiment.

Components Principals d'OpenGL

  1. Context d'OpenGL

El context d'OpenGL és un entorn que conté tots els estats necessaris per a la renderització. Això inclou informació sobre les textures, els buffers, els shaders, i altres recursos.

  1. Shaders

Els shaders són petits programes que s'executen en la GPU (Unitat de Processament Gràfic) per a realitzar operacions de renderització. Els tipus principals de shaders són:

  • Vertex Shaders: Processen cada vèrtex individualment.
  • Fragment Shaders: Processen cada fragment (potencial píxel) individualment.

  1. Buffers

Els buffers són àrees de memòria que emmagatzemen dades com vèrtexs, colors, i textures. Els tipus principals de buffers són:

  • Vertex Buffer Objects (VBOs): Emmagatzemen dades de vèrtexs.
  • Element Buffer Objects (EBOs): Emmagatzemen índexs de vèrtexs per a dibuixar elements complexos.

Exemple Pràctic

A continuació, es mostra un exemple simple de codi OpenGL que inicialitza un context i dibuixa un triangle:

#include <GL/glew.h>
#include <GLFW/glfw3.h>

// Vertex Shader source code
const char* vertexShaderSource = R"(
#version 330 core
layout (location = 0) in vec3 aPos;
void main() {
    gl_Position = vec4(aPos, 1.0);
}
)";

// Fragment Shader source code
const char* fragmentShaderSource = R"(
#version 330 core
out vec4 FragColor;
void main() {
    FragColor = vec4(1.0, 0.5, 0.2, 1.0);
}
)";

int main() {
    // Inicialitzar GLFW
    if (!glfwInit()) {
        return -1;
    }

    // Crear una finestra GLFW
    GLFWwindow* window = glfwCreateWindow(800, 600, "Hello OpenGL", NULL, NULL);
    if (!window) {
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    // Inicialitzar GLEW
    if (glewInit() != GLEW_OK) {
        return -1;
    }

    // Compilar Vertex Shader
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);

    // Compilar Fragment Shader
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);

    // Crear Shader Program
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);

    // Esborrar shaders compilats
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // Dades del triangle
    float vertices[] = {
        -0.5f, -0.5f, 0.0f,
         0.5f, -0.5f, 0.0f,
         0.0f,  0.5f, 0.0f
    };

    // Crear Vertex Buffer Object (VBO)
    GLuint VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // Crear Vertex Array Object (VAO)
    GLuint VAO;
    glGenVertexArrays(1, &VAO);
    glBindVertexArray(VAO);

    // Enllaçar VBO a VAO
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    // Bucle de renderització
    while (!glfwWindowShouldClose(window)) {
        // Esborrar el buffer de color
        glClear(GL_COLOR_BUFFER_BIT);

        // Utilitzar el shader program
        glUseProgram(shaderProgram);

        // Dibuixar el triangle
        glBindVertexArray(VAO);
        glDrawArrays(GL_TRIANGLES, 0, 3);

        // Intercanviar buffers
        glfwSwapBuffers(window);

        // Processar esdeveniments
        glfwPollEvents();
    }

    // Alliberar recursos
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shaderProgram);

    // Terminar GLFW
    glfwTerminate();
    return 0;
}

Explicació del Codi

  1. Inicialització de GLFW i GLEW: Es comença inicialitzant les biblioteques GLFW i GLEW, que són necessàries per a crear una finestra i gestionar el context d'OpenGL.
  2. Shaders: Es defineixen i compilen els shaders de vèrtex i fragment.
  3. Shader Program: Es crea un programa de shaders i s'enllacen els shaders compilats.
  4. Buffers: Es defineixen les dades del triangle i es creen els buffers necessaris per a emmagatzemar aquestes dades.
  5. Renderització: En el bucle principal, es neteja el buffer de color, s'utilitza el programa de shaders, i es dibuixa el triangle.

Conclusió

En aquesta secció, hem après què és OpenGL, la seva història, els components principals, i hem vist un exemple pràctic de com crear un programa simple que dibuixa un triangle. Aquestes bases ens preparen per a aprofundir en temes més avançats en els següents mòduls del curs.

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