library - opengl intel

glLineStipple en desuso en OpenGL 3.1

Question

glLineStipple ha quedado en desuso en las últimas API de OpenGL. ¿Con qué se reemplaza? Si no se reemplaza, ¿cómo puedo obtener un efecto similar? (No quiero usar un perfil de compatibilidad, por supuesto ...)

Answer 1

Lo sentimos, no ha sido reemplazado con nada. La primera idea que me viene a la mente para emularla sería el sombreador de geometría. Alimenta el sombreador de geometría con una línea, calcula la longitud de su espacio de pantalla y, según eso, generas un número variable de líneas secundarias entre su vértice inicial y final.

EDITAR: Quizás también podría usar una textura 1D con el canal alfa (o rojo) que codifica el patrón como 0.0 (sin línea) o 1.0 (línea) y luego hacer que la coordenada de la textura de las líneas pase de 0 a 1 y en el chader de fragmentos. haga una prueba alfa simple, descartando fragmentos con alfa por debajo de algún umbral. Puede facilitar el sombreador de geometría para generar sus texCoords de línea, ya que de lo contrario necesitará vértices diferentes para cada línea. De esta manera también puede hacer que el texCoord dependa de la longitud del espacio de pantalla de la línea.

Todo se GL_LINE más difícil si dibuja triángulos (usando el modo de polígono GL_LINE ). Luego, debe realizar la transformación de línea de triángulo en el sombreador de geometría, colocar triángulos y colocar líneas (esto también podría ser una razón para desaprobar el modo de polígono en el futuro, si es que aún no lo ha hecho).

EDITAR: Aunque creo que esta pregunta ha sido abandonada, he hecho un triple sombreado simple para el segundo enfoque. Es solo una solución mínima, siéntase libre de agregar funciones personalizadas. No lo he probado porque carezco del hardware necesario, pero deberías entenderlo:

uniform mat4 modelViewProj;
layout(location=0) in vec4 vertex;
void main()
{
gl_Position = modelViewProj * vertex;
}

El sombreador de vértice es un simple paso a través.

layout(lines) in;
layout(line_strip, max_vertices=2) out;
uniform vec2 screenSize;
uniform float patternSize;
noperspective out float texCoord;
void main()
{
vec2 winPos0 = screenSize.xy * gl_in[0].gl_Position.xy / gl_in[0].gl_Position.w;
vec2 winPos1 = screenSize.xy * gl_in[1].gl_Position.xy / gl_in[1].gl_Position.w;
gl_Position = gl_in[0].gl_Position;
texCoord = 0.0;
EmitVertex();
gl_Position = gl_in[1].gl_Position;
texCoord = 0.5 * length(winPos1-winPos0) / patternSize;
EmitVertex();
}

En el sombreador de geometría tomamos una línea y calculamos la longitud del espacio de la pantalla en píxeles. Luego lo dividimos por el tamaño de la textura del patrón de puntos, que sería un factor*16 al emular una llamada a glLineStipple(factor, pattern) . Esto se toma como una coordenada de textura 1D del punto final de la segunda línea.

Tenga en cuenta que esta coordenada de textura debe interpolarse linealmente (especificador de interpolación noperspective ). La interpolación habitual-correcta causaría que el patrón de puntos se "exprimiera" en partes más alejadas de la línea, mientras que estamos trabajando explícitamente con valores de espacio de pantalla.

uniform sampler1D pattern;
uniform vec4 lineColor;
noperspective in float texCoord;
layout(location=0) out vec4 color;
void main()
{
if(texture(pattern, texCoord).r < 0.5)
discard;
color = lineColor;
}

El sombreador de fragmentos ahora solo realiza una prueba alfa simple utilizando el valor de la textura del patrón, que contiene un 1 para la línea y un 0 para ninguna línea. Por lo tanto, para emular el punto fijo de función, tendría una textura 1D de 1 componente y 16 píxeles en lugar de un patrón de 16 bits. No olvide establecer el modo de ajuste del patrón en GL_REPEAT , sobre el modo de filtrado. No estoy seguro, pero supongo que GL_NEAREST sería una buena idea.

Pero como se dijo anteriormente, si quieres renderizar triángulos usando glPolygonMode , no funcionará de esta manera. En su lugar, debe adaptar el sombreador de geometría para aceptar triángulos y generar 3 líneas para cada triángulo.

EDITAR: De hecho, el soporte directo de OpenGL 3 para operaciones de enteros en sombreadores nos permite eliminar por completo este enfoque completo de la textura 1D y trabajar directamente con un patrón de bits real. Por lo tanto, el sombreador de geometría se cambia ligeramente para mostrar la coordenada de patrón de tamaño de pantalla real, sin normalización:

texCoord = 0.5 * length(winPos1-winPos0);

En el fragmento de sombreado, simplemente tomamos un patrón de bits como un entero sin signo (aunque de 32 bits en contraste con el glLineStipple de 16 bits de glLineStipple ) y el factor de estiramiento del patrón y simplemente tomamos la coordenada de textura (bueno, ya no hay textura , pero no importa) módulo 32 para obtener su posición en el patrón (los uint explícitos son molestos, pero mi compilador GLSL dice que las conversiones implícitas entre int y uint son malas):

uniform uint pattern;
uniform float factor;
...
uint bit = uint(round(linePos/factor)) & 31U;
if((pattern & (1U<<bit)) == 0U)
discard;