En supposant un contexte de compatibilité ascendante dans OpenGL 3 et supérieur, vous pouvez soit utiliser glPolygonModecomme mentionné précédemment, mais notez que les lignes avec une épaisseur supérieure à 1px sont désormais obsolètes. Ainsi, bien que vous puissiez dessiner des triangles en fil de fer, ils doivent être très fins. Dans OpenGL ES, vous pouvez utiliser GL_LINESavec la même limitation.
Dans OpenGL, il est possible d'utiliser des shaders de géométrie pour prendre les triangles entrants, les désassembler et les envoyer pour la pixellisation sous forme de quads (des paires de triangles vraiment) émulant des lignes épaisses. Assez simple, vraiment, sauf que les shaders de géométrie sont connus pour leur mauvaise mise à l'échelle des performances.
Ce que vous pouvez faire à la place, et ce qui fonctionnera également dans OpenGL ES, c'est d'utiliser un fragment shader. Pensez à appliquer une texture de triangle filaire au triangle. Sauf qu'aucune texture n'est nécessaire, elle peut être générée de manière procédurale. Mais assez parlé, codons. Shader de fragment:
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);
}
Et vertex shader:
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
}
Ici, les coordonnées barycentriques sont simplement (1, 0, 0), (0, 1, 0)et (0, 0, 1)pour les trois sommets triangulaires (l'ordre n'a pas vraiment d'importance, ce qui facilite potentiellement le compactage en bandes triangulaires).
L'inconvénient évident de cette approche est qu'elle va manger des coordonnées de texture et que vous devez modifier votre tableau de sommets. Pourrait être résolu avec un shader de géométrie très simple, mais je soupçonne toujours qu'il sera plus lent que de simplement alimenter le GPU avec plus de données.