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

Shaders de Geometria

Següent ►
►

Els shaders de geometria són una part avançada del pipeline de renderització d'OpenGL que permeten manipular la geometria dels objectes abans de la fase de rasterització. Aquests shaders poden generar nous vèrtexs, modificar els existents o eliminar-los, oferint una gran flexibilitat per a efectes visuals complexos.

Què és un Shader de Geometria?

Un shader de geometria és un tipus de shader que s'executa després del vertex shader i abans del fragment shader. Permet processar primitives (punts, línies, triangles) i generar noves primitives a partir d'elles.

Característiques Clau:

  • Entrada: Primitives generades pel vertex shader.
  • Sortida: Noves primitives que poden ser punts, línies o triangles.
  • Flexibilitat: Pot generar més d'una primitiva per cada primitiva d'entrada.

Configuració del Shader de Geometria

  1. Escriure el Shader de Geometria

A continuació es mostra un exemple bàsic d'un shader de geometria que converteix cada triangle en un triangle més gran:

#version 330 core
layout(triangles) in;
layout(triangle_strip, max_vertices = 3) out;

void main() {
    for (int i = 0; i < 3; i++) {
        gl_Position = gl_in[i].gl_Position * 1.5; // Escalar el triangle
        EmitVertex();
    }
    EndPrimitive();
}

  1. Compilar i Enllaçar el Shader

Per utilitzar el shader de geometria, cal compilar-lo i enllaçar-lo amb els altres shaders (vertex i fragment shaders):

GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLuint geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

// Compilar els shaders (codi no mostrat per simplicitat)
glCompileShader(vertexShader);
glCompileShader(geometryShader);
glCompileShader(fragmentShader);

// Crear el programa i enllaçar els shaders
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, geometryShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

// Usar el programa de shaders
glUseProgram(shaderProgram);

Exemples Pràctics

Exemple 1: Generar una Línia per Cada Triangle

Aquest shader de geometria genera una línia per cada triangle d'entrada, útil per a efectes de contorn:

#version 330 core
layout(triangles) in;
layout(line_strip, max_vertices = 6) out;

void main() {
    for (int i = 0; i < 3; i++) {
        gl_Position = gl_in[i].gl_Position;
        EmitVertex();
        gl_Position = gl_in[(i + 1) % 3].gl_Position;
        EmitVertex();
        EndPrimitive();
    }
}

Exemple 2: Generar un Quad per Cada Triangle

Aquest shader de geometria genera un quad (quadrat) per cada triangle d'entrada, duplicant els vèrtexs:

#version 330 core
layout(triangles) in;
layout(triangle_strip, max_vertices = 6) out;

void main() {
    for (int i = 0; i < 3; i++) {
        gl_Position = gl_in[i].gl_Position;
        EmitVertex();
        gl_Position = gl_in[(i + 1) % 3].gl_Position;
        EmitVertex();
    }
    EndPrimitive();
}

Exercicis Pràctics

Exercici 1: Crear un Shader de Geometria que Generi un Cub

Descripció: Escriu un shader de geometria que prengui un punt com a entrada i generi un cub al voltant d'aquest punt.

Pistes:

  • Utilitza layout(points) in; per a l'entrada.
  • Utilitza layout(triangle_strip, max_vertices = 36) out; per a la sortida.
  • Genera 12 triangles (36 vèrtexs) per formar el cub.

Solució:

#version 330 core
layout(points) in;
layout(triangle_strip, max_vertices = 36) out;

void main() {
    vec4 offset[8] = vec4[](
        vec4(-1.0, -1.0, -1.0, 1.0),
        vec4( 1.0, -1.0, -1.0, 1.0),
        vec4( 1.0,  1.0, -1.0, 1.0),
        vec4(-1.0,  1.0, -1.0, 1.0),
        vec4(-1.0, -1.0,  1.0, 1.0),
        vec4( 1.0, -1.0,  1.0, 1.0),
        vec4( 1.0,  1.0,  1.0, 1.0),
        vec4(-1.0,  1.0,  1.0, 1.0)
    );

    int indices[36] = int[](
        0, 1, 2, 2, 3, 0, // Front face
        4, 5, 6, 6, 7, 4, // Back face
        0, 1, 5, 5, 4, 0, // Bottom face
        2, 3, 7, 7, 6, 2, // Top face
        0, 3, 7, 7, 4, 0, // Left face
        1, 2, 6, 6, 5, 1  // Right face
    );

    for (int i = 0; i < 36; i++) {
        gl_Position = gl_in[0].gl_Position + offset[indices[i]];
        EmitVertex();
    }
    EndPrimitive();
}

Errors Comuns i Consells

Errors Comuns:

  • No definir correctament els layouts d'entrada i sortida: Assegura't que els layouts coincideixin amb les primitives que estàs processant.
  • No cridar EmitVertex() i EndPrimitive(): Aquests són necessaris per a cada vèrtex i primitiva generada.
  • Superar el nombre màxim de vèrtexs: Assegura't que max_vertices sigui suficient per a les primitives que vols generar.

Consells:

  • Experimenta amb diferents tipus de primitives: Prova de generar punts, línies i triangles per veure com afecten la sortida.
  • Utilitza variables uniform per passar dades al shader de geometria: Això et permetrà controlar el comportament del shader des del codi de l'aplicació.

Conclusió

Els shaders de geometria ofereixen una gran flexibilitat per a la manipulació de la geometria en temps real. Amb ells, pots crear efectes visuals complexos i optimitzar la renderització de la teva aplicació. Practica amb els exemples i exercicis proporcionats per dominar aquesta poderosa eina d'OpenGL.

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