Comment puis-je faire varier la taille de point de OpenGL glBegin(GL_POINTS)?

Est-il possible de faire varier la taille des points lors de l'élaboration de beaucoup de points? Je sais qu'il y a de la glPointSize(float), mais est-il une façon de le faire dans un " lot " ou un tableau?

Je voudrais que les points de différentes tailles basé sur un attribut de données. Comme chaque point d'avoir x, y, z, et un attribut de taille. Je suis à l'aide de tampons de trame en ce moment dans java.

Je pourrais éventuellement utiliser les vertex shaders pour cela?

OriginalL'auteur max | 2011-01-04

  1. 15

    Vous pouvez utiliser le point de sprite: l'activer à l'aide de glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); et puis vous pouvez utiliser gl_PointSize attribut dans votre programme de vertex.

    Vertex shader exemple tiré d'un OpenGL fil de discussion:

    void main() {
    gl_FrontColor=gl_Color;
    gl_PointSize = gl_Normal.x;
    gl_Position = ftransform();
}
    Merci. Est-il un moyen de définir la taille de point à l'aide de vertex attributs au lieu d'utiliser 'gl_pointSize = gl_Normal.x'?
    Je suppose que vous pouvez ajouter votre propre float attribut à ce shader et l'utilisation glVertexAttrib1f ou glVertexAttribPointer. Vous pouvez consulter nehe.gamedev.net/data/articles/article.asp?article=21.
    Ok. Merci. Sont vertex attributs de la manière standard de transmission de données supplémentaires dans un shader?

    OriginalL'auteur tibur

  2. 2

    C'est ce que j'ai jamais fait,

     //reset 
 glLoadIdentity();                                   

 //set size to 1 for a group of points
 glPointSize(1);                                     

 //group #1 starts here     
 glBegin(GL_POINTS);                                 

    //color of group #1 is white 
    glColor3f(1,1,1);                                

    for(int a=0; a<x; a++)
        for(int b=0; b<y; b++)
                    glVertex3f(a/953.,-b/413.,0.);   //location of points
 glEnd();


 //set size to 5 for another group of points
 glPointSize(5);  

 //group #2 starts here     
 glBegin(GL_POINTS);

    //color of group #2 is red 
    glColor3f(1,0,0);
    for(unsigned long int a=0; a<jd; a++)
    {
           glVertex3f(data[a].i,data[a].j,0);
    }
 glEnd();

    OriginalL'auteur h45

  3. 0

    Je crois que c'est avec glPointSize(GLfloat taille)

    Source:

    http://www.talisman.org/opengl-1.1/Reference/glPointSize.html

    Comme je le comprends, max veut faire varier la taille des points, mais de l'envoyer dans un seul lot.

    OriginalL'auteur MajuiF

  4. 0

    Avec GL_POINT_DISTANCE_ATTENUATION (GL14?) vous pouvez définir les coefficients d'une fonction (je pense que c'est quadratique) pour le calcul de la taille de point de Z à distance.

    On dirait que l'OP veut avoir une par point de réglage de la taille indépendants de la distance.

    OriginalL'auteur Ben Jackson

  5. 0

    Augmentation et diminution de la taille de point touche plus d'un pixel, mais les shaders sont destinés à être exécutés qu'une seule fois par pixel. Ce sera un échec, car une fois que le shader programme a été exécuté pour un pixel en particulier, les changements n'affectent que la suite de pixels, mais pas les précédents pixels.

    Shader programmes sont exécutés sur de nombreuses unités de shader simultanément et pour un nombre de pixels en parallèle, la rendant impossible à faire ce que vous essayez de faire. La limitation est que l'on peut définir la taille de pixel avec un programme de shaders, mais il gardera sa taille pour tous les pixels shader programme est exécuté.

    Vous pourriez essayer de trier vos données de point de par sa taille et son groupe de points de la même taille dans un tableau et dessiner chaque tableau avec un point différent taille.

    Ou vous pouvez essayer de le faire avec une indirection où vous tout d'abord de rendre les différentes tailles de point dans une texture et une deuxième passe de rendre les pixels en accédant à la texture de données et l'utiliser pour tester si un pixel doit être rendu (ou pas).

    Il y a beaucoup de mal ici. Dans le GL, les shaders ne sont jamais courir une fois par pixel. Les Vertex shaders sont exécutées une fois par (entrée) vertex, le fragment shader (une fois ou plusieurs fois) par fragment, geometry shaders une fois par entrée primitive et ainsi de suite. Et GL prend en charge la pixellisation de points avec une taille de point variable, de sorte que, pour une primitive avec un sommet de nombreux fragments peuvent être générés.

    OriginalL'auteur Sven