Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Do Mär 28, 2024 15:47

Foren-Übersicht » Programmierung » Einsteiger-Fragen
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 58 Beiträge ]  Gehe zu Seite 1, 2, 3, 4  Nächste
Autor Nachricht
BeitragVerfasst: Di Jan 06, 2015 13:08 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Hallo zusammen,

Ich arbeite derzeit an einem (kommerziellen) Tool, das für 2D Grafiken 3D Information generiert, in Form von Normal Maps.
Das Tool wird in Lazarus programmiert, und wird für Windows, Mac und Linux verfügbar sein.
Bei der Berechnung der Normal Maps und auch für das integrierte Pseudo-3D-Vorschaufenster sind natürlich einige leistungsintensive Textur-Berechnungen notwendig, die momentan alle von der CPU durchgeführt werden, was besonders bei größeren Bildern zu schwerwiegenden Leistungsproblemen führt.
Wünschenswert wäre es natürlich, viele dieser Berechnungen mithilfe der Grafikkarte durchzuführen - GLSL shader wären dafür vermutlich die beste Lösung.

Mit OpenGL habe ich wenig Erfahrung, ich habe mir die die Tutorials im DGL Wiki angesehen und teilweise ausprobiert, habe mich ein wenig mit dem dglOpenGL Header, SDL, GLScene, Sascha Willems' GLSL Beispielen und einigen anderen Lösungen befasst, bin bisher aber auf keinen grünen Zweig gekommen.

Was ich suche, ist eine einfache Lösung, um entweder in Lazarus GLSL Shader zu verwenden, oder aber zumindest einen Teil der Berechnungen mit OpenGL durchzuführen, wobei es auf zwei Dinge besonders ankommt:
- die Lösung muss für Windows, Mac und Linux funktionieren
- keine Restriktionen durch die Lizenzbestimmungen, die z.B. dazu führen daß das Programm OpenSource sein muss

Das vielversprechendste was ich bisher hinbekommen habe, war, mithilfe des Lazarus-internen TOpenGLControl eine 2D Textur auf ein Quad zu zeichnen und die Größe beliebig zu verändern.

Mir ist klar daß ich so etwas wie eine eierlegende Wollmilchsau suche und möglicherweise gibt es keine einfache und umfassende Lösung für mein Problem, allerdings dachte ich (da Zeit auch ein wesentlicher Faktor ist), bevor ich mich jetzt noch einige Wochen/Monate intensiver mit OpenGL Programmierung und deren Einbindung in Lazarus beschäftige, um am Ende festzustellen, daß ich in einer Sackgasse gelandet bin, frage ich hier mal die Experten um Rat.

Beste Grüße,

Dennis


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Di Jan 06, 2015 13:40 
Offline
DGL Member
Benutzeravatar

Registriert: Di Dez 27, 2005 12:44
Beiträge: 393
Wohnort: Berlin
Programmiersprache: Java, C++, Groovy
Hallo,

für deine Zwecke dürften Framebuffer Objects (FBOs) das richtige Mittel der Wahl sein. Du renderst dein Ergebnis einfach offscreen in eine Textur und liest diese dann mit glGetTexImage wieder aus. Du musst allerdings auf die Texturgröße achten, es gibt da gewisse Hardwarebeschränkungen (siehe Punkt 21.130). Die kannst du aber umgehen, wenn du deine Grafik in mehrere kleinere Einheiten aufteilst.

Viele Grüße
dj3hut1

_________________
Wenn Gauß heute lebte, wäre er ein Hacker.
Peter Sarnak, Professor an der Princeton University


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Di Jan 06, 2015 17:02 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

solche Tools gibt es schon. Spontan fallen mir da CrazyBump und ShaderMap ein. Ich hab damals auch ein Freeware Tool geschrieben was das kann: BumpMapGenerator also gibt es auch im Freeware Sektor etwas, was man gut nutzen kann. Aus rein wirtschaftlicher Sicht frag ich mich jetzt: Warum noch ein kostenpflichtiges Tool? Was unterscheidet dein Tool von den genannten?

BTT: Wir haben einen relativ einfache Klassen-Sammlung für die wichtigsten OpenGL Objekte: OpenGL Core. Der ist allerdingt unter der MPL veröffentlicht. Du kannst dir das ja trotzdem mal angucken. Support ist zur Zeit für Windows und Linux gegeben. Für Mac haben wir keine Testumgebung, das sollte aber auch relativ schnell nachgepflegt sein. Da ich sozusagen der leitende Entwickler des Projekts bin lässt sich da gg. eine kleine Spende sicher auch was mit der Lizenz machen ;)

MfG Bergmann.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Do Jan 08, 2015 16:43 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Danke für die Tipps.

@dj3hut1: Framebuffer Objects habe ich mir angesehen, hatte auch schon davon gehört, allerdings scheinen diese auch nur mit dem dglopengl Header benutzbar zu sein - mit nur GL und OpenGLContext in der uses Klausel wurden bei mir die Befehle von Deathball's Tutorial nicht erkannt.

@Bergmann89:
Ich habe schon gehofft, von Dir einen Rat zu bekommen, habe Deinen BumpMapGenerator auch schon vor einiger Zeit entdeckt und ausprobiert (hat alles bestens funktioniert, nur das 3D Preview ist mir immer nach ein paar Sekunden Bildschirmflackern abgestürzt mit einer NVIDIA OpenGL Driver Fehlermeldung, was an meinen Grafikkartentreibern liegen könnte).

Das ganze OpenGLCore Paket habe ich auch schon ausprobiert, konnte dieses aber nicht zum Laufen bringen, zumindest nicht zusammen mit meinem bisherigen experimentellen OpenGLContext Kuddelmuddel.
Wahrscheinlich sollte ich mich nochmal von Grund auf mit dem OpenGLCore Paket befassen, ohne dabei alle möglichen anderen Dinge rein zu mischen, das scheint sich ja zu lohnen, wenn sogar Mac Unterstützung theoretisch möglich wäre.

Der Tutorial Bereich ist leider auch (für Anfänger wie mich) etwas unübersichtlich gestaltet, es ist nie so richtig klar mit welchen Units nun eigentlich gearbeitet wird und was dem aktuellen Stand der Technik entspricht.
Gibt es irgend ein umfassendes und aktuelles Tutorial für das OpenGLCore Paket, mit dem ich das was ich für meine Zwecke brauche, schrittweise lernen könnte (vorzugsweise mit Beispielprogrammen), oder wenigstens eines, das die ersten Schritte anfängerfreundlich erklärt?

Ich bedanke mich auf jeden Fall ganz herzlich für die Ratschläge und die Offenheit.

Zu der Frage nach dem Sinn meines Tools noch:
Ich weiß daß es einige gute Normal Map Generatoren gibt, sowohl im kommerziellen als auch im Freeware-Sektor.
Meines unterscheidet sich von den bekannten dadurch daß es direkt für Sprites Normal Maps generiert, ohne daß man dafür zusätzliche Maps erstellen muss.
Klar, das können Normal Map Filter für z.B. GIMP oder Programme wie Crazybump auch, allerdings taugen diese nur dazu, für Texturen einen Relief-Effekt zu erzeugen, während mein Tool Figuren/Objekte in Sprites plastisch macht, durch eine Art "Aufblas-Effekt".
Wer Genaueres wissen und sehen will, kann sich ja mal die Kickstarter-Seite dazu ansehen: Sprite DLight Kickstarter

Ein kleines Bild zum Vergleichen herkömmlicher 1-click-Normal-Map-Generatoren und meines Tools:
Bild

(1: Originalbild, 2: GIMP-Filter Normal Map, 3: von einem herkömmlichen Tool erzeugte Normal Map auf Grundlage einer Depth Map die aus dem Originalbild erzeugt wurde, 4: Normal Map von meinem Tool erzeugt)


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Do Jan 08, 2015 17:29 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
Hey,

wie du schon gesagt hast solltest du den OpenGLCore nicht mit dem Lazarus OpenGLContext verwenden. Der OpenGLCore hat seine eigenen Context-Klassen. Ein komplettes Tutorial für OpenGL kann ich dir leider nicht anbieten, aber zu den heut zu Tage verwendeten Techniken findest du einige Artikel in unserem Wiki. Du musst nur wissen wonach du suchen musst. Hier mal einige Stichworte die für dich intressant sein könnten:
Die Einsteiger-Tutorials sind aber nach wie vor wichtig, da sie ein Grundverständnis für OpenGL vermitteln.

Kleine Beispiele wie man die einzelnen Units des OpenGL Cores nutzt stehen am Anfang der jeweiligen Unit, oder auf der Projekt-Homepage. Wenn man die grundlegende Technik dahinter verstanden hat (sie Links aus der Liste) dann sind die Klassen aber eigentlich selbst erklärend.

Nochmal zu deinem Projekt: Sieht gut aus. Für Sprites hab ich sowas wirklich noch nicht gesehen. Im 3D Bereich braucht man sowas selten, da ja dort die "Rundung" des Objekts vom Mesh kommt und mit dem BumpMapping nur die Details erzeugt werden. Auch schon 16k$ bei Kickstarter, nicht schlecht, da hast du ja für das nächste halbe Jahr erstmal ausgesorgt :mrgreen:

MfG Bergmann

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Fr Jan 09, 2015 09:45 
Offline
DGL Member
Benutzeravatar

Registriert: Di Dez 27, 2005 12:44
Beiträge: 393
Wohnort: Berlin
Programmiersprache: Java, C++, Groovy
@Dee Wenn du plattformübergreifend programmieren willst, könnte ich dir JOGL und LWJGL empfehlen, aber du bist wahrscheinlich kein Java-Programmierer...

_________________
Wenn Gauß heute lebte, wäre er ein Hacker.
Peter Sarnak, Professor an der Princeton University


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mo Jan 12, 2015 17:40 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Herzlichen Dank für die Links und Tipps.
Das meiste davon hatte ich mir schon angesehen (allerdings ohne viel davon zu verstehen).
Habe auch schon mit manchen von den Beispielen in den Units des OpenGL Core herumprobiert, aber vermutlich fehlt mir einfach zuviel vom Basiswissen um alles im richtigen Kontext anzuwenden.
Z.B. habe ich versucht, das Beispiel der Unit uglcFrameBufferObject zu testen, habe dazu nach etwas Herumprobieren herausgefunden daß man die Units dglopengl, uglcFrameBufferObject und uglcTypes in die Uses Klausel mit aufnehmen musst, habe dann den Beispielcode in eine ButtonClick Prozedur gepackt und prompt einen SIGSEGV bekommen beim Klicken des Buttons.
Ich nehme an, ich hätte evtl. vorher eine Textur laden müssen, mithilfe der glBitmap Unit.
Es is halt sehr schwierig für einen Anfänger, zu wissen wo man suchen und anfangen soll.

Ein kleines Codebeispiel, das zeigt wie man eine Bitmap in OpenGL lädt und z.B. einen einfachen Weichzeichner darauf anwendet, um sie hinterher wieder als Bitmap auszugeben, wäre natürlich perfekt - also wenn irgendwer zufällig etwas entsprechendes herumliegen hat: immer her damit ;)

@dj3hut1: Danke für die Tipps, aber Java-Programmierer bin ich noch weniger als OpenGL Programmierer ;)
Abgesehen davon ist das Projekt schon so umfassend, daß es Monate kosten würde, alles nochmal neu in einer anderen Programmiersprache zu schreiben.

Zum Kickstarter noch:
Klar sieht die Zahl erstmal beeindruckend aus, und ich bin auch mehr als glücklich mit dem Ergebnis, was total unerwartet kam - mein Ziel war $2.200 und dementsprechend simpel war das Tool ursprünglich auch geplant, aber durch das ganze Interesse, das sich mittlerweile entwickelt hat, sind natürlich auch die Ansprüche deutlich gestiegen.
Ich muss auch dazu sagen daß man die Summe, die als großes Endresultat dran steht, nicht in dieser Höhe bekommt, da einige Leute noch nachträglich herausfallen (wegen fehlerhafter Kreditkareninformationen), und da Amazon und Kickstarter auch einen Anteil einkassieren - auf den Rest fallen natürlich noch Steuern an.

Um eine grobe Vorstellung davon zu bekommen wie die Sprites in 3D aussehen, wäre das momentane Daumenkino-Vorschaufenster schon ausreichend, allerdings wäre eine flüssige Vorschau schon deutlich professioneller, und ich hatte ja auch die Hoffnung daß komplexe 2D-Berechnungen die für das Generieren der Normalen notwending sind, mit OpenGL um einiges schneller und stabiler möglich wären.
Nach allem was ich bisher gehört habe, scheint der (Zeit- und Lern-)Aufwand aber unverhältnismäßig hoch zu sein - ich habe als groben Veröffentlichuns-Zeitraum das Frühjahr 2015 angegeben.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mo Jan 12, 2015 19:11 
Offline
DGL Member
Benutzeravatar

Registriert: Di Apr 29, 2008 18:56
Beiträge: 1213
Programmiersprache: Delphi/FPC
zu der SIGSEGV:
ich nehme an, das du keinen gültigen Kontext erstellt und gebunden hast. Der läd die OpenGL Funktionen dynamisch nach. Davor sind alles Null-Pointer.

zum Plan:
Ohne dir den Wind aus den Segeln nehmen zu wollen, als Anfänger wirst du das im Frühjahr 2015 nicht schaffen. Ich könnte dir da aber evtl ne Art Crash-Kurs anbeiten^^ Hatte dir letztens schonmal ne PN mit meinem Skype-Namen geschickt.

_________________
Aktuelle Projekte: BumpMapGenerator, Massive Universe Online
Auf meiner Homepage gibt auch noch paar Projekte und Infos von mir.


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Di Jan 13, 2015 18:10 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Zitat:
@dj3hut1: Framebuffer Objects habe ich mir angesehen, hatte auch schon davon gehört, allerdings scheinen diese auch nur mit dem dglopengl Header benutzbar zu sein - mit nur GL und OpenGLContext in der uses Klausel wurden bei mir die Befehle von Deathball's Tutorial nicht erkannt.

Ich habe in meinen Code auch dglOpenGL und OpenGLContext, das das alt GL brauche ich nicht.

Der Code läuft unter Window und Linux.

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mi Jan 14, 2015 22:05 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Ja, ich habe keinen gültigen Kontext erstellt, sondern einfach ganz naiv den Beispielcode kopiert und eingefügt - kein Wunder daß es nicht funktioniert hat.
Wie man einen Kontext erstellt mit den hier benutzten Units erschließt sich mir leider auch nicht, die Einsteiger Tutorials sind hierbei wohl auch nicht von großem Nutzen, da dort mit SDL oder der VCL gearbeitet wird, und nicht mit dglOpenGL.

Danke für den Hinweis daß ich die OpenGL Einbindung als Anfänger bis zum Frühling wohl nicht schaffe, ich hatte es schon vermutet.
Ein kleiner Crashkurs wäre natürlich toll, wenn das ganze Vorhaben aber sowieso dermaßen ausufern würde daß ich mehrere Monate dazu rechnen müsste, ist es vermutlich besser, bei den langsamen CPU Abläufen zu bleiben und die Zeit in andere Baustellen des Tools zu investieren.
Ich danke auf jeden Fall für die Beratung - es hätte ja immerhin sein können daß es möglich ist, aus ein paar zusätzlichen Units und Codeschnipseln aus unterschiedlichen Tutorials etwas zu basteln, was zumindest einen Bruchteil der Berechnungen beschleunigen würde, ohne dafür den kompletten Überblick haben zu müssen ;)


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Mi Jan 14, 2015 22:33 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Willst du einen einfachen OpenGL 3.3 Code, welcher mit dglOpenGL und OpenGLContext arbeitet ?
Es hat auch einen ganz einfachen Shader.

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Do Jan 15, 2015 19:12 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
mathias hat geschrieben:
Willst du einen einfachen OpenGL 3.3 Code, welcher mit dglOpenGL und OpenGLContext arbeitet ?
Es hat auch einen ganz einfachen Shader.

Sehr gerne. Ich bin dankbar für alles was ein wenig Licht (und Shaders) ins Dunkel bringt ;)


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Do Jan 15, 2015 20:04 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Ich hoffe du kommst mit dem Code zurecht.

Der Timer ist Interval 10.

Der Shader im Code ist so ziehmlich das einfachste das es gibt.
Aber hier geht es erst mal drum, wie man überhaupt eine Shader einbindet.

Code:
  1. unit Unit1;
  2.  
  3. {$mode objfpc}{$H+}
  4.  
  5. interface
  6.  
  7. uses
  8.   Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
  9.   OpenGLContext, dglOpenGL;      // Die 2 Units für OpenGL
  10.  
  11. type
  12.  
  13.   { TForm1 }
  14.  
  15.   TForm1 = class(TForm)
  16.     Timer1: TTimer;
  17.     OpenGLControl1: TOpenGLControl;
  18.     procedure FormCreate(Sender: TObject);
  19.     procedure FormDestroy(Sender: TObject);
  20.     procedure FormPaint(Sender: TObject);
  21.     procedure FormResize(Sender: TObject);
  22.     procedure Timer1Timer(Sender: TObject);
  23.   private   { private declarations }
  24.     procedure InitScene;
  25.     procedure RenderScene;
  26.   public        { public declarations }
  27.     ProgramID: GLuint;
  28.   end;
  29.  
  30. var
  31.   Form1: TForm1;
  32.  
  33. implementation
  34.  
  35. {$R *.lfm}
  36.  
  37. { TForm1 }
  38.  
  39. type
  40.   TVertex3f = array[0..2] of GLfloat;
  41.   TFace = array[0..2] of TVertex3f;
  42.  
  43. const
  44.   Triangle: array[0..0] of TFace =
  45.     (((-0.4, 0.1, 0.0), (0.4, 0.1, 0.0), (0.0, 0.7, 0.0)));
  46.   Quad: array[0..1] of TFace =
  47.     (((-0.2, -0.6, 0.0), (-0.2, -0.1, 0.0), (0.2, -0.1, 0.0)),
  48.     ((-0.2, -0.6, 0.0), (0.2, -0.1, 0.0), (0.2, -0.6, 0.0)));
  49.  
  50. type
  51.   TVB = record
  52.     VAO,
  53.     VBO: GLuint;
  54.   end;
  55.  
  56. var
  57.   VBTriangle, VBQuad: TVB;
  58.  
  59. function Initshader(VertexDatei, FragmentDatei: string): GLuint;
  60. var
  61.   StringList: TStringList;
  62.   Str: ansistring;
  63.  
  64.   ProgramObject: GLhandle;
  65.   VertexShaderObject: GLhandle;
  66.   FragmentShaderObject: GLhandle;
  67.  
  68.   ErrorStatus, InfoLogLength: integer;
  69.  
  70. begin
  71.   StringList := TStringList.Create;
  72.   ProgramObject := glCreateProgram();
  73.  
  74.   // Vertex - Shader
  75.  
  76.   VertexShaderObject := glCreateShader(GL_VERTEX_SHADER);
  77.   StringList.LoadFromFile(VertexDatei);
  78.   Str := StringList.Text;
  79.   glShaderSource(VertexShaderObject, 1, @Str, nil);
  80.   glCompileShader(VertexShaderObject);
  81.   glAttachShader(ProgramObject, VertexShaderObject);
  82.  
  83.   // Check  Shader
  84.  
  85.   glGetShaderiv(VertexShaderObject, GL_COMPILE_STATUS, @ErrorStatus);
  86.   if ErrorStatus = GL_FALSE then begin
  87.     glGetShaderiv(VertexShaderObject, GL_INFO_LOG_LENGTH, @InfoLogLength);
  88.     SetLength(Str, InfoLogLength);
  89.     glGetShaderInfoLog(VertexShaderObject, InfoLogLength, @InfoLogLength, @Str[1]);
  90.     Application.MessageBox(PChar(Str), 'OpenGL Vertex Fehler', 48);
  91.     Halt;
  92.   end;
  93.  
  94.   glDeleteShader(VertexShaderObject);
  95.  
  96.   // Fragment - Shader
  97.  
  98.   FragmentShaderObject := glCreateShader(GL_FRAGMENT_SHADER);
  99.   StringList.LoadFromFile(FragmentDatei);
  100.   Str := StringList.Text;
  101.   glShaderSource(FragmentShaderObject, 1, @Str, nil);
  102.   glCompileShader(FragmentShaderObject);
  103.   glAttachShader(ProgramObject, FragmentShaderObject);
  104.  
  105.   // Check  Shader
  106.  
  107.   glGetShaderiv(FragmentShaderObject, GL_COMPILE_STATUS, @ErrorStatus);
  108.   if ErrorStatus = GL_FALSE then begin
  109.     glGetShaderiv(FragmentShaderObject, GL_INFO_LOG_LENGTH, @InfoLogLength);
  110.     SetLength(Str, InfoLogLength);
  111.     glGetShaderInfoLog(FragmentShaderObject, InfoLogLength, @InfoLogLength, @Str[1]);
  112.     Application.MessageBox(PChar(Str), 'OpenGL Fragment Fehler', 48);
  113.     Halt;
  114.   end;
  115.  
  116.   glDeleteShader(FragmentShaderObject);
  117.  
  118.   glLinkProgram(ProgramObject);
  119.  
  120.   // Check  Link
  121.   glGetProgramiv(ProgramObject, GL_LINK_STATUS, @ErrorStatus);
  122.   if ErrorStatus = GL_FALSE then begin
  123.     glGetProgramiv(ProgramObject, GL_INFO_LOG_LENGTH, @InfoLogLength);
  124.     SetLength(Str, InfoLogLength);
  125.     glGetProgramInfoLog(ProgramObject, InfoLogLength, @InfoLogLength, @Str[1]);
  126.     Application.MessageBox(PChar(Str), 'OpenGL ShaderLink Fehler', 48);
  127.     Halt;
  128.   end;
  129.  
  130.   Result := ProgramObject;
  131.   FreeAndNil(StringList);
  132. end;
  133.  
  134. procedure TForm1.InitScene;
  135. begin
  136.   ProgramID := InitShader('VertexShader.txt', 'FragmentShader.txt');
  137.   glUseProgram(programID);
  138.  
  139.   glClearColor(0.0, 0.5, 1.0, 1.0); //Hintergrundfarbe: Hier ein leichtes Blau
  140.  
  141.   // Dreieck
  142.  
  143.   glGenBuffers(1, @VBTriangle.VBO);
  144.   glGenVertexArrays(1, @VBTriangle.VAO);
  145.  
  146.   glBindVertexArray(VBTriangle.VAO);
  147.  
  148.   glBindBuffer(GL_ARRAY_BUFFER, VBTriangle.VBO);
  149.   glBufferData(GL_ARRAY_BUFFER, sizeof(Triangle), @Triangle, GL_STATIC_DRAW);
  150.   glEnableVertexAttribArray(0);
  151.   glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, nil);
  152.  
  153.   // Rechteck
  154.  
  155.   glGenBuffers(1, @VBQuad.VBO);
  156.   glGenVertexArrays(1, @VBQuad.VAO);
  157.  
  158.   glBindVertexArray(VBQuad.VAO);
  159.  
  160.   glBindBuffer(GL_ARRAY_BUFFER, VBQuad.VBO);
  161.   glBufferData(GL_ARRAY_BUFFER, sizeof(Quad), @Quad, GL_STATIC_DRAW);
  162.   glEnableVertexAttribArray(0);
  163.   glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, nil);
  164. end;
  165.  
  166. procedure TForm1.RenderScene;
  167. begin
  168.   glClear(GL_COLOR_BUFFER_BIT);
  169.  
  170.   // Zeichen Dreieck
  171.  
  172.   glBindVertexArray(VBTriangle.VAO);
  173.   glDrawArrays(GL_TRIANGLES, 0, Length(Triangle) * 3);
  174.  
  175.   // Zeichne Quadrat
  176.  
  177.   glBindVertexArray(VBQuad.VAO);
  178.   glDrawArrays(GL_TRIANGLES, 0, Length(Quad) * 3);
  179.  
  180.   OpenGLControl1.SwapBuffers;
  181. end;
  182.  
  183.  
  184. procedure TForm1.FormCreate(Sender: TObject);
  185. begin
  186.   InitOpenGL;
  187.  
  188.   OpenGLControl1 := TOpenGLControl.Create(Self);
  189.   with OpenGLControl1 do begin
  190.     OpenGLMajorVersion := 3;     // OpenGL 3.3 erzwingen
  191.     OpenGLMinorVersion := 3;
  192.     Parent := Self;
  193.     Align := alClient;
  194.     MakeCurrent;
  195.     AutoResizeViewport := True;  // Ersetzt glViewport
  196.   end;
  197.   ReadExtensions;
  198.   ReadImplementationProperties;
  199.  
  200.   InitScene;
  201. end;
  202.  
  203. procedure TForm1.FormDestroy(Sender: TObject);
  204. begin
  205.   glDeleteVertexArrays(1, @VBTriangle.VAO);
  206.   glDeleteVertexArrays(1, @VBQuad.VAO);
  207.  
  208.   glDeleteBuffers(1, @VBTriangle.VBO);
  209.   glDeleteBuffers(1, @VBQuad.VBO);
  210.  
  211.   glDeleteShader(ProgramID);
  212.   OpenGLControl1.Free;
  213. end;
  214.  
  215. procedure TForm1.FormPaint(Sender: TObject);
  216. begin
  217.   RenderScene;
  218. end;
  219.  
  220. procedure TForm1.FormResize(Sender: TObject);
  221. begin
  222.   //  glViewport(0, 0, ClientWidth, ClientHeight);
  223. end;
  224.  
  225. procedure TForm1.Timer1Timer(Sender: TObject);
  226. begin
  227.   RenderScene;
  228. end;
  229.  
  230. end.


VertexShader.txt:

Code:
  1. #version 330
  2. in vec3 inPos;
  3.  
  4. void main(void)
  5. {
  6.   gl_Position = vec4(inPos, 1.0);
  7. }


FragmentShader.txt

Code:
  1. #version 330
  2.  
  3. out vec4 outColor; // ausgegebene Farbe
  4.  
  5. void main(void)
  6. {
  7.   outColor = vec4(1.0, 0.0, 0.0, 1.0);
  8. }


PS: Schön wäre es, wen man den Code für eine Einsteiger Tutorial verwenden könnte.

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Fr Jan 16, 2015 12:40 
Offline
DGL Member

Registriert: Sa Jan 03, 2015 13:28
Beiträge: 23
Programmiersprache: Lazarus/FPC
Herzlichen Dank, Mathias.
Das sieht alles schonmal sehr übersichtlich und vielversprechend aus. V.a. daß sich die Shaderprogramme ganz einfach über eine externe Textdatei einbinden lassen, ist klasse.
Die VertexShader und FragmentShader txt Dateien habe ich im Projektverzeichnis erstellt mit dem angegebenen Code, habe im Projektinspektor das Package "LazOpenGLContext" hinzugefügt und den ganzen Code für Unit1 eingefügt, bekam dann allerdings beim Start folgende Fehlermeldung (3x innerhalb der function "InitShader"):
"Error: Incompatible types: got "ByteBool" expected "LongInt""

Die entsprechenden Zeilen waren "if ErrorStatus = GL_FALSE then begin", wobei GL_FALSE in dglOpenGL als ByteBool definiert ist und ErrorStatus als integer.
Ich habe folgende Version der dglOpenGL.pas benutzt: "OpenGL 4.5 - Headertranslation Version 4.5a".

Gruß,

Dennis


Nach oben
 Profil  
Mit Zitat antworten  
BeitragVerfasst: Fr Jan 16, 2015 18:02 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Mai 31, 2002 19:41
Beiträge: 1276
Wohnort: Bäretswil (Schweiz)
Programmiersprache: Pascal
Zitat:
"Error: Incompatible types: got "ByteBool" expected "LongInt""

Das Problem liegt eindeutig an dglOpenGL, es gibt mehrere Versionen.

Zitat:
Die entsprechenden Zeilen waren "if ErrorStatus = GL_FALSE then begin"

Du schreibst waren, somit nehme ich an, du hast den Code zum laufen gebracht ?

_________________
OpenGL


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 58 Beiträge ]  Gehe zu Seite 1, 2, 3, 4  Nächste
Foren-Übersicht » Programmierung » Einsteiger-Fragen


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 12 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.055s | 17 Queries | GZIP : On ]