Assumindo um contexto compatível com a frente no OpenGL 3 e superior, você pode usar glPolygonModecomo mencionado anteriormente, mas observe que as linhas com espessura superior a 1px agora estão obsoletas. Portanto, embora você possa desenhar triângulos como uma armação de arame, eles precisam ser muito finos. No OpenGL ES, você pode usar GL_LINEScom a mesma limitação.
No OpenGL, é possível usar sombreadores de geometria para pegar triângulos, desmontá-los e enviá-los para rasterização como quads (pares de triângulos realmente) emulando linhas grossas. Bem simples, na verdade, exceto que os shaders de geometria são notórios por uma escala de desempenho ruim.
O que você pode fazer e o que também funcionará no OpenGL ES é empregar o shader de fragmentos . Pense em aplicar uma textura de triângulo de arame ao triângulo. Exceto que nenhuma textura é necessária, ela pode ser gerada proceduralmente. Mas chega de conversa, vamos codificar. Shader de fragmento:
in vec3 v_barycentric; // barycentric coordinate inside the triangle
uniform float f_thickness; // thickness of the rendered lines
void main()
{
float f_closest_edge = min(v_barycentric.x,
min(v_barycentric.y, v_barycentric.z)); // see to which edge this pixel is the closest
float f_width = fwidth(f_closest_edge); // calculate derivative (divide f_thickness by this to have the line width constant in screen-space)
float f_alpha = smoothstep(f_thickness, f_thickness + f_width, f_closest_edge); // calculate alpha
gl_FragColor = vec4(vec3(.0), f_alpha);
}
E shader de vértice:
in vec4 v_pos; // position of the vertices
in vec3 v_bc; // barycentric coordinate inside the triangle
out vec3 v_barycentric; // barycentric coordinate inside the triangle
uniform mat4 t_mvp; // modeview-projection matrix
void main()
{
gl_Position = t_mvp * v_pos;
v_barycentric = v_bc; // just pass it on
}
Aqui, as coordenadas baricêntricas são simples (1, 0, 0), (0, 1, 0)e (0, 0, 1)para os três vértices do triângulo (a ordem realmente não importa, o que torna o empacotamento em tiras de triângulo potencialmente mais fácil).
A desvantagem óbvia dessa abordagem é que ela comerá algumas coordenadas de textura e você precisará modificar sua matriz de vértices. Poderia ser resolvido com um shader de geometria muito simples, mas eu ainda suspeitaria que será mais lento do que apenas alimentar a GPU com mais dados.