Comment rendre les primitives sous forme de wireframes dans OpenGL?

Comment rendre les primitives sous forme de wireframes dans OpenGL?

glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );

allumer,

glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );

pour revenir à la normale.

Notez que des éléments tels que le mappage de texture et l'éclairage seront toujours appliqués aux lignes filaires s'ils sont activés, ce qui peut sembler étrange.

Depuis http://cone3d.gamedev.net/cgi-bin/index.pl?page=tutorials/ogladv/tut5

// Turn on wireframe mode
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);

// Draw the box
DrawBox();

// Turn off wireframe mode
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);

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.

Si vous utilisez le pipeline fixe (OpenGL <3.3) ou le profil de compatibilité que vous pouvez utiliser

//Turn on wireframe mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

//Draw the scene with polygons as lines (wireframe)
renderScene();

//Turn off wireframe mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

Dans ce cas, vous pouvez modifier la largeur de la ligne en appelant glLineWidth

Sinon, vous devez changer le mode polygone dans votre méthode de dessin (glDrawElements, glDrawArrays, etc.) et vous pourriez vous retrouver avec des résultats approximatifs car vos données de sommet sont pour des triangles et vous générez des lignes. Pour de meilleurs résultats, envisagez d'utiliser un ombrage géométrique ou de créer de nouvelles données pour le filaire.

Le moyen le plus simple est de dessiner les primitives en tant que GL_LINE_STRIP.

glBegin(GL_LINE_STRIP);
/* Draw vertices here */
glEnd();

Dans Modern OpenGL (OpenGL 3.2 et supérieur), vous pouvez utiliser un Geometry Shader pour cela:

#version 330

layout (triangles) in;
layout (line_strip /*for lines, use "points" for points*/, max_vertices=3) out;

in vec2 texcoords_pass[]; //Texcoords from Vertex Shader
in vec3 normals_pass[]; //Normals from Vertex Shader

out vec3 normals; //Normals for Fragment Shader
out vec2 texcoords; //Texcoords for Fragment Shader

void main(void)
{
    int i;
    for (i = 0; i < gl_in.length(); i++)
    {
        texcoords=texcoords_pass[i]; //Pass through
        normals=normals_pass[i]; //Pass through
        gl_Position = gl_in[i].gl_Position; //Pass through
        EmitVertex();
    }
    EndPrimitive();
}

Avis:

• pour les points, passez layout (line_strip, max_vertices=3) out;àlayout (points, max_vertices=3) out;
• En savoir plus sur Geometry Shaders

Vous pouvez utiliser des bibliothèques glut comme ceci:

1. pour une sphère:

   glutWireSphere(radius,20,20);
   

2. pour un cylindre:

   GLUquadric *quadratic = gluNewQuadric();
   gluQuadricDrawStyle(quadratic,GLU_LINE);
   gluCylinder(quadratic,1,1,1,12,1);
   

3. pour un cube:

   glutWireCube(1.5);
   

Un moyen simple et efficace de dessiner des lignes anti-aliasées sur une cible de rendu non anti-aliasée consiste à dessiner des rectangles de 4 pixels de largeur avec une texture 1x4, avec des valeurs de canal alpha de {0., 1., 1., 0.} et utilisez le filtrage linéaire avec désactivation du mip-mapping. Cela rendra les lignes épaisses de 2 pixels, mais vous pouvez changer la texture pour différentes épaisseurs. C'est plus rapide et plus facile que les calculs barymétriques.

utiliser cette fonction: void glPolygonMode (GLenum face, GLenum mode);

face: spécifie les polygones auxquels ce mode s'applique. peut être GL_FRONT pour la face avant du polygone et GL_BACK pour son dos et GL_FRONT_AND_BACK pour les deux.

mode: Trois modes sont définis et peuvent être spécifiés en mode:

GL_POINT: les sommets de polygone marqués comme début d'une arête de frontière sont dessinés sous forme de points.

GL_LINE: Les arêtes limites du polygone sont dessinées sous forme de segments de ligne. (votre cible)

GL_FILL: L'intérieur du polygone est rempli.

PS: glPolygonMode contrôle l'interprétation des polygones pour la pixellisation dans le pipeline graphique.

pour plus d'informations, consultez les pages de référence OpenGL dans le groupe khronos: https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glPolygonMode.xhtml

Si c'est OpenGL ES 2.0 que vous traitez, vous pouvez choisir l'une des constantes du mode de dessin dans

GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, pour tracer des lignes,

GL_POINTS (si vous devez dessiner uniquement des sommets), ou

GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN et GL_TRIANGLESpour dessiner des triangles pleins

comme premier argument à votre

glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)

ou

glDrawArrays(GLenum mode, GLint first, GLsizei count) appels.