OpenGL 3.x



  • Ich würde gern eine kleine Partikelsimulation mit OpenGL 3.x schreiben.

    Bisher hab ich diese mit "altem" OpenGL verwirklicht.

    Ich berechne mittels einiger DGL die neuen Positionen meiner Vertices und zeichne sie anschließend.

    Nun frage ich mich, an welcher Stelle ich das Neuberechnen der Koordinaten in OpenGL 3.X machen muss.
    Ist das Sache des Vertexshaders?
    Sollte ich dort auch die DGL lösen?

    Oder berechne ich die DGL wie gewohnt auf der CPU , errechne eine Modelview-Matrix und schicke diese an einen Shader?

    Ich habe noch kaum Erfahrung mit OpenGL 3.x.
    😞



  • Müssen tust du gar nichts, außer vielleicht auf deprecated Stuff zu verzichten.
    Wenn der Shader schneller is, rechne im Shader, ganz klar.



  • OpenGL3 ist ein Krampf für Anfänger. 100 Zeilen Code für ein texturiertes Dreieck ist echt übel und die Fehlersuche durch die zusätzliche Shaderkacke ein Alptraum. Wäre mal schön wenn da mal einer ein Buch oder Tutorial in deutsch für schreiben würde. So hat man kaum eine Chance, ich habe nach einer Woche für ein Minimalbeispiel aufgegeben.



  • vortix schrieb:

    Nun frage ich mich, an welcher Stelle ich das Neuberechnen der Koordinaten in OpenGL 3.X machen muss.
    Ist das Sache des Vertexshaders?
    Sollte ich dort auch die DGL lösen?

    Oder berechne ich die DGL wie gewohnt auf der CPU , errechne eine Modelview-Matrix und schicke diese an einen Shader?

    Ist beides möglich. Wenn du z.B. die CPU entlasten willst oder mehr Geschwindigkeit brauchst, kannst du das Update evtl. auf der GPU machen.

    vortix schrieb:

    Ich habe noch kaum Erfahrung mit OpenGL 3.x.
    😞

    Dann sammle welche... 😉



  • Ich scheitere schon recht flott.
    AM meisten bereitet mir diese Zeile Kopfschmerzen

    glEnableVertexAttribArray(0);

    Woher kommt die Null?

    Ich beziehe mich auf die aktuellen Nehe-Tutorials, die imo bei weitem nicht so gut sind, wie die zu OGL 2.1.

    http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/#header-2

    Zu meiner ursprünglichen Frage:
    Ist es auch möglich die Positionen der Partikel komplett auf CPU zu berechnen und einfach mit BufferData diese zu updaten?
    Die Möglichkeit des Vertexshaders sollte ich erstmal außen vor lassen, da ich externe Bibliotheken für die DGL verwende



  • Die 0 kommt einfach daher da du auf dem ersten Attribut im Shader arbeitest.

    Im Shader hast du ja stehen:

    in vec3 Position;

    int positionLocation = glGetAttribLocation(programID, "Position");

    spuckt dir für den Shader genau diese 0 aus.



  • Vielen Dank für die INfo.

    Gibt es vielleicht ein Tutorial das so etwas ein wenig ausführlicher behandelt?

    Leider setzen viele Tutorials den Fokus auf die Mathematik. Ich habe kein Problem das bisschen Vektorrechnen zu verstehen, hab aber von der modernen Grafikpipeline kaum ne Ahnung.

    Noch ne Frage zu dem vertexattrib. In der Doku lese ich dazu:

    glEnableVertexAttribArray enables the generic vertex attribute array specified by index. glDisableVertexAttribArray disables the generic vertex attribute array specified by index. By default, all client-side capabilities are disabled, including all generic vertex attribute arrays. If enabled, the values in the generic vertex attribute array will be accessed and used for rendering when calls are made to vertex array commands such as glDrawArrays, glDrawElements, glDrawRangeElements, glMultiDrawElements, or glMultiDrawArrays.

    Was sind diese generic vertex attributes genau?
    Und wenn sich die "0" auf die erste Variable im Shader bezieht...
    welcher Shader? Vertex?

    Ich habe spasseshalber mal einen in vec4 xxx; im Vertexshader vor position eingefügt, dennoch funktioniert die Ausgabe des Dreiecks einwandfrei. Obwohl immer noch Attribute 0 aktiviert wird.
    Seltsam ...

    Naja ich bräuchte mal ein Tutorial das genauer darauf eingeht.
    Von der SUperbible 5, die ich mir sogar gekauft habe, bin ich leider sehr enttäuscht. Bis das ganze VAO/VBO Zeugs mal erklärt wird oder generell Shader, ist schon das halbe Buch rum. Diese GLTools nehmen ZU viel Arbeit ab und verbergen leider alles wesentliche.



  • Mach dir nix draus, ich habe schon eine ganze Weile gebraucht um ein einfaches Dreieck darzustellen. Bei einer Textur die aus dem Speicher und nicht aus einer Datei kommen soll, bin ich dann endgültig gescheitert.

    Die Suche per Google bringt mich entweder auf englische Seiten, die ich zwar verstehe, aber es wird mir dennoch zu kompliziert erklärt. Auf deutsch findet man kaum was und 99% aller Treffer arbeiten noch mit der alten glBegin glEnd Technologie.

    Ich probiere es vielleicht nächstes Jahr nochmal. Mein Ziel hatte ich dann mit der WinAPI gelöst, man ist das einfach gewesen im Gegensatz zu OpenGL3+



  • Ich glaube man sollte eine fertige Engine verwenden die OpenGL 3 nutzt. Das selbst zu programmieren ist einfach nur Quälerei.



  • Ein guter Weg, nur nutze ich ungerne für jede Kleinigkeit gleich eine anderen Lib oder Framework denn damit handle ich mir wieder eine Abhängigkeit zusätzlich ein. Und zum Zweiten möchte ich auch das neue OpenGL ein wenig verstehen und in den Grundzügen anwenden können.

    Mich wundert auch warum es so wenig Literatur oder wirklich einsteigerfreundliche Tutorials gibt. Ich dachte immer OpenGL3+ ist schon ein paar Jahre auf dem Markt, also in der IT eine Ewigkeit?

    Damals die Customchips im Amiga mit purem Assembler zu programmieren war wesentlich einfacher.



  • ALso ich würde es schon gerne lernen. Ich denke der Aufwand für 4.x ist dann nicht mehr allzu hoch.

    Leider ist die Lernkruve am Anfang recht steil.

    Wenn mir jmd das glVertexAttribute Zeugs mal anständig erklären würde, wäre mir schon sehr stark geholfen.

    Sobald ich soweit bin, dass ich mich (ausschließlich) um die Shader kümmern muss, bin ich eigentlich schon sehr zufrieden. Auch die Literatur für Shader ist wesentlich besser.



  • Kleines Update.
    Ich versuche grad ein Dreieck zu manipulieren, so dass die Spitze von links nach rechts wandert und nach 2 Sekunden wieder links ist.

    Bisher versuche ich das, indem ich ein Array mit den Dreieckskoordinaten habe, diese in jedem neuen Frame neu berechne und die Daten mit glBufferData beim Zeichnen neu übermittle.

    Das scheint zumindest so wie ich gemacht habe nicht sehr effizient.
    Das Bild ruckelt stark, trotz vsync und Frameratelimit.

    Hier mal die Zeichenroutine ohne clear:

    glUseProgram(programID);
    
            if(frametime > 2)
                clock.restart();
    
            g_vertex_buffer_data[6] = frametime -1;
    
            glEnableVertexAttribArray(0);
    		glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    		glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);
    		glVertexAttribPointer
    		(
    			0,                  // attribute 0. No particular reason for 0, but must match the layout in the shader.
    			3,                  // size
    			GL_FLOAT,           // type
    			GL_FALSE,           // normalized?
    			0,                  // stride
    			(void*)0            // array buffer offset
    		);
    
    		// Draw the triangle !
    		glDrawArrays(GL_TRIANGLES, 0, 3); 
    
    		glDisableVertexAttribArray(0);
    

    Bin über jeden Verbesserungsvorschlag froh ^^



  • Nimm mal GL_DYNAMIC_DRAW statt GL_STATIC_DRAW und tu den Buffer nur einmal mit glBufferData() anlegen und dann immer mit glBufferSubData() updaten.


Log in to reply