Einstieg OpenGL => OpenGL Tutorial

[PeterS]

Ich habe jetzt zumindest mal den Timer in mein Testprogramm übernommen.
Damit sich wenigstens was bewegt

[PeterS]

https://github.com/sechshelme/Lazarus-G ... master/DLL

Hier solltest du alles finden. Ich habe diese alle von GIMP.
Nimmst einfach die fehlenden raus.
So musst du nicht in dubiosen Seiten suchen.

Okay, das ist eine solide Quelle

Allerdings sind die DLLs alle in 64 Bit.

Screenshot (607).png (54.83 KiB) 1516 mal betrachtet

Da ich noch viel Alt-Schrott habe, codiert unter 32 Bit,
habe ich derzeit keine 64-Bit-Lazarus-Umgebung ..

[TSchnuckenbock]

Ich habe meine Programme soweit möglich alle in einer "portable"-Version auf dem Rechner. Und da ich OpenSource-Fan bin, habe ich diese Programme oftmals in mehreren Version über die Jahre angesammelt. Und ich war früher auch mit 32Bit unterwegs.

Hab eben mal geschaut, wo überall deine gesuchte libcairo-2.dll drinsteckt bzw drinsteckte:
Gramps, GnuCash, Gimp, GnuPlot, Inkscape, Wirshark, und noch ein paar andere.

Die Frage ist nun, sind das 32 oder 64 Bit-Versionen. Dazu habe ich mir die libcairo-2.dll aus dem Gimp 2.6.7 genommen und in den Dependcy-Walker geladen. Ich würde sagen,. die ist 32 Bit.

Dann habe ich im Gimp-Projekt nach der alten Version 2.6.7 geschaut (Ich hoffe ich verlinke jetzt hier den offiziellen Download):

https://download.gimp.org/gimp/v2.6/windows/

Da könnest du dir z.B. die Gimp 2.6.7 installieren in der i686-Version, von der ich annehme, daß das die 32-Bit-Version ist.
(das etwas neuere Gimp 2.6.12-i686 wird wohl eventuell auch gehen und könnte aktuellere Quellen/dlls drin haben).

Wenn man in dem verlinkten Download-Ordner bei "Parent Directory" hoch geht, dann kannst du ja mal vorher schauen, ob es vielleicht auch ein Gimp 2.8 in 32 Bit gibt.

Bei mir im installierten Gimp 2.6.7 liegen dann noch viele dlls mehr, u.a. deine gesuchten

LIBFONTCONFIG
FREETYPE6
LIBPNG (in Version 12 oder so)
ZLIB1

Ich vermute, wenn du dir dortige libcairo-2.dll im Dependency-Walker öffnest, kannste sehen, welche dll du dir noch aus dieser alten Gimp-Installationen "ziehen" mußt.

[PeterS]

Ich vermute, wenn du dir dortige libcairo-2.dll im Dependency-Walker öffnest, kannste sehen, welche dll du dir noch aus dieser alten Gimp-Installationen "ziehen" mußt.

Vielen Dank für Deine umfangreiche Recherche, das hätte ich so schnell nicht hinbekommen !


Aus meiner Ausgangs-Frage heraus kann ja niemand erahnen, was ich eigentlich vorhabe,
und unter welchen Bedingungen ich hier was realisieren möchte.

Aus anderen Projekten heraus habe ich bereits Erfahrung mit verschiedenen, meist C-basierten, DLLs.
FreeImage.dll, LibSndFile.dll, Libsamplerate.dll, Portaudio.dll, ..

Im vorliegenden Fall / Projekt möchte ich mir in Sachen OpenGL erstmal
ohne externe DLLs die nötigen Grundlagen erarbeiten.
Insbesondere weil das Tool, an dem ich zur Zeit arbeite, eh ein Mini-Programm ist.
Und da möchte ich nur ungern einen ganzen Zoo von externen DLLs mitschleppen.


Stolperstein war ja ursprünglich, daß das LCL-Beispiel von hier:
https://wiki.freepascal.org/OpenGL_Tuto ... CL_program
sich unter Windows nicht so verhält wie erwartet.

Aber das haben wir ja jetzt klar gekriegt

[PeterS]

Aus dem Tutorial-Text:
"Lazarus comes with a example OpenGL program, you can find it in the folder Lazarus/Examples/openglcontrol."

=> da werde ich als nächstes mal reinschauen.
Ich würde es vorziehen, mit Lazarus' LCL-OpenGL-TObject zu arbeiten.
In der Hoffnung daß mich das nicht zu stark einschränkt.

[EDIT] okay ...
Dieser Example-Code ist schon ein "dickes Ding" !
"written 2001 by Satan" .. das ist schon einige Zeit her.
Und viel zu Fuß programmiert, ohne LFM-Datei ... puh !

[Mathias]

Zur GDI zurück, wen man es nicht übertreibt, ist die nicht mal so schlecht.

Unter Linux, läuft es sehr fliessend. Unter Windows, wen man Vollbild macht, stottert es. Ob dies an meinem wine liegt ?

[PeterS]

Unter Linux, läuft es sehr fliessend. Unter Windows, wen man Vollbild macht, stottert es. Ob dies an meinem wine liegt ?

Ich hab's sofort herunter geladen, und compiliert.

Läuft ohne zu stottern, bei mir unter Windows 11.
Und das auf einem lahmen GEEKOM Mini-PC mit Intel(R) Celeron(R) N5105 @ 2GHz

[Mathias]

Läuft ohne zu stottern, bei mir unter Windows 11.

Dann wird es wohl an wine liegen, Es könnte sein, das echtes Windows GDI Funktionen an die GPU weiter gibt.

[TSchnuckenbock]

Ich versuche mich mal zu erinnnern, wie ich damals vor Jahren vorgegangen bin, als ich mich mit OpenGL und Delphi befasst hatte.

Viel Lesen und Ausprobieren war notwendig. Angefangen hatte ich mit Legacy-OpenGL, also quasi die "alte" Art, OpenGL zu nutzen. Dann schwenkte ich zu modernerem OpenGL um so mit Vertexbuffer, Shader etc.

Ich toaste dazu das folgende Tutorial um auf Delphi (kannst du auch als PDF dort runterladen):

https://learnopengl.com/

Das hat Mathias glaube ich fast zeitgleich gemacht und seine Quellen hier bereits verlinkt....

Auch Erik van Bilsen hat dieses Tutorial auf Delphi umgebaut:

https://github.com/neslib/DelphiLearnOp ... ingStarted

Der Code von Erik van Bilsen sagte mir nicht so ganz zu, weil man dafür auch ein modernes Delphi brauchte, was ich damals nicht hatte. Heutzutage kann man sich eine aktuelle Delphi-Community-Edition für privat holen.
Ich habe in meinem Code aber viel von Eriks Code übernommen, also quasi so ein bischen abgekupfert.

Für die Textsachen hatte ich damals dann einen FreeType-Header geschrieben, was ich auch zum Laufen bekommen hatte mit Text in OpenGL. Und das ganze mit dem Shader-Krams. Eben ausprobiert: Läuft immer noch (nun auf Win10-Rechner, der ein anderer ist).

Weitere Info-Quellen sind:

Chris Rorden (neurolabusc)

https://github.com/neurolabusc/OpenGLCoreTutorials

Der Code von Chris Rorden sieht ziemlich nach Lazarus aus.

Christian W. Budde (der auch vielen anderen tollen Stuff programmiert hat), hat wohl auch mal was bzgl. OpenCL gemacht, also "Rechnen auf der Grafikkarte":

https://github.com/CWBudde/PasOpenCL

Als dgl-Header habe ich den dglOpenGL-Header immer genutzt, irgendwie in Version 4.4. oder 4.5, wenn ich mich recht erinnere. Das DelphiOpenGL-Portal hatte hier ja einer schon verlinkt.

Sich in OpenGL einzuarbeiten ist nicht einfach, aber man wird belohnt.
Ich habe mir damals quasi so meine eigenen Klassen programmiert für dieses moderne OpenGL 3 oder wie das heißt.
Und dann geht das, wenn man erstmal eine gute funktionierende Grundkonstruktion hat.

Mit der Shader-Sprache muß man sich auch ein bischen auseinandersetzen...ist irgendwie ähnlich C oder so.

[PeterS]

Sich in OpenGL einzuarbeiten ist nicht einfach, aber man wird belohnt.

Vielen Dank für die vielen Links, das wird mir bestimmt helfen.
Große Auswahl, da sollte auch was für mich dabei sein

Was ich bisher noch nicht verstanden habe,
welchen Nutzen hat das Laz-OpenGLContext-Paket gegenüber dem zu-Fuß-programmieren ?
Kann das Lazarus-OpenGL-Paket irgendwas mehr ?
Oder nimmt es einem schlicht nur ein wenig Arbeit ab ?


[Edit] und jetzt habe ich auch noch das hier gefunden:

The following commonly used functions are all deprecated:

glBegin
glEnd
glVertex*
glNormal*
glTextCoord*
glTranslate*
glRotate*
glScale*
glLoadIdenity
glModelViewMatrix

Das heißt aus meiner Sicht daß ich mich besser auf das 3.3 Tutorial konzentrieren sollte ..

[Mathias]

Das heißt aus meiner Sicht daß ich mich besser auf das 3.3 Tutorial konzentrieren sollte ..

Wen du dich für 3D Programmierung interessierst, würde ich auf jedenfalls mit OpenGL 3.3 beginnen.
Mit der Shader-Programmierung hast du extrem viele Möglichkeiten,

welchen Nutzen hat das Laz-OpenGLContext-Paket gegenüber dem zu-Fuß-programmieren ?

Wen du meines meinst.

• Das Laden von Shadern.
• Matrix Operationen.
• Den Context für die LCL erstellen.
• Vereinfachtes Laden von Texturen.

[Mathias]

Als dgl-Header habe ich den dglOpenGL-Header immer genutzt, irgendwie in Version 4.4. oder 4.5, wenn ich mich recht erinnere. Das DelphiOpenGL-Portal hatte hier ja einer schon verlinkt.

Von dem habe ich mich gelöst und verwende jetzt den glad, da sind alle Altlasten verschwunden. glbegin und co, geht da gar nicht mehr.
Bei fpc ist auch ein GL-Header dabei aber der geht nicht bis 4.6

Für die Textsachen hatte ich damals dann einen FreeType-Header geschrieben, was ich auch zum Laufen bekommen hatte mit Text in OpenGL. Und das ganze mit dem Shader-Krams. Eben ausprobiert: Läuft immer noch (nun auf Win10-Rechner, der ein anderer ist).

Mit FreeType beschäftige ich mich momentan auch ein wenig. Dies wäre sogar bei der LCL dabei.

Was generell bei FPC sehr schade ist, das die meisten Header-Übersetzungen sehr veraltet sind. Cairo ist da ein echter Oldie.
Bei Cairo bin ich gerade dabei das neuste Paket zu übersetzen. Bei FreeType will es nicht so richtig, da sind sehr viele Sachen ineinander verschachtelt.

Noch ein Wermutstropfen. Dies schönen Sachen wie GTKx, Cairo, Freetype, SDL, etc., sind bei Linux von Hause auf dabei, bei Windows muss man zuerst alle DLLs in Werbungverseuchten Webseiten zusammen suchen und dabei aufpassen, das man keinen Trojaner erwischt. Ausser man hat ein wenig Erfahrung und nimmt zB. als Quelle GIMP. Unterdessen bin ich soweit, das ich viele DLLs selbst baue, und dies unter Linux, da die meisten Werkzeuge dafür vorhanden sind. Windows hat ja nicht mal einen gcc.

[TSchnuckenbock]

Ich hatte mir den FreeType-Header selbst geschrieben anhand der Originalquellen (C oder C++ oder so).
Den hatte ich auf dem Zettel, falls ich mal in Rente gehe, zu überarbeiten und dann OpenSource zu stellen, falls ich dazu dann noch Lust habe und FreeType überhaupt noch eine Interessengemeinde haben sollte.

In den Kommentaren meiner Quellen (Programmier-Stuff) finde ich immer mal die Info ala "von Erik Junghanns übernommen" und so. Pseudo ist bergmann89 und eines seiner Projekte ist

https://git.bergmann89.de/opengl/TextSuite

Könnte älteres OpenGL sein, aber ich hatte mir für mein Framework (modernes OpenGL) wohl einiges aus den Projekten von dem Erik Junghanns übernommen.

Ergänzung: Schau dir mal die anderen OpenGL-Projekte beim Erik Junghanns an!

Ich würde altes OpenGL nur für den Einstieg nehmen und dann möglichst schnell auf das modernere mit den Shader umsteigen.
Gezeichnet wird einfach auf ein Panel, wenn ich das recht in Erinnerung habe z,B. "pnlOpenGLCanvas".

Code: Alles auswählen

...
procedure TfrmMain.FormShow(Sender: TObject);
begin


  Application.OnIdle := ApplicationEventsIdle;

end;

procedure TfrmMain.OpenGLInit;
begin
   // OpenGL-Funtionen initialisieren (aus dem Heise-tutorial abgekupfert)

   // Zuweisung der OpenGL-Funktionszeiger
   // ....ansonsten gibts bei den ersten gl....-Aufrufen Zugriffsverletzungen (access violation)
  fOpenGLInitialized := InitOpenGL;
  if not fOpenGLInitialized then
  begin
    raise Exception.Create('OpenGL konnte nicht initialisiert werden!');

    Application.Terminate;
  end;


   // DeviceContext fürs OpenGL-Panel holen
  FCanvasDC := GetDc(pnlOpenGLCanvas.Handle);
  if FCanvasDC = 0 then
    raise Exception.Create('Device context für das Zeichen-Panel konnte nicht bestimmt werden.');


   // Renderkontext erstellen (32 Bit Farbtiefe, 24 Bit Tiefenpuffer, Doublebuffering)
   //  Der Render-Context enthält alle nötigen Informationen,
   //    die eine Zeichenfläche und die zu dieser zugeordneten Ressourcen beschreiben:
   //      * Pixelformat
   //      * Abmessungen der Zeichenfläche (Höhe, Breite, Aspekt-Ratio)
   //      * Angaben zur Lage der Datenpuffer für Farb-, Stencil-, Tiefen- und Transparenz-Informationen
   //      * Statusinformationen wie die Art und Dicke zu zeichnender Linien,
   //          die zum Zeichnen zu verwendenden Texturen sowie andere Angaben,
   //          die für das Zeichnen notwendig sind.
   //    siehe https://wiki.delphigl.com/index.php/Renderkontext
   //
   // DelphiGL: Durch Anlegen des Render-Kontext werden entsprechend
   //             Speicherbereiche im RAM und auf der Grafikkarte reserviert.
   //           WICHTIG: Das Pixelformat kann für einen DeviceKontext nur EINMAL
   //                     festgelegt werden, aber man weiss zu diesem Zeitpunkt
   //                     ggf noch nicht, ob überhaupt die gewünschten Funktionen
   //                     dafür zur Verfügung stehen.
   //                    Daher kann es sinnvoll sein, zuerst in einem "unsichtbaren Fenster"
   //                     den Rendercontext zu erzeugen um dann dort die
   //                     Erweiterungen abfrage zu können (z.B. bei Multisampling / Antialiasing)
   //
   //  - 32 Bit Farbtiefe => 4 Farbkanäle (Rot, Grün, Blau, Alpha (Transparenz)),
   //                          je 8 Bit (also 1 Byte); ermöglicht 256 Abstufungen pro Farbkanal
   //  - 24 Bit Tiefenpuffer => Einträge von0 bis 2^24 = ca. 16,7 sind mögliche;
   //                            je höher der Wert, desto feiner/genauer der Tiefentest.
   //                            Der Abstand zwischen Near- und Far-ClippingZone muß sich
   //                            muß sich diesen Bereich an Tiefenzonen teilen.
  FContext := CreateRenderingContext(FCanvasDC,                        // Device Context
                                [opDoubleBuffered],       // Optionen: Doublebuffering
                                32,                       // ColorBits: 32 Bit Farbtiefe
                                24,                       // ZBits / Größe des ZBuffer: 24 Bit Tiefenpuffer
                                0,                        // StencilBits (werden für den Stencil-Test benötigt)
                                0,                        // AccumBits: Anzahl Bits im Akkumulationspuffer
                                0,                        // AuxBuffers: Anzahl Bits im Hilfspuffer
                                0);                       // Layer: Anzahl Ebenen (gibts einen Nutzen für OpenGL ?)

   // Überprüfen, ob der Renderering-Context erzeugt werden konnten
  if (FContext = 0) then
  begin
    raise Exception.Create('Der Rendering Context konnte nicht erstellt werden.');
  end;

   // Erstellten Renderkontext aktivieren und
   //   Extenasions laden (3. Parameter (loadext: Boolean) mit Vorbelegung "true")
   //  - wglMakeCurrent
   //  - ReadExtensions
  ActivateRenderingContext(FCanvasDC, FContext);

   // Hier lesen wir Eigenschaften ein, die wohl unser Kontext hat
   // Hinweis: das funktioniert nur, wenn man bereits den Rendering-Kontext aktiviert hat !
  ReadOpenGLProperties;
end;

....
procedure TfrmMain.ApplicationEventsIdle(Sender: TObject; var Done: Boolean);
begin
       // Codesite.Send('ApplicationEventsIdle');

  // Hier ggf  ein "wglMakeCurrent" machen, falls man mit mehreren
  //             GL-Contexten arbeitet (also mehrer Windows).
  //            Am Ende der Methode hier dann ein
  //
  //        wglMakeCurrent(NULL, NULL);
  //
  //      Quelle:   https://www.khronos.org/opengl/wiki/Platform_specifics:_Windows#Multiple_Windows



  // Erik va. Bilsen setzt hier den ViewPort
  //             (ich hatte es bisher im FormShow gemacht)
  { Define the viewport dimensions }
  glViewport(0, 0, pnlOpenGLCanvas.Width, pnlOpenGLCanvas.Height);

   // Render
   // Clear the colorbuffer
  glClearColor(0.2, 0.3, 0.3, 1.0);
  glClear(GL_COLOR_BUFFER_BIT);

   { Erik van Bilsen:
      Draw the triangle
   }
  if assigned(FShader) then
    FShader.Enable;

  if assigned(FVertexArray) then
    FVertexArray.Render;

{ jetzt wohl altlast
  if assigned(FVAO) then
    FVAO.Render;
}

  if assigned(FShader) then          // gibts so nur bei Erik Junghanns
    FShader.Disable;


  SwapBuffers(fCanvasDC);   // Swap the screen buffers
                            // (Erik. v. B. nutzt "Windows.SwapBuffers(..)",
                            //   um seine Multi-Platform-Implementierung umzusetzen)

   // Windows denken lassen, das wir noch nicht fertig wären
   // ...dadurch wieder kontinuierlich neu gezceihnet
  Done := False;

[Mathias]

Ergänzung: Schau dir mal die anderen OpenGL-Projekte beim Erik Junghanns an!

Wen man die LCL verwendet, würde ich den TOpenGLControl von Lazarus verwenden und den Context zu erzeugen.

[PeterS]

In den Kommentaren meiner Quellen (Programmier-Stuff) finde ich immer mal die Info ala "von Erik Junghanns übernommen" und so. Pseudo ist bergmann89 und eines seiner Projekte ist

https://git.bergmann89.de/opengl/TextSuite

Blöd daß sämtliche Beispiel-Projekte - wenn sie denn compilieren - nur ein leeres Fenster zeigen, unter Windows.
Ohne Detail-Kenntnisse kriegt man das nicht zum laufen.

Aber das Archiv ist ja auch schon über 7 Jahre ungepflegt im Netz ..