Wie kann ich variieren der Punktgröße in OpenGL glBegin(GL_POINTS)?

Gibt es eine Möglichkeit zum variieren der Punktgröße, wenn die Zeichnung viele Punkte? Ich weiß, es gibt die glPointSize(float), aber gibt es einen Weg, es zu tun in einer 'batch' oder array?

Ich würde gerne die Punkte haben verschiedenen Größen, basierend auf einem Attribut der Daten. Wie jeder Punkt mit x -, y -, z -, und ein size-Attribut. Ich bin mit der frame-buffer jetzt in java.

Könnte ich eventuell verwenden, ist der vertex Shader dafür?

InformationsquelleAutor max | 2011-01-04
  1. 15

    Können Sie point-sprite: aktivieren Sie diese mit glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); und dann können Sie gl_PointSize - Attribut in das vertex-Programm.

    Vertex-shader-Beispiel aus einem OpenGL-Diskussion-thread:

    void main() {
    gl_FrontColor=gl_Color;
    gl_PointSize = gl_Normal.x;
    gl_Position = ftransform();
}
    • Danke. Gibt es eine Möglichkeit zum einstellen der Punktgröße der mit Hilfe von vertex-Attribute anstelle von 'gl_pointSize = gl_Normal.x'?
    • Ich denke, dass Sie können fügen Sie Ihre eigenen float-Attribut zu, dass shader und verwenden glVertexAttrib1f oder glVertexAttribPointer zu setzen. Vielleicht schauen Sie unter nehe.gamedev.net/data/articles/article.asp?article=21.
    • Ok. Danke. Sind die vertex-Attribute der standard-Weg der Weitergabe von zusätzlichen Daten in ein shader?
    InformationsquelleAutor tibur
  2. 2

    Das war, was ich je getan habe,

     //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();
    InformationsquelleAutor h45
  3. 0

    Ich glaube, es ist mit glPointSize(GLfloat size)

    Quelle:

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

    • Soweit ich das verstanden habe, max will, variieren Sie die Größe der Punkte, sondern senden Sie Sie in nur einem einzigen batch.
    InformationsquelleAutor MajuiF
  4. 0

    Mit GL_POINT_DISTANCE_ATTENUATION (GL14?) Sie können die Koeffizienten für eine Funktion (ich denke, es ist quadratisch) für computing-Punkt-Größe von Z Entfernung.

    • Es klingt wie der OP will einen pro-Punkt-Größe die Einstellung unabhängig von der Entfernung.
    InformationsquelleAutor Ben Jackson
  5. 0

    Erhöhen und verringern die Punktgröße betrifft mehr als ein pixel, aber Shader ausgeführt werden soll, die nur einmal pro pixel. Es wird scheitern, denn wenn die shader-Programm ausgeführt wurde, für einen bestimmten pixel, kann die änderung nur Auswirkungen auf die folgenden Pixel, aber nicht das Vorherige Pixel.

    Shader-Programme ausgeführt werden, auf viele shader-Einheiten gleichzeitig und für viele Pixel in parallel, der es unmöglich macht, das zu tun, was Sie versuchen zu tun. Die Einschränkung wird sein, dass man kann die pixel-Größe mit einem shader-Programm, aber es wird halten, dessen Größe für alle Pixel-shader-Programm ausgeführt wird.

    Könnten Sie versuchen, Sortieren Sie Ihre point-Daten nach Größe und Gruppe Punkte der gleichen Größe in ein array und ziehen Sie jede Reihe mit einem anderen Punkt Größe.

    Oder Sie könnten versuchen, es zu tun mit einem Umweg nach dem ersten Rendern der verschiedenen Punkt-Größen in eine textur, und in einem zweiten Durchlauf Rendern die Pixel, die durch den Zugriff auf die textur-Daten und benutzen, um zu testen, ob ein pixel dargestellt werden soll (oder nicht).

    • Es ist viel schief hier. In der GL, die Shader sind nie einmal pro pixel. Vertex-Shader ausgeführt werden, einmal pro (Eingang) vertex -, fragment-shader einmal (oder sogar mehrmals) pro fragment -, geometry-Shader einmal pro Eingang primitiv und so weiter. Und der GL unterstützt die Rasterung der Punkte, die mit einer Variablen Punktgröße, so dass für eine primitive mit einer vertex viele Fragmente generiert werden könnten.
    InformationsquelleAutor Sven
Schreibe einen Kommentar