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

Prova de Profunditat i Prova de Plantilla

Següent ►
►

En aquest tema, explorarem dues tècniques fonamentals per a la renderització en 3D: la prova de profunditat (depth testing) i la prova de plantilla (stencil testing). Aquestes tècniques ens permeten controlar com es dibuixen els píxels en funció de la seva profunditat i altres criteris, millorant així la qualitat visual i la complexitat de les escenes renderitzades.

  1. Prova de Profunditat (Depth Testing)

Què és la Prova de Profunditat?

La prova de profunditat és una tècnica que permet determinar si un píxel ha de ser dibuixat en funció de la seva profunditat en l'escena. Això és crucial per assegurar que els objectes més propers a la càmera ocultin els objectes més llunyans, creant una sensació de profunditat realista.

Com Funciona?

  1. Buffer de Profunditat (Depth Buffer): És una àrea de memòria que emmagatzema la profunditat de cada píxel renderitzat.
  2. Comparació de Profunditat: Quan es dibuixa un nou píxel, la seva profunditat es compara amb la profunditat emmagatzemada en el buffer de profunditat.
  3. Actualització del Buffer: Si el nou píxel és més proper que el valor emmagatzemat, es dibuixa i s'actualitza el buffer de profunditat. Si no, es descarta.

Configuració en OpenGL

Per habilitar la prova de profunditat en OpenGL, seguim aquests passos:

// Habilitar la prova de profunditat
glEnable(GL_DEPTH_TEST);

// Configurar la funció de comparació de profunditat
glDepthFunc(GL_LESS);

Exemple Pràctic

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

void initOpenGL() {
    // Habilitar la prova de profunditat
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
}

void renderScene() {
    // Netejar el buffer de color i profunditat
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Dibuixar objectes aquí
    // ...
}

int main() {
    // Inicialitzar GLFW i crear una finestra
    if (!glfwInit()) return -1;
    GLFWwindow* window = glfwCreateWindow(800, 600, "Prova de Profunditat", NULL, NULL);
    if (!window) {
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glewInit();

    // Inicialitzar OpenGL
    initOpenGL();

    // Bucle de renderització
    while (!glfwWindowShouldClose(window)) {
        renderScene();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}

  1. Prova de Plantilla (Stencil Testing)

Què és la Prova de Plantilla?

La prova de plantilla és una tècnica que permet controlar quins píxels es dibuixen en funció de valors emmagatzemats en un buffer de plantilla. Això és útil per crear efectes complexos com miralls, ombres i retallades.

Com Funciona?

  1. Buffer de Plantilla (Stencil Buffer): És una àrea de memòria que emmagatzema valors de plantilla per a cada píxel.
  2. Operacions de Plantilla: Quan es dibuixa un píxel, es realitzen operacions de plantilla que poden modificar el buffer de plantilla o decidir si el píxel es dibuixa.

Configuració en OpenGL

Per habilitar la prova de plantilla en OpenGL, seguim aquests passos:

// Habilitar la prova de plantilla
glEnable(GL_STENCIL_TEST);

// Configurar la funció de comparació de plantilla
glStencilFunc(GL_EQUAL, 1, 0xFF);

// Configurar les operacions de plantilla
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

Exemple Pràctic

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

void initOpenGL() {
    // Habilitar la prova de plantilla
    glEnable(GL_STENCIL_TEST);
    glStencilFunc(GL_EQUAL, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
}

void renderScene() {
    // Netejar el buffer de color, profunditat i plantilla
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

    // Configurar la plantilla per al primer objecte
    glStencilFunc(GL_ALWAYS, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

    // Dibuixar el primer objecte
    // ...

    // Configurar la plantilla per al segon objecte
    glStencilFunc(GL_EQUAL, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

    // Dibuixar el segon objecte
    // ...
}

int main() {
    // Inicialitzar GLFW i crear una finestra
    if (!glfwInit()) return -1;
    GLFWwindow* window = glfwCreateWindow(800, 600, "Prova de Plantilla", NULL, NULL);
    if (!window) {
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glewInit();

    // Inicialitzar OpenGL
    initOpenGL();

    // Bucle de renderització
    while (!glfwWindowShouldClose(window)) {
        renderScene();
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}

Exercicis Pràctics

Exercici 1: Implementar la Prova de Profunditat

  1. Crea un programa que dibuixi dos cubs, un davant de l'altre.
  2. Habilita la prova de profunditat per assegurar que el cub més proper oculti el cub més llunyà.

Exercici 2: Implementar la Prova de Plantilla

  1. Crea un programa que dibuixi un rectangle en una àrea específica de la pantalla.
  2. Utilitza la prova de plantilla per dibuixar un segon rectangle només dins de l'àrea del primer rectangle.

Solucions

Solució a l'Exercici 1

// Codi per a l'exercici 1

Solució a l'Exercici 2

// Codi per a l'exercici 2

Conclusió

La prova de profunditat i la prova de plantilla són tècniques essencials per a la renderització avançada en OpenGL. La prova de profunditat assegura que els objectes es dibuixin correctament en funció de la seva distància a la càmera, mentre que la prova de plantilla permet crear efectes visuals complexos. Amb aquestes tècniques, podem millorar significativament la qualitat i la complexitat de les nostres escenes 3D.

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