Buchempfehlung
MySQL kurz & gut
MySQL kurz & gut
Das preiswerte Taschen- buch stellt MySQL-rele- vante Inhalte systematisch und knapp dar, sodass es sich optimal zum Nach- schlagen beim Pro- grammieren eignet. [Mehr Infos...]
FreeBASIC-Chat
Es sind Benutzer im FreeBASIC-Chat online.
(Stand:  )
FreeBASIC bei Twitter
Twitter FreeBASIC-Nachrichten jetzt auch über Twitter erhalten. Follow us!

Tutorial

OpenGL und FreeBASIC - eine kleine Einführung - Teil 1

von MitgliedEastler_dartSeite 3 von 3

Unser erstes Objekt - Punkte

ZUM PROGRAMMIERSTIL:
Auf der vorigen Seite haben wir zusammengestellt, wie wir OpenGL initialisieren müssen, um überhaupt irgendwas damit machen zu können.
Nun machen wir uns schon daran, Objekte darzustellen. Jedoch zuvor noch ein Wort zur Programmstrukturierung. Wir hatten in der Einleitung von "optimierbar" gesprochen. Optimieren kann man nur ein übersichtliches Listing. Damit unser Script relativ übersichtlich bleibt, trennen wir das Anzeigen von Objekten aus dem Hauptteil heraus und verlagern es in eine/mehrere Subs.
Ein ehrliches Wort dazu: Dieses Auslagern hilft zwar, dieses Tutorial besser zu verstehen, widerspricht aber dem Grundkonsenz vom OpenGL-Programmieren:
"Jede vermeidbare Befehlszeile ist eine Zeile zuviel."
Da wir aber an vielen Stellen hier lieber ausführlich programmieren, als mit weniger Befehlen auf Geschwindigkeit achten, werden wir auch an dieser Stelle einige Regeln erst mal über Bord werfen. Wir merken uns aber, OpenGL braucht jedes, auch noch so kleine Quäntchen an Rechenpower, welches man im Listing irgendwie einsparen kann. Und unser zusätzlicher Befehl "Spring in eine Sub" kann so ein Quäntchen sein.

Für die OpenGL-Erfahrenen, die jetzt Zweifel kriegen, geb ich nur den Hinweis, dass die in Subs ausgelagerten Objektanzeigebefehle später vielleicht als ScreenListen sehr einfach den Turbo erhalten können.

EINE SUB FÜR DAS OBJEKT:
Wie zuvor gesagt, erzeugen wir eine SUB, in der wir unser erstes Objekt erstellen wollen. Dazu müssen wir die SUB wie folgt am Anfang des Listings deklarieren. Wir tragen also nach den Unterteilungszeilen für Deklarationen ein:

'-------------------------
'Declarationen
'-------------------------
DECLARE SUB Objekt1()

Und eröffnen dann am Ende des Listings diese SUB:

'-------------------------
SUB Objekt1 ()
   'hier kommen die Programmzeilen zum Anzeigen
   'von Objekten rein
END SUB

   '---------------------------
   'ProgrammSchleife
   '---------------------------
   Tastendruck = INKEY   'Jeder Tastendruck wird sofort in die Variable Tastendruck gespeichert

   Objekt1               '<<<<<<<<<<<<<<<<hier die neue Programmzeile rein

   flip                  'liebes OpenGL, zeig alles, was in der Schleife für dich vornedran steht, auf Monitor an
   '---------------------------
   'Ende der Schleife
   '---------------------------

PUNKTE:
Stand der Dinge ist jetzt, der Programmablauf fängt mit den DIMs, Includes, Declarationen usw. an, kommt in den Hauptteil, und kreiselt dort in der Schleife, bis der Anwender die Escape-Taste drückt. Weil in der Schleife der Aufruf der SUB "Objekt1" steht, wird diese Sub mit jedem Schleifendurchlauf aufgerufen und damit ausgeführt.
Nun können wir innerhalb dieser SUB alle möglichen Befehle eintragen, es wäre technisch das Gleiche, wenn wir diese direkt in die Schleife eingetragen hätten, nur isses so übersichtlicher.

Ein Vorwort gleich zum Zeichnen von Objekten. Falls ihr euch hier das erste Mal mit OpenGL beschäftigt, dann steht ihr bestimmt vor der gleichen Hürde wie ich beim ersten Mal. Bitte versucht erst gar nicht, irgendwas oder irgendwie in Pixeln auf dem Monitor zu denken. Das wird hier nix. Alles und jegliches, was wir hier für darzustellende Sachen angeben, ist grundsätzlich im dreidimensionalen Raum zu machen. Uns interessiert überhaupt nicht, wo die einzelnen Pixel auf dem Monitor angezeigt werden sollen, wir überlegen nur, wo dieser Punkt in unserem dreidimensionalen Raum liegt. Für die Umrechnung auf den (2D-)Monitor haben wir OpenGL.

Und weil im grad Geschriebenen von Punkten die Rede ist, fangen wir mit Punkten auch an. Zumal Sie die Basis für alles Weitere sind.

Ein Punkt wird unter 3D (wie soll's anders sein) mit drei Parametern definiert. Dazu verwendet man ein Koordinatensystem. Sie kennen bestimmt aus der Schule das Koordinatensystem mit der X- und der Y-Achse. Genau so eins mein ich. Die X-Achse war für "links" und "rechts" zuständig, die Y-Achse für "hoch" und "runter". In 3D kommt nun noch die dritte Dimension dazu, das "vor" und "zurück" oder auch "nach vorne" "nach hinten" benannt, das ist die Z-Achse.

Denken wir uns also den Punkt, der 0.5 Einheiten nach rechts, 1 Einheit nach oben und 6 Einheiten nach hinten versetzt angezeigt werden soll. Wir wollen OpenGL also sagen:
"Male einen Punkt, der auf der X-Achse an Pos 0.5 (0.5 nach Rechts), auf Y-Achse Pos 1 (1 oben) und auf Z-Achse an Pos -6 (Z=vor-zurück, minus=zurück) liegt."

Um diese Position OpenGL zu benennen, verwenden wir den Befehl: "glVertex".
In unserem Fall müssen wir hinter den Befehl noch die Endung "3f" anhängen, (dazu später mehr) sowie die Positionswerte der X-/Y-/und Z-Achse. Der Befehl lautet:

glVertex3f 0.5, 1.0, -6.0

Wie Sie sehen, nehmen wir den Befehlsnamen und dahinter die 3 gewünschten Positionen, in der Reihenfolge X-Achse, Y-Achse, Z-Achse. Das ist doch einfach zu merken oder?

Aber ein weiteres Befehlspaar muss ich dazu noch erklären: "glBeginn" und "glEnd".
Immer wenn wir Objekte für OpenGL "beschreiben", müssen wir dies in die Befehlspaare "glBeginn" und "glEnd" einschließen. Dabei geben wir dem Befehl "glBeginn" noch mit dazu, was für einen Typ wir grad "beschreiben". In unserem Fall ist das ein Punkt, hängen an glBeginn noch die Variable "gl_Points" dran, das sieht dann so aus:

glBegin gl_Points
   glVertex3f 0.5, 1.0, -6.0
glEnd

FARBE:
Für diesen Punkt können wir auch eine Farbe festlegen, der Befehl dazu heißt: "glColor", auch an diesen Befehl hängen wir die Endung "3f" mit dran, was dann zu "glColor3f" führt. Dahinter geben wir wieder drei Parameter an, die OpenGL sagen, wie es die Farbe "zusammenmischen" soll. Dabei werden einfach die Mengen an roter, grüner und blauer Farbe festgelegt: Wir wollen hier mal in gelb malen, dafür mischen wir zu gleichen Teilen rot und grün zusammen, nehmen keine blaue Farbe. Um die Punkte möglichst hell zu gestalten, soll OpenGL für gelb und grün jeweils die höchstmögliche Menge nehmen, was mit dem Wert "1" festgelegt wird. Würden wir z.B. weniger Rot wollen, wäre ein Wert von 0.8 oder 0.567 oder... anzugeben. Wir bleiben aber bei "hellstem gelb", also für rot 1, für grün 1 und kein blau = 0.
Eine Befehlszeile für Farbe sieht dann so aus: "glColor3f 1.0, 1.0, 0.0".
Wir merken uns dabei aber, wir stellen hier nicht nur die Farbe für unseren Punkt ein, sondern setzen mit diesem Befehl die aktuelle Zeichenfarbe auf gelb. Das bedeutet, dass ab dem Moment, wo diese Zeile steht, alles was kommt in gelb gezeichnet wird, bis mit einem weiteren solchen Befehl eine andere Farbe festgelegt wird.

Um also unseren Punkt zu zeichnen, und die Farbe auf gelb zu setzen, sähe unser Beispiel so aus:

glBegin gl_Points
   glColor3f 1.0, 1.0, 0.0
   glVertex3f 0.5, 1.0, -6.0
glEnd

Es erscheint erst mal umständlich, für einen einzigen Punkt vier Befehlszeilen schreiben zu müssen, das ist jedoch nicht so. Wir dürfen durchaus mehrere Punkte auf einmal definieren. Wünschen wir uns also noch zwei weitere Punkte:
1) Halbe Einheit nach links, 1 Einheit nach oben und 6 Einheiten nach hinten
sowie
2) 0 Einheiten links/rechts, 2 Einheiten nach oben und 6 Einheiten nach hinten.

Um alle drei Punkte, also den aus dem ersten Beispiel und die beiden hier an OpenGL zum Zeichnen zu übergeben, sieht die Befehlsfolge so aus:

glBegin gl_Points
   glColor3f 1.0,1.0,0.0       :' Zeichenfarbe auf gelb
   glVertex3f  0.5, 1.0, -6.0  :' der erste Punkt
   glVertex3f -0.5, 1.0, -6.0  :' der zweite Punkt
   glVertex3f  0.0, 2.0, -6.0  :' der dritte Punkt
glEnd

Und genau das tragen wir auch in unserer Sub zwischen 'SUB Objekt1() und END SUB ein.

Man sieht hier dann gleich: Ah, GL einen Typ geben, was wir zeichnen wollen, danach die Parameter der Objekte dieses Types listen, sobald wir fertig sind, oder Objekte anderen Typs zeichnen wollen, mit glEnd die Liste dieses Types abschließen.

Dieses Beispiellisting würde auf dem Monitor so aussehen:

die_drei_punkte

WAS WISSEN WIR JETZT:
Ja, kurz gesagt, einige der Grundkenntnisse von OpenGL. Ganz am Anfang haben wir ein Grundgerüst erstellt, in dem schon einige der OpenGL-Einstellungen festgelegt sind, sodass wir überhaupt erst mal arbeiten können.
Danach haben wir das Listing so verändert, dass alles, was wir mit OpenGL anzeigen wollen, in separaten SUBs stehen kann. Damit brauchen wir für weitere Exkursionen immer nur in diese SUBs zu gucken, ohne immer den ganzen DrumRum-Quelltext mit aufzulisten.
Zu vorletzt freundeten wir uns mit Adressierungen im 3D-Raum an wobei das Koordinatensystem mit X-/Y-/und Z-Achse immer geholfen hat.
Und last, but not least, gleich mal mit diesem Wissen für drei Punkte die 3D-Koordinaten ermittelt und mit OpenGL in einer glBeginn-glEnd-Liste so aufgelistet, dass diese 3 Punkte auch angezeigt werden.
Wenn diese 3D-Koordinaten ein bisschen auf uns eingewirkt haben, werden wir im Nächsten Teil weitermachen, und aus diesen Punkten Linien und Flächen erstellen. Ruhen Sie sich einen Moment aus, bevor Sie mit Kapitel 2 weiter machen, dort steckt zusätzlich zum eigentlichen Erstellen von Linien und Flächen wieder eine Menge notwendiges Hintergrundwissen mit drin. Es ist von Vorteil, wenn Sie für das nächste Kapitel wieder frisch und ausgeruht sind.

Zum Schluss dieses ersten Kapitels nochmal das gesamte Listing unseres hier zusammengestellten Programmes:

'-------------------------
'DIMs
'-------------------------
DIM SHARED AS STRING Tastendruck

'-------------------------
'Includes
'-------------------------
#include "fbgfx.bi"
#include once "GL/gl.bi"
#include once "GL/glu.bi"

'-------------------------
'Declarationen
'-------------------------
DECLARE SUB Objekt1()

'-------------------------
' das Fenster öffnen
'-------------------------
screen 19, 16, , 2

'-------------------------
' Open-GL Init
'-------------------------
glViewport 0, 0, 800, 600                      ' den Current Viewport auf eine Ausgangsposition setzen
glMatrixMode GL_PROJECTION                     ' Den Matrix-Modus Projection wählen
glLoadIdentity                                 ' Diesen Modus auf Anfangswerte setzen
gluPerspective 45.0, 800.0/600.0, 0.1, 100.0   ' Grundeinstellungen des Anezeigefensters festlegen
glMatrixMode GL_MODELVIEW                      ' Auf den Matrix-Modus Modelview schalten
glLoadIdentity                                 ' und auch diesen auf Anfangswerte setzen
glClearColor 0.5, 0.5, 0.50, 0.0               ' Setze Farbe für löschen auf Mittelgrau
glClearDepth 1.0                               ' Depth-Buffer Löschen erlauben
glEnable GL_DEPTH_TEST                         ' den Tiefentest GL_DEPTH_TEST einschalten
glClear GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT  'Tiefen- und Farbpufferbits löschen
'---------------------------
'HAUPTTEIL
'---------------------------

DO UNTIL Tastendruck = CHR(27) :'die Schleife solange immer wiederholen, bis in der Variablen Tastendruck die Esc-Taste (chr(27) steht
   '---------------------------
   'ProgrammSchleife
   '---------------------------
   Tastendruck = INKEY   'Jeder Tastendruck wird sofort in die Variable Tastendruck gespeichert

   Objekt1               '<<<<<<<<<<<<<<<<hier die neue Programmzeile rein

   flip                  'liebes OpenGL, zeig alles, was in der Schleife für dich vornedran steht, auf Monitor an
   '---------------------------
   'Ende der Schleife
   '---------------------------
LOOP

END

'-------------------------
SUB Objekt1 ()
   'hier kommen die Programmzeilen zum Anzeigen
   'von dem Dreieck rein
   glBegin gl_Points
      glColor3f 1.0,1.0,0.0       :' Zeichenfarbe auf gelb
      glVertex3f  0.5, 1.0, -6.0  :' der erste Punkt
      glVertex3f -0.5, 1.0, -6.0  :' der erste Punkt
      glVertex3f  0.0, 2.0, -6.0  :' der erste Punkt
   glEnd
END SUB

 

Gehe zu Seite Gehe zu Seite  1  2  3  
Zusätzliche Informationen und Funktionen
  • Das Tutorial wurde am 18.07.2008 von MitgliedEastler_dart angelegt.
  • Die aktuellste Version wurde am 05.08.2008 von MitgliedEastler_dart gespeichert.
  Bearbeiten Bearbeiten  

  Versionen Versionen