Comment remplir un polygone avec une couleur différente que limite?

Une approche plus moderne serait de mettre en œuvre cette via geometry shaders. Ce serait le travail pour l'OpenGL 3.2 et au-dessus dans le cadre de la fonctionnalité de base, ou pour l'OpenGL 2.1 avec l'extension GL_EXT_geometry_shader4.

Ce livre a toutes les théorie : Shader à Base de fil de fer de dessin. Il fournit également un exemple de mise en œuvre de la technique la plus simple en GLSL.

Voici mon propre coup de couteau à elle, essentiellement un port de leur mise en œuvre pour l'OpenGL 3.3, limitée à un triangle primitives:

Vertex shader: (remplacer les entrées avec tout ce que vous utilisez pour passer au sommet de données d'un m, v et p des matrices)

#version 330

layout(location = 0) in vec4 position;
layout(location = 1) in mat4 mv;

out Data
{
    vec4 position;
} vdata;

uniform mat4 projection;

void main()
{
    vdata.position = projection * mv * position;
}

Geometry shader:

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

in Data
{
    vec4 position;
} vdata[3];

out Data
{
    noperspective out vec3 dist;
} gdata;

void main()
{
    vec2 scale = vec2(500.0f, 500.0f); //scaling factor to make 'd' in frag shader big enough to show something
    vec2 p0 = scale * vdata[0].position.xy/vdata[0].position.w;
    vec2 p1 = scale * vdata[1].position.xy/vdata[1].position.w;
    vec2 p2 = scale * vdata[2].position.xy/vdata[2].position.w;

    vec2 v0 = p2-p1;
    vec2 v1 = p2-p0;
    vec2 v2 = p1-p0;
    float area = abs(v1.x*v2.y - v1.y*v2.x);

    gdata.dist = vec3(area/length(v0),0,0);
    gl_Position = vdata[0].position;
    EmitVertex();

    gdata.dist = vec3(0,area/length(v1),0);
    gl_Position = vdata[1].position;
    EmitVertex();

    gdata.dist = vec3(0,0,area/length(v2));
    gl_Position = vdata[2].position;
    EmitVertex();

    EndPrimitive();
}

Vertex shader: (remplacer les couleurs avec ce que vous avez besoin !)

#version 330

in Data
{
    noperspective in vec3 dist;
} gdata;

out vec4 outputColor;

uniform sampler2D tex;

const vec4 wireframeColor = vec4(1.0f, 0.0f, 0.0f, 1.0f);
const vec4 fillColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);

void main()
{
    float d = min(gdata.dist.x, min(gdata.dist.y, gdata.dist.z));
    float I = exp2(-2*d*d);
    outputColor = mix(fillColor, wireframeColor, I);
}

OriginalL'auteur Nicolas Lefebvre

Il y a 2 façons de le faire:

• celui que vous faites à l'instant (2 polygones, l'une un peu plus grande que l'autre, ou à la main après)

• texture

à ma connaissance, il n'existe pas d'autres possibilités et à partir d'un point de vue des performances de ces 2 possibilités, en particulier la première, tant que vous n'couleur de remplissage, sont extrêmement rapides.

OriginalL'auteur Bernd Elkemann