Ich habe mir mein erstes Programm mit OpenGL 3 aus diversen Tutorials zusammengewürfelt.

Bin ich da auf den richtigen Weg für OpenGL 3 ?
Ich kann mir vorstellen, das es gravierende Fehler enthält.

Ein Fehler hat es sowieso, das Dreieck ist nicht farbig sondern nur weiss.

Programmiert ist es in Lazarus.

Ich hoffe mir kann weiter geholfen werden, ich will meine zukünftitge Programm auf einer Fehlerfreien Basis aufbauen.

Danke im voraus.

_________________
OpenGL

Du hast zwei VBO's in die du die Daten speicherst. Du musst beides in ein Array, bzw. VBO speichern:

{Vertex1,Color1,Vertex2,Color2,...,Vertexn,Colorn}

und dann mittels glVertexAttribPointer angeben wo die Color-Daten in deinem VBO (einem!) liegen.

Außerdem sind glTranslatef und generell alle Matrix-Befehle deprecated, für OGL 3 solltest du die durch eigene Funktionen ersetzen, was aber für den Anfang erstmal unwichtig ist

_________________
offizieller DGL Compliance Beauftragter
Never run a changing system! (oder so)

Das sieht mir nicht nach OpenGL3 aus. Zum Erstellen eines Kontexts mit Version 3.0 oder höher musst du auf Windows irgendwo die Funktion wglCreateContextAttribsARB aufrufen. Das sehe ich in deinem Code nicht. Kann aber auch sein, dass der DGL-Header das auf Wunsch übernimmt, da kenne ich mich nicht mit aus.

Die zweite Sache, die auffällt ist, dass du offenbar keine Shader verwendest. Das ist bei OpenGL3+ aber Pflicht. Der würde dann auch die Farbe festlegen. Meiner Meinung nach taugt das Tutorial_glsl immer noch ganz gut zum Erlernen von GLSL. Die Sprache hat sich nicht soo grundsätzlich geändert. Die wesentlichen Änderungen sind:

• Alle eingebauten Variablen sind verschwunden (Ausnahme: gl_Position und gl_PointSize im Vertexshader, gl_FragCoord im Fragmentshader und wenige andere). Sie werden nun bei Bedarf selbst deklariert und übergeben.
• Statt attribute wird im Vertexshader nun in geschrieben.
• varying gibt es nicht mehr. Stattdessen werden diese Variablen im VS mit out und im FS mit in deklariert.
• In der ersten Zeile jedes Shaders wird nun eine #version-Direktive geschrieben, z.B. #version 330 oder #version 120
• Da die OpenGL-Funktionen zum Verwalten der Shader inzwischen im Kern angekommen sind, fällt natürlich das ARB am Ende weg.

Die Matrixfunktionen (glMatrixMode, glLoadIdentity, glRotatef, gluPerspective usw.) gibt es ebenfalls nicht mehr in OpenGL3. Du musst die Matrizen mit glUniform an den Shader weitergeben.

_________________
So aktivierst du Syntaxhighlighting im Forum: [code=pascal ][/code], [code=cpp ][/code], [code=java ][/code] oder [code=glsl ][/code] (ohne die Leerzeichen)

Leider kann ich dir konkret nicht weiterhelfen, weil ich mir mit der fixed Pipeline nicht mehr ganz sicher bin.
Allerdings möchte ich die dich daraufhinweisen, das du nicht reines OpenGL 3 nutzt!
Mit VBOs bist du schonmal auf einen guten Weg.
Damit das nicht passiert, dass du versehentlich(?) ohne es zu merken deprecated Zeug benutzt, möchte ich dich nochmal auf meinen Tipp hinweisen, einen Grafikkontext im Core Profile zu erstellen. Wie das bei dir in deinen Contextcreator funktioniert, kann ich dir leider nicht sagen, weil ich selber nur GLFW nutze. Am Besten einfach in die Dokumentation schauen und danach suchen.

Du solltest auf jedenjall die integrierten Matrixfunktionen und die fixed Pipeline raushauen und stattdesen Shader einsetzen, wenn du es richtig machen willst.

EDIT:
glAwesome war schneller.

Bei den Shadertutorial gebe ich dir prinziell auch recht, denke aber auch, dass ein Neueinsteiger durch die vielen feinen Unterschiede bloß unnötige Fehler einhandelt und dadurch verwirrt wird. Wer es gerne Deutsch hat, kann das Tutorial gut als ersten Einstieg in das Thema durchlesen und nach Grundkenntnissen und dem Wissen über die Änderungen, das Tutorial als Nachschlagwerk für Funktionen verwenden, jedoch für den ersten soliden Einstieg in GLSL Code in der Praxis, würde ich doch das bereits in einen anderen änlichen Thema von mir verlinkte Tutorial hier empfehlen:
www.lighthouse3d.com/tutorials/glsl-core-tutorial
Das fand ich persönlich sehr gut auch mit vielen Codebeispielen und man braucht keine Sorgen haben, dass irgendetwas veraltet ist. Sogar Tesselation wird kurz angesprochen, wenn auch nicht verwendet.

Die GLU-Funktionen wurden übrigens auch alle in OpenGL 3 entfernt.

Schön währe, wen man einen Quelltext für eine Delphi Formular in OpenGL 3.x finden würde, auf dem man aufbauen könnte.

Von dem ihr oben schreibt verstehe ich nur Bahnhof.

Von OpenGL 1.x finde man viele solche Quelltexte, auf denen hatte ich meine sämtlichen Programme aufgebaut. Unter anderem auch in eurem Tutorial.

_________________
OpenGL

Delphiquelltexte wirst du nicht kaum finden, aber OpenGL ist ein Standard der in allen Programmiersprachen gleich aussieht. Die meisten interessanten Sachen sind in C(++) geschrieben. Rudimentäre Kenntnisse über die Sprache brauchst du eh, weil auch GLSL eine C-Sprache ist.

Was verstehst du denn nicht? Sind irgendwelche Begriffe unklar? So allgemein gestellt, fällt es mir schwer, darauf eine hilfreiche Antwort zu geben.

Ich würde dir einfach mal empfehlen ein modernes Tutorials durchzugehen. Welche Programmiersprache sollte egal sein, auch wenn es dann vielleicht im ersten Moment etwas ungewohnt aussieht vom Syntax. Bei Problemen die sich auf Delphi beziehen, kann dir da auch nicht weiterhelfen, weil ich von Delphi keine Ahnung habe. Ich kann höchstens die Quelltexte nachvollziehen.

Nun ja den speziellen Context musst du nicht unbedingt aufsetzen (jedenfalls soweit ich weiss). Der Allgemeine Context (so wie er jetzt ist) ist auf jedenfall ne ganze Ecke entspannter
wenn es z.B. um verschiedene Codepaths gehts. Aber egal. Mir scheint eher das du Probleme mit der neuen Arbeitsweise von OpenGL hast von daher fang ich mal beim Urschleim (Code Beispiele sind ES ... also nicht unbedingt fuer Desktop) an:


Die GL_ARRAY_BUFFER sind im Prinzip genau wie die Vertex (usw.) Pointer. Nur halt schneller, flexibler und besserer . Beiden uebergibst du ein Array von, normalerweise, GLFloat. Das geschieht ganz einfach ueber:


jetzt musst du OpenGL nur noch mitteilen wie deine Daten aufgebaut sind. Wenn du dir z.B. folgende Struct vorstellst:

Dann waere dein Array wie folgt aufgebaut:

Du musst OpenGL also mitteilen das die Vertexposition jeweils an der 0+7*i,1+7*i,2+7*i Stelle liegen und deine Farben an 3+7*i,4+7*i,5+7*i,6+7*i liegen. Das ganze sieht dann wie folgt aus:



wobei DEINPOSITIONATTRIBUTEINDEX und DEINPCOLORATTRIBUTEINDEX fixxe integer sind die von GLSL nachher fuer die attribute Variablen verwendet werden. Am besten du machst dir einen enum:


Kurz vor den Uniforms bindest du die Attribute dann an deinen Vertexshader per glBindAttribLocation:


Alles zusammen ergibt also:


Beim Zeichnen bindest du einfach dein Array und zeichnest deine Punkte:



und im Vertexshader holst du dir Attribute dann ueber das "attribute" Schluesselwort (aehnlich wie Uniforms):


Im Shader kannst du dann mit den Sachen rumspielen wie du lustig bist

_________________
Meine Homepage

Müssen tut man nichts. Sinnvoll ist es aber.
Sonst bekommt man nichtmal mit, wenn man veraltete Funktionen nutzt, das ist gefährlich und sinnlos.


Beim Programmieren geht es in erster Linie nicht um Entspannung sondern um gute Software. Die zukünftige Kompatiblität wird jedenfalls darunter leiden. Ohne die Einstellung wirklich nur reines modernes OpenGL zu verwenden erfordert schwere Selbstdisziplin und Informationen die man im Internet nur mühsam findet.


Wenn man irgendwann einen anderen Renderpath einbauen will, ist es auch keine große Sache: Man setzt ganz einfach dabei das Flag(?) für OpenGL Core beim Initialisieren des Kontexts nicht mehr und gut ist. Wirklich keine große Sache. Andersrum, den Core einzuschalten, sollte auch keine größere Sache sein. Ich weiß leider nur nicht, wie es bei ihm geht.


Das Entscheidende: Die Daten werden im schnellen Speicher der Grafikkarte gespeichert. Gerade Daten die nicht häufig geändert werden, können massiv davon profitieren. Bei Vertexdaten die sich pro Frame ändern, ist der Vorteil klein bis nicht vorhanden.


Nein, das ist veraltet. Man muss in GLSL der Version 3 das jetzt mit "in" und "out" machen. Eigentlich ein kleiner Unterschied aber für einen Einsteiger ein Großer: Führt zur Verwirrung.

Gerade ein Anfänge oder (Neu)Einsteiger hat die ideale Gelegenheit es gleich vernümpftig zu lernen.

@mathias
Arbeite doch einfach mal ein OpenGL 3 Tutorial deiner Wahl von vorne durch. Im anderen Thread wurden ja bereits zwei verlinkt. Wenn du dann irgendetwas darin nicht verstehst, frägst du dazu nochmal nach.

Ich verstehe nur noch Bahnhof.

Ich habe mal versucht 2 Dreiecke zu zeichnen, dies geht auch nicht.
Es währe schön wen man mal eine Basis hätte. Am besten mit 2 Dreiecke die farbig sind.

Mit glbegin, vertex2f glcolor3f war es so einfach, ich kann mir kaum vorstellen, das OpenGL 3.0 so schwer zu verstehen ist.

_________________
OpenGL

Bei deinem ersten glGenBuffers übergibst du eine "0". Der erste Parameter ist aber kein Index sondern die Anzahl. siehe glGenBuffers

Kenne mich mit den VBOs zwar noch überhaupt nicht aus, aber ich schätze, dass man vor einem glDrawArray mindestens glBindBuffer aufrufen muss, damit OGL weiß welchen Buffer es überhaupt zeichnen soll.

Außerdem solltest du bei "glRotatef(Winkel, 0, 0, 0);" eine Achse wählen um die du drehen möchtest. Etwa die y-Achse "glRotatef(Winkel, 0, 1, 0);"

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Was heißt denn schonwieder, du verstehst nur noch Bahnhof?
Der Immediate Mode wurde entfernt, weil unflexibel ist, langsam (Mehrere virtual calls pro Vertex + Overhead), redundant und auf komplex im Treiber ist.

Mit deinen aktuellen Code bist du erst auf halben Weg zum Ziel.
OpenGL 3.0 ist nicht schwerer zu verstehen, es unterscheidet sich bloß ziemlich von den Praktiken/Anforderungen die vor 10 Jahren modern/günstig waren.
Du bist außerdem auf keinen der genannten Kritikpunkte am Code eingegangen.
Mach es doch einfach mal für den Anfang genauso wie in einen der Tutorials: (Ich habe das Gefühl, mich zu wiederholen...)
www.opengl-tutorial.org
Da liest du dir mal wenigstens den "Basic"-Teil durch, übernimmst einfach den Code und experimentierst dann damit rum. Das erste Kapitel wird bei dir wahrscheinlich anders funktionieren, weil du ja mit Delphi arbeitest. Kontext hast du ja auch selber schon irgendwie erstellt, wenn auch keinen für OGL3 empfohlenen, im "Core-Modus".
Es werden da alle Philosophien aus dem neuen OpenGL erklärt und es gibt wirklich viel Code auch zwischen drin, denn man gut als Basis verwenden kann.

Ansonsten: Wenn du nicht mehr Eigeninitiative ergreifst und deine Verständisprobleme hier genauer vorträgst, wird dir niemand beim Umstieg helfen können!

den link würde ich nicht empfehlen,

sondern wieder http://arcsynthesis.org/gltut/

is sicher wieder Geschmackssache

Der Link sollte auch gut sein.
Es gibt sicher noch weitere OpenGL 3 Tutorials. Wichtig ist eigentlich nur die 3...

Ich habe mir den Quelltext von dem Tutorial angeschaut. und möglichst viel übernommen.
http://www.opengl-tutorial.org/beginner ... ored-cube/

Immerhin kann ich jetzt 2 Dreiecke darstellen, aber die Farbe will immer noch nicht.

Hat das etwa mit dem Shader zu tun, LoadShaders( "TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader" ); kennt dglOpenGL nicht.
Und MatrixID hat was mit der Kamera zu tun oder ?

_________________
OpenGL

Also, die Methode "LoadShaders" ist keine OpenGL Funktion sondern scheinbar eine Hilfsfunktion von der Tutorialseite.
Das erkennt man auch daran, dass kein "gl" als Präfix im Funktionsnamen ist.
Der Quellcode der Hilfsmethode, steht in Kapitel 2 ungefähr nach der Mitte der Seite.
Ich weiß nicht wie gut deine C++ Hintergrundkenntnisse sind, deshalb noch ein paar Hinweise vorweg:

1. "printf"-Funktionen geben den Text einfach auf der Konsole aus zu Debugzwecken. Die Funktion ist eigentlich C und hat mit C++ nichts zu suchen. Kein guter Codestil... Naja sollte dir als Delphinutzer egal sein.
   
2. Beim "Read the * Shader code from the file" wird einfach der Code aus den übergebenden Dateinamen eingelesen in denen du den Shaderquellcode gespeichert hast und in den entsprechenden "*ShaderCode"-String-Variablen gespeichert.
   
3. "std::vector<char>" ist einfach ein ASCII-Buchstaben-Array der Länge die anschließend in den Klammern angegeben ist. Man könnte also auch einfach einen String nehmen.

Zu den genauen Delphiäquivalenten des Codes, kann ich dir leider echt nichts sagen, weil ich von der Sprache wenig Ahnung habe.