Welche OGL-Version wählen: Performance vs. Kompatibilität



  • Hallo,
    Ich wollte mal was mit OpenGL machen.
    Mein Problem ist nur, dass ich keinen Überblick über die verschiedenen Möglichkeiten habe, die sich über die Jahre zur Shaderprogrammierung ergeben haben. Besonders was da zusammen gehört.
    Also zb "in"/"out" vs "attribute" etc. Oder auch diverse Buffer für Shader.
    Gibts dazu vielleicht irgendwo eine Übersicht? Besonders wann welche OGL-Version rauskam..

    Statt nämlich auf die neusten Neuerungen zu setzen, die ich garnicht brauche, würde ich lieber auch ältere/schwächere Hardware mit einbeziehen.

    Also konkret: Welche Version brauche ich mindestens, für einen FS für per-pixel-lighting (und aus welchem Jahr wäre die)? Und welche Version würdet ihr dafür empfehlen?

    Ich hab schon etwas mit der ganz alten fixed function pipeline (ogl 1.1 == 1995 ?!) gespielt (Matrizen, lightposition/color, normals etc). Welche Shaderversion bräuchte es denn, um auf diese Variablen im Shader zuzugreifen?

    In welcher Version programmiert ihr denn so? Und warum? Und was wäre die älteste, noch empfehlenswerte Version (zb. für Spiele oder CAD)?
    Vielleicht gibts ja Erfahrungswerte, z.B., dass man noch 5/10 Jahre alter Hardware mit einbezieht..

    Gruß,
    Kleee



  • Wenn DU nicht an spezielle Implementationen gebunden bist, ist für die Version ist nur noch die zu nutzenden Technologien + Pixelformate etc. ausschlagebend, und auch ob Du mobile und Desktop zusammenfahren willst (OpenGL und OpenGL ES profiles).

    Gehen wir vom einfachsten Fall aus, Du willst nur was fürn Desktop bauen (kein OpenGL ES also kein Android, IOS etc).

    Dann check einfach was für Technologien du Verwenden willst ....
    Das hat natuerlich auch auswirkung auf die performance.

    Brauchst du z.b. keine besonderen Shader (Geometrie, Tesselation), keine besonderen Pixelformate ( kommst mit BGRA hin, komprimierst selber etc)
    verwendest quasi nur den Modern Opengl minimum Standard (VBO VBAO) und bist frei bei der GLSL Version, wirst die minimum Version schon gut druecken können. ( z.b. 3.2 was Stand ca. 2010 ist )

    Wichtig ist aber zu verstehen, das OpenGL sich über Features (Capabilities) weiterentwickelt. Die dann in den Core für eine Bestimmte version wandern, oder auch nicht ....

    D.H. zuerst existieren die als erweiterung, die man abfragen kann, ob sie für die aktuell verwendete Implementation verfügbar sind (glGetXXX )
    Wenn Sie in den Standard aufgenommen werden, kann man die Capabilities immer noch checken, aber muss es nicht, weil dann kann man auch einfach die version abfragen (zwingend für version).

    Weiterhin wichtig, OpenGL selber ist nur nen Wrapper um die funktionen, die auf der Graka, bzw im treiber liegen.
    Also ist auf die Kombi Graka + Treiber + BS ausschlaggebend, was für ne OpenGL version Du fahren kannst.
    Unter 4.0 (2010-2011) brauchst sicher nicht zu gehen ...

    Also zb "in"/"out" vs "attribute" etc.

    Das ist viel "Formsache" ... da ist viel geändert wurden, um Nachträglich einige dinge glattzuziehen ... um die shadersprache wieder übersichtlich zu machen trotz gewachsenen funktionsumfang.

    Welche Shaderversion bräuchte es denn, um auf diese Variablen im Shader zuzugreifen?

    Shader machen ohne variablen keinen Sinn ^^
    Also uniforms gibts schon immer.
    Wichtiger war, wie flexibel die vertexAttribute sein konnten, in bezug auf Was, und wie im Speicher abgelegt ...
    und welche datentypen (genauigkeit, integers .... etc) man braucht.

    Also für Standard anwendungen wär 3.2 locker ausreichend.
    Für wildere Sachen (HDR, fette komprimierte texturen etc) braucht man halt dann etwas kompetentere HW, und damit dann auch modernere Version des Treibers und damit der Opengl version



  • Danke, das ist sehr gut zu wissen!

    und auch ob Du mobile und Desktop zusammenfahren willst (OpenGL und OpenGL ES profiles).

    Welcher Ogl-Version entspricht denn OglES? Und wie aktiviere ich es im Profil (oder was auch immer ich machen muss..) aufm Desktop? Evtl würde das ja schon genügen, und ich hätte direkt einen dicken Kompatibilitätsbonus.
    Ist v3.2 .. v3.3 irgendwie ein Meilenstein gewesen, oder so?
    Ist es ok, ähnliche Funktionen von unterschiedlichen Versionen zu nutzen, oder ist es evtl sogar so idiotensicher, dass man obsolete Funktionen nicht nutzen kann, bzw. woran erkenne ich, was wozu gehört? ..Z.B. wird doch im Laufe der Versionen irgendwann auf "glBegin() glColor()" etc verzichtet, dann auf die "glMatrixTrafos()", .., oder irre ich mich da?
    Es bräuchte eine Art Gegenüberstellung: "So zeichnet man einen texturierten Würfel in Ogl(ES)1,2,3,4". Das wäre extrem hilfreich für den Einstieg und die Unterscheidung.
    Bleibt noch die Frage, wo man Tutorials zu den alten Versionen findet..

    Und was mich jetzt noch akut beschäftigt: Ich hätte gerne einen eigenen FS, würde aber gerne erstmal alle Fixed-Function-Pipeline-Trafos und -Anweisungen (glBegin().. ) behalten. Geht das, oder muss ich alles fürn Testprogramm neu schreiben???
    Wenn das geht, wie komm ich z.B an die versch. Lichtquellen-Parameter dran?



  • 1. OpenGL ES ist eine "Variante" von OpenGL, und zwar für embedded / mobile Graka.
    Also für nicht ganz so kompotente oder anderweitig kompetente hardware 🙂

    Also kein Profile was du umschalten kannst, sondern das "gerät" / OS schreibt dir vor, welches OpenGL du bekommst. Also willst du dein renderer irgendwann mal auf android ios oder windows mobile laufen lassen, solltest dich an opengl es orientieren. bei reinen desktop anwendungen (Linux, windows ... ) brauchst das nicht.

    Die versionen mappen auch nicht 1:1. OpenGL ES stellt weniger anforderungen/Specs an die HW, also ist da auch weniger in den Core Features drin.
    Deswegen bietet es sich an, da mehr mit den Capabilities zu arbeiten, d.h. man fragt die HW / Treiber ab, was die graka wirklich kann ...

    OpenGL ES 2.0 orientiert sich z.b. an OpenGL 2.0 ... allerdings mit komplett deaktivierter Fixed pipeline.

    bzw. woran erkenne ich, was wozu gehört?

    https://www.khronos.org/opengl/wiki/OpenGL_Reference

    Ist v3.2 .. v3.3 irgendwie ein Meilenstein gewesen, oder so?

    OpenGL 3.2 / OpenGL ES 2.0 ist die erste Version wo im Core Profile die Fixed pipeLine abgeschalten wurde. Also kein glBegin .. glMatrix ... etc mehr
    Man ist gezwungen "Modern" zu rendern.

    So zeichnet man einen texturierten Würfel in Ogl(ES)1,2,3,4

    Bleibt noch die Frage, wo man Tutorials zu den alten Versionen findet..

    Vergiss alte version ...
    die unterscheidung ist
    fixed pipeline (da suchst nach opengl 1.x tutorials)
    oder "modern" (da suchst nach modern opengl tutorials oder nach versionen nach 3.2)
    ansonsten kommen nur features hinzu.
    Was mit 3.2 geht, geht definitiv auch mit 4.6
    kann nur sein das es mit 4.6 wesentlich effizientere Wege gibt, das selbe zu rendern, oder das man mehr details hinbekommt ... etc.

    Besser du schaust dir nur den modernen weg an, dafür gibts gute tutorials:
    https://learnopengl.com/
    und die triangle fersion ^^
    http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/

    Wenn das geht, wie komm ich z.B an die versch. Lichtquellen-Parameter dran?

    diese Frage ist nur bei der Fixed Pipline valid ...
    bei "Modern" gibst du die Beleuchtungsparams dem Shader als uniforms oder UniformBlocks (UBO) mit.
    d.h. du definierst uniforms in deinem shader, und bevor oder während du renders, befüllst die ... uniforms werden pro shaderprogram (program ist eine combi aus mehreren shadertypen, mindestens vertex und fragment für einen rendercall) gespeichert. wenn sich die beleuchtung, modifizierst einfach die uniforms ... und beim naechsten renderdurchlauf werden die neuen werte genommen.

    Suche am besten nach Opengl und material materialsystem etc ....

    und tu dir nen gefallen, vergess die fixed pipeline. Der Performance und Feature gewinn ist zu mächtig, um das zu ignorieren ...
    Kann dir beim konvertieren von Fixed Pipeline auf modern nicht viel helfen, weil ich mit Fixed Pipeline nie wirklich was gemacht hab.

    Ciao ...



  • Ich hab mich mal umgeschaut.. So langsam dämmerts mir. Gibts eigentlich Alternativen zu "glUniform", "glVertexAttribPointer", oder so?

    Also willst du dein renderer irgendwann mal auf android ios oder windows mobile laufen lassen, solltest dich an opengl es orientieren.

    Mal de dumme Frage: Wie orientiere ich mich den ganz konkret an OglEs? Vielleicht genügt das ja schon. Eigentlich brauche ich nur den FS (und VS).

    Also kein Profile was du umschalten kannst, sondern das "gerät" / OS schreibt dir vor, welches OpenGL du bekommst.

    Das verstehe ich noch nicht so ganz. Muss man denn nicht irgendwie vorschreiben, womit man arbeiten möchte? Oder existieren einfach alle Funtionen parallel (zumindest die, die von der hw bereit gestellt werden)?



  • Muss man denn nicht irgendwie vorschreiben, womit man arbeiten möchte?

    Nein, Deine Umgebung bestimmt das ...

    Hasst du einen Desktop oder Laptop/Convertable mit z.b. intel/amd cpu und intel integrierter Grafik oder externer Grafaikkarte (nvidia,amd) und Windows, Linux, MacOs als BS, dann wirst du OpenGL Treiber bekommen.

    Hasst du aber ein handy, ein Tablet mit Android, IOS, oder nen Gerät mit irgend nem Prozessor und ner Embedded Geräte Graka (Nicht zu verwechseln mit den Intel Onbord Grakas) / DSP , dann wirst OpenGL ES (ES steht für embedded systems) bekommen. Auch wenn du Android auf einem Intel PC laufen lassen willst, oder in einer virtuellen Machine aufm PC, hasst du opengl ES

    https://en.wikipedia.org/wiki/OpenGL_ES

    OpenGL und OpenGL ES haben die gleichen Konzepte, viele gemeinsame Funktionen ... sind aber eben doch nicht gleich ^^

    Also du kannst nicht wählen, ob OpenGL oder OpenGL ES verwenden willst. Die Frage ist, ob deine Renderbibo beide Standards unterstützen muss (weil irgendwann mal deine Anwendung aufn handy laufen lassen willst, z.b.)



  • Ok, besten Dank. Ich denke, ich durchschau's. Alles exisitert parallel.

    Also du kannst nicht wählen, ob OpenGL oder OpenGL ES verwenden willst. Die Frage ist, ob deine Renderbibo beide Standards unterstützen muss

    Wenn OglEs2 ne abgespeckte Version von Ogl2 ist, kann man doch davon ausgehen, dass jeder, der Ogl2 kann, auch mit ES klar kommt, oder?



  • Wenn OglEs2 ne abgespeckte Version von Ogl2 ist, kann man doch davon ausgehen, dass jeder, der Ogl2 kann, auch mit ES klar kommt, oder?

    In der Praxis eher andersrum 🙂
    OpenGL 2 kannst fixed pipline mit modernen Techniken nutzen.
    OpenGL ES 2 geht fixed Pipeline nicht.

    Bei den modernen Methoden ist es auch so .... vieles was im OpenGL Core als Mandetory spezifiziert ist, ist in OGL ES nicht zwingend. Die hardware ist da eher nicht so mit features bestückt wie die fetten intel,amd,nvidia chips. Deswegen kommt man mit dem OGL ES minimum öfters nicht hin, sondern muss mehr mit capabilities arbeiten.


Log in to reply