Point Sprites pour le système de particules

Point sprites sont en effet bien adaptés pour les systèmes de particules. Mais ils n'ont rien à voir avec des Organisations sises à vienne et GLSL, ce qui signifie qu'ils sont complètement orthogonale de la fonctionnalité. Peu importe si vous utiliser des sprites ou non, vous devez toujours utiliser des Organisations sises à vienne pour le téléchargement de la géométrie, qu'ils soient de simples points, pré-faites des sprites ou que ce soit, et vous devez toujours mettre cette géométrie à travers un ensemble de shaders (en OpenGL moderne bien sûr).

Cela étant dit point sprites sont très bien pris en charge dans OpenGL moderne, tout simplement pas automatiquement comme avec l'ancien fixe la méthode de la fonction. Ce n'est pas pris en charge sont le point de l'atténuation des fonctionnalités qui vous permettent de mettre à l'échelle un point de la taille sur la base de sa distance à la caméra, vous devez le faire manuellement dans le vertex shader. De la même manière que vous avez à faire la texture du point manuellement dans un fragment shader, à l'aide de la variable d'entrée gl_PointCoord (qui dit où dans [0,1]-place de l'ensemble du point de l'actuel fragment est). Par exemple, un point de base de sprite pipeline pourrait ressembler à ça:

...
glPointSize(whatever);              //specify size of points in pixels
glDrawArrays(GL_POINTS, 0, count);  //draw the points

vertex shader:

uniform mat4 mvp;

layout(location = 0) in vec4 position;

void main()
{
    gl_Position = mvp * position;
}

fragment shader:

uniform sampler2D tex;

layout(location = 0) out vec4 color;

void main()
{
    color = texture(tex, gl_PointCoord);
}

Et c'est tout. Bien sûr, ces shaders juste faire le plus de dessin de base de la texture des sprites, mais sont un point de départ pour d'autres fonctions. Par exemple pour calculer le sprite de la taille en fonction de sa distance à la caméra (peut-être pour lui donner un monde fixe-taille de l'espace), vous devez glEnable(GL_PROGRAM_POINT_SIZE) et écrire à la spéciale de la variable de sortie gl_PointSize dans le vertex shader:

uniform mat4 modelview;
uniform mat4 projection;
uniform vec2 screenSize;
uniform float spriteSize;

layout(location = 0) in vec4 position;

void main()
{
    vec4 eyePos = modelview * position;
    vec4 projVoxel = projection * vec4(spriteSize,spriteSize,eyePos.z,eyePos.w);
    vec2 projSize = screenSize * projVoxel.xy / projVoxel.w;
    gl_PointSize = 0.25 * (projSize.x+projSize.y);
    gl_Position = projection * eyePos;
}

Ce serait tout point sprites ont le même monde-taille de l'espace (et donc un autre écran-taille de l'espace en pixels).

---

Mais point sprites, tout en restant parfaitement pris en charge dans OpenGL moderne ont leurs inconvénients. L'un des plus grands inconvénients est leur écrêtage comportement. Les Points sont ramenées à leur centre de coordonnées (parce que le détourage est fait avant le tramage et donc avant le point de se "élargie"). Donc, si le centre des le point est à l'extérieur de l'écran, le reste de ce qui pourrait encore arriver dans la zone d'affichage n'est pas montré, au pire une fois que le point est à mi-chemin hors de l'écran, il va soudainement disparaître. Ce n'est cependant perceptible uniquement (ou annyoing) si le point sprites sont trop grandes. Si elles sont très petites particules qui ne couvrent pas beaucoup plus que quelques pixels de toute façon, alors ce ne sera pas beaucoup d'un problème et je serais encore à l'égard des systèmes de particules canonique de cas d'utilisation pour le point sprites, il suffit de ne pas les utiliser pour les grands panneaux d'affichage.

Mais si c'est un problème, alors OpenGL moderne offre de nombreuses autres façons de mettre en œuvre point sprites, en dehors de la naïveté chemin de pré-construction de toutes les images-objets individuels, des quads sur le CPU. Vous pouvez toujours vous rendre sur eux comme un tampon plein de points (et donc dans la manière dont ils sont susceptibles de sortir de votre GPU basé sur un moteur de particules). Réellement générer du quad, de la géométrie ensuite, vous pouvez utiliser la géométrie shader, ce qui vous permet de générer un quad à partir d'un seul point. D'abord vous n'avez qu'à le modelview de transformation à l'intérieur du vertex shader:

uniform mat4 modelview;

layout(location = 0) in vec4 position;

void main()
{
    gl_Position = modelview * position;
}

Alors la géométrie shader fait le reste du travail. Il associe la position des points avec les 4 coins d'un générique [0,1]-quad et complète la transformation dans clip-espace:

const vec2 corners[4] = { 
    vec2(0.0, 1.0), vec2(0.0, 0.0), vec2(1.0, 1.0), vec2(1.0, 0.0) };

layout(points) in;
layout(triangle_strip, max_vertices = 4) out;

uniform mat4 projection;
uniform float spriteSize;

out vec2 texCoord;

void main()
{
    for(int i=0; i<4; ++i)
    {
        vec4 eyePos = gl_in[0].gl_Position;           //start with point position
        eyePos.xy += spriteSize * (corners[i] - vec2(0.5)); //add corner position
        gl_Position = projection * eyePos;             //complete transformation
        texCoord = corners[i];                         //use corner as texCoord
        EmitVertex();
    }
}

Dans le fragment shader, vous serait alors bien sûr, utiliser l'outil de texCoord variable au lieu de gl_PointCoord pour le texturage, puisque nous n'avons plus le dessin des points.

---

Ou une autre possibilité (et peut-être plus vite, car je me souviens geometry shaders ont la réputation d'être lent) serait d'utiliser des instances de rendu. De cette façon, vous avez un supplément de VBO contenant les sommets de un seul générique 2D quad (c'est à dire [0,1]-carré) et de votre bon vieux VBO contenant les positions de point. Ce que vous faire est de dessiner ce seul quad plusieurs fois (instancié), tandis que la recherche de cas individuels, de positions du point VBO:

glVertexAttribPointer(0, ...points...);
glVertexAttribPointer(1, ...quad...);
glVertexAttribDivisor(0, 1);            //advance only once per instance
...
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count);  //draw #count quads

Et dans le vertex shader vous puis assembler le par point avec les coin/quad-position (qui est aussi la texture de coordonnées de vertex):

uniform mat4 modelview;
uniform mat4 projection;
uniform float spriteSize;

layout(location = 0) in vec4 position;
layout(location = 1) in vec2 corner;

out vec2 texCoord;

void main()
{
    vec4 eyePos = modelview * position;            //transform to eye-space
    eyePos.xy += spriteSize * (corner - vec2(0.5)); //add corner position
    gl_Position = projection * eyePos;             //complete transformation
    texCoord = corner;
}

Il réalise le même que la géométrie shader approche fondée sur les, correctement taillée point sprites avec une constante de l'espace-monde taille. Si vous voulez imiter le d'écran de l'espace de taille de pixel de réel point sprites, vous avez besoin de mettre un peu plus de puissance de calcul en elle. Mais cela est laissé comme exercice et l'oppisite du monde à l'écran de transformation, de la le point sprite shader.