• Tutorials
• Downloads
• Referenz
• NoPaste
• FAQ

Tutorial

OpenGL und FreeBASIC - eine kleine Einführung - Teil 5 - Texturen

von Eastler_dart

Seite 3 von 6

TEXTUREN IN EINEM UNTERPROGRAMM LADEN - VERWENDBAR

Na, hat Ihnen das Schnupperbeispiel gefallen?

Aber es hat ja den Haken, daß es nur mit der Datei "Mauer_128.bmp"
funktioniert, ansonsten nicht.
Das Beispiel war ja auch nur dazu gedacht, Ihnen die notwendigen
FreeBasic- und OpenGL-Funktionen mal näherzubringen, mit denen
man Texturen auf ein Objekt bringt.

Nun wollen wir das Erarbeitete in ein Unterprogramm packen, welchem
wir einfach den Dateinamen einer Bitmapdatei übergeben und den
Namen/Nummer der OpenGL-Textur zurückerhalten, mit dem wir diese
dann aktivieren können.

Aber ergänzenderweise muß ich sagen, daß ich solangsam Bedenken
habe, weil wir bisher immer ohne Fehlerauswertung gearbeitet haben.
Ohne diese wird zwar alles etwas übersichtlicher, aber nun arbeiten
wir mit Dateien, und da geht ganz schnell mal was schief.

Also wird diese SUB die Bitmap-Datei analysieren und prüfen,
ob sie überhaupt verwendbar ist. Falls nicht, müssen entsprechende
Fehlermeldungen raus und das Programm beendet werden.

eine Fehlerausgabe

Deshalb erstellen wir erst mal eine Sub für diese Fehlermeldungen,
in welcher die Meldungen auf dem Console-Fenster und auch in einer
Datei ausgegeben werden.

Das Ausgeben von Texten in dem Consolefenster kennen Sie ja bereits,
das zusätzliche Schreiben in eine Datei sollte Ihnen auch nicht
fremd sein. Also hier diese SUB:

Die Datei benennen wir "Protokoll.txt". Damit diese nicht bei
jedem Aufruf von Schreibe() gelöscht werden würde, öffnen wir
die Datei für "Append" = anhängen.
Damit wird diese Datei aber nie gelöscht, sodaß bei einem
Zweiten/Dritten/... Start unseres Programmes die Protokoll-
einträge immer noch unten dran geschrieben werden.
Um jetzt die Einträge zuordnen zu können, schreiben wir bei
jeder Ausgabe das Datum und die Uhrzeit vornedran.

Im DeclareBereich natürlich diese SUB auch declarieren

So, nun können wir uns an das Unterprogramm für das Bildeinlesen
heranwagen. Nochmal, zur Veranschaulichung. Bei dieser Routine
soll es darum gehen, ein Bild auf der Festplatte an OpenGL zu
übergeben, sodaß man später mit diesem Bild Texturieren kann.
Dieser Vorgang sollte gleich nach dem Initialisieren von OpenGL
aufgerufen werden, sodaß das Bild im Speicher der Grafikkarte
steht.
Erst viel später werden dann Objekte erstellt, und ggf. diese
mit dem Bild texturiert, somit kommt das Texturieren selber
hier nicht rein.

Hier also "nur" das Kopieren des Bildes auf die Grafikkarte.
Im Grunde nehmen wir die selben Befehle wie zuvor, nur daß
wir nun die Datei prüfen, aus der Datei die Bildgröße holen,
sodaß wir nur den Namen der Datei an die Sub übergeben müssen.

von der Festplatte in den Arbeitsspeicher

Tja, hierbei kommt der größe neue Brocken auf uns zu.
Das Prüfen der übergebenen Datei, ob diese für Texturen
verwendbar ist.
1.Check: "ist die Datei überhaupt da?"
2.Check: "ist das überhaupt eine Bitmap-Datei?"
3.Check: "ist das Bild da drin auch wirklich UNKomprimiert?"
4.Check: "Ist die Größe des Bildes für Texturen verwendbar?"
-------- Da wir immer noch für sämtliche OpenGL-Versionen
-------- ab Version 1.0 schreiben, hab ich die Größen auf
-------- den für alle passenden Werte festgelegt:
-------- A) Bild muß quadratisch sein
-------- B) Die Kantenlängen dürfen
-------- 64Pixel, 128Pixel oder 256Pixel lang sein
Nur wenn alle Bedingungen erfüllt sind, kann jedes OpenGL
das Bild als Textur verwenden.

Oh Gott, was hat er denn nun vor? werden Sie denken, aber
es ist leichter, als es klingt.
In jeder Bitmapdatei stehen vor den eigentlichen Bilddaten
einige Infos drin, anhand derer wir das Ganze überprüfen
werden. Diese Infos sehen wie folgt aus:

Bitmapdatei Header-Aufschlüsselung

Die Positionen gelten für das Einlesen per GET#, das Erste Byte ist dort Nr 1 (nicht 0)
ANMERKUNG ZUR Bildhoehe: Wenn der Wert Negativ ist, ist das Bild in der Datei vertikal gespiegelt!

hier finden wir also alles, was wir brauchen.

Also basteln wir das erste Stück, das Überprüfen der Datei:

Nun hoffe ich, daß Sie mit dem Umgang von FreeBasic vertraut
sind, daß Sie IF-THEN und deren Verschachtelung verstehen.

Denn wir packen die oben genannte 4 Checks in vierfach
verschachtelte IF-THEN-Prüfungen, wobei wir immer auf Falsch
prüfen, ggf. das Programm mit Fehlermeldung beenden, Falls nicht
falsch(ELSE), machen wir da drin weiter.
Bedeutet schlichtweg, wenn der Programmablauf durch alle
vier IF-THENs durchläuft, und das Programm sich nicht
beendet, weil eine Bedingung nicht paßt, dann hat die
übergebenen Datei volle Gültigkeit, deshalb wird in der
vierten IF-Bedingung bei ELSE gleich der RAM per ImageCreate
reserviert und die Datei per BLOAD dort rein kopiert.

Die Routine also als Function dimmen, damit wir Werte an
den aufrufenden Befehl zurückgeben können.
Die Funktion nennen wir mal BmpToOgl.
Als Erstes brauchen wir dann ein paar Variablen:

Danach können wir gleich mit dem Datei-Check beginnen:

So, wenn das alles durch ist, das Programm nicht abgebrochen hat,
dann haben wir nun in DateiImRamPtr den Zeiger auf das Bild
im Arbeitsspeicher, das Bild ist bereits dahin kopiert.

Farben Rot und Blau tauschen

Genauso, wie im ersten Beispiel, setzen wir nun gleich die
vertauschten Rot- und Blau-Werte richtig:

Auch hier wieder, wir nehmen (noch) keine Rücksicht darauf,
das unser Bild nun senkrecht gespiegelt ist, damit uns ein
einziges ImageCreate ausreicht

Nun kommt nochmal etwas Neues dazu. Am Anfang hatten wir doch
festgestellt, daß "neuere" Grafikkarten viel schneller arbeiten,
wenn die Bilddaten mit 32-bit im Speicher stehen.
Aber feststellen, ob die Karte nun schnell oder alt ist, läßt
sich nicht zuverlässig.
Nun hab ich dazu eine andere Überlegung. Wenn ich ein OpenGL
- Programm erstelle, liste ich dem Anwender gerne die Möglich-
keiten seiner Grafikkarte auf und er soll auswählen, mit
welcher Auflösung er das Programm laufen lassen will.
Und genau da häng ich mich dann: Wenn er eine ältere Karte
hat, wird er wohl kaum auf 32-bit Farbtiefe schalten, hat er
eine neuere, klickt er freudig auf "bitte 32-bit einstellen".
Also prüfen wir hier einfach, mit welcher Farbtiefe das
OpenGL-Fenster grad läuft.
Bei 32-bittigem OpenGL-Fenster legen wir das Texturbild
ebenfalls mit 32-bit Farbtiefe auf der Grafikkarte ab (GL_RGBA)
ansonsten halt mit 24- oder 16-bit (GL_RGB, ob 16 oder 24
zu nehmen ist, regelt OpenGL automatisch).
Jedenfalls müssen wir eine Variable anlegen, in der wir
die Farbtiefe des OpenGL-Fensters speichern und mit dem
FreeBasic-Befehl SCREENCONTROL die Farbtiefe in der Variablen
ablegen:

Auf Grafikkarte kopieren lassen

Nun wieder wie gehabt, für ein neues Texturbild einen Eintrag
erstellen lassen, sich den Namen(Nummer) der Textur geben
lassen:

und je nachdem, was in FensterFarbTiefe drin steht, das
Bild im Ram auf die Grafikkarte abholen lassen:

Die Parameter für das Texturieren bei nah dran und weit weg
einstellen:

Nachdem nun das Bild auf der Grafikkarte steht, können
wir das Bild im Arbeitsspeicher wieder löschen und den
Speicher wieder freigeben:

Da wir unsere Einleseroutine als Function angelegt haben,
sorgen wir nun noch dafür, daß der Name(Nummer) der
Textur an den aufrufenden Befehl zurückgegeben wird:

Eine Zweite Textur

Ja, Sie lesen richtig, da wir die Funktionen für das Bild
von Festplatte bis zur Grafikkarte kopieren in eine
Function ausgelagert haben, können wir diese ja auch
mehrfach aufrufen. So wie die Function angelegt ist,
stört sie sich nicht daran, mehrmals laufen zu müssen.
Das Einzigste, was wir brauchen, ist eine zweite INTEGER
Variable, damit wir den Namen(Nummer) der zweiten
Textur auch speichern können:

Jetzt sollten wir aber auch ein anderes Bild haben,
zweimal das Gleiche wär ja langweilig.
Ist zwar irgendwie verrückt, aber ich hab eins mit
Kirschen, das gefällt mir irgendwie und ist lustig:

Die Datei hat den Namen Kirschen_256. Sie merken bestimmt,
dieses Bild ist größer, hat eine Seitenlänge von 256 Pixel.

Klicken Sie das Bild mit der rechten Maustaste an und
wählen Sie "Speichern unter".
Speichern Sie die Datei dorthin, wo bereits Mauer_128.bmp steht,
also in das Verzeichnis, wo auch das kompilierte, ausführbare
Programm stehen wird.

Nachdem das Bild nun an der richtigen Stelle auf der Festplatte
gespeichert ist, können wir es als Textur an OpenGL übergeben.
Mit unserer Function ist das ein Leichtes, einfach Aufrufen,
als Parameter nun "Kirschen_256.bmp" übergeben, und die Rückgabe
der Function (Texturname/nummer) in der Variablen TexturZwei
speichern:

Schwupps, das wars schon. Nun können wir bereits die Kirschen
als Textur einsetzen - aber wo?

Klar doch, jetzt gehts an die Pyramiden ;-)
Dabei müssen wir nur beachten, daß wir die beiden Pyramiden
mit einer einzigen Routine erstellen, bei der wir direkt
davor per glTranslatef die Position, an der zu erstellen ist,
ändern.
Das bedeutet, wenn wir direkt in der Pyramidensub das verwenden
der Textur reinschreiben, haben beide Pyramiden die gleiche
Textur.
Soll heißen: In der SUB schreiben wir nur die TexturKoordinaten
vor die 3D-Punkte, das aktivieren eines Bildes als Textur machen
wir schon im Hauptprogramm, somit können wir erst die Mauertextur
aktivieren, eine Pyramide erstellen, dann die Kirschentextur
aktivieren und die zweite Pyramide erstellen.

den Pyramiden Texturkoordinaten geben

Also gehen wir in die PyramidenSUB. Dort stehen im Kern dann
die Beschreibungslisten des Quadrates als Boden und der
vier Dreiecke als Seitenflächen.
Fangen wir mit dem Boden an, ein Texturbild auf ein Quadrat,
das hatten wir ja schon.
Einfach direkt vor jede Punktdeffinition(glVertex3f) die
Punktangabe auf dem TexturBild setzen. Damit der Zusammenhang
deutlich zu sehen ist, schreiben wir die Texturpunktdeffinition
und den 3D-Punkt(Vertex) in eine Zeile, wie wir wissen, müssen
wir mehrere FreeBasic-Befehle in einer Zeile mit Doppelpunkt
voneinander trennen.
Für das Bestimmen, ob die Ecke des Quads nun links/oben oder
rechts/oben usw ist, müssen Sie sich grundsätzlich daran
halten, von "außen" auf das Objekt schauen.
Das ist bei unserem Pyramidenboden in der 3D-Welt von unten
nach oben schauen. Und in der Sichtweise arbeiten wir dann
GEGEN den Uhrzeigersinn.
Hier der Auszug der Deffinition Pyramidenboden=QUAD:

Und nun die Dreiecke der Seitenflächen, man beachte hier,
daß wir nun vier weitere Objekte haben, und auf diese
genauso wie auf dem Quad des Bodens das selbe Texturbild
kleben. Also ein Bild für viele Objekte, kein Problem.

Jedoch der Übersichtlichkeit hier nochmal eine Skizze,
wie wir auf dem Texturbild die TexturKoordinaten bei
Dreiecken setzen:

Sie sehen, wir schneiden aus dem Bild per Texturkoordinaten
einfach eine passende Fläche aus. Genau wegen solchen
Fällen gibt es diese Texturkoordinaten, egal ob Sterne,
Dreiecke, oder sonstige unförmige Objekte, jeden Punkt
des Objekt als Punkt auf dem Texturbild so passend
deffinieren, daß eine passende Form ausgeschnitten wird,
schon paßts.

Also gehen wirs an, die vier Dreiecke sind in unserer
Sub jedes für sich deffiniert, also bei allen vier
die Texturkoordinaten davor setzen. Auch hier wieder
von außen auf das Objekt schauend, gegen den Uhrzeigersinn
die Punktreihenfolgen wählen.
Auszug der Dreiecke:

Das wars schon, jedem 3D-Punkt der Pyramidenteile
ist nun ein Punkt auf der Textur zugeordnet - fertig.

Jetzt müssen wir nur noch ins Hauptprogramm,
genauer gesagt, in die Schleife, wo die Pyramiden
aufgerufen werden, und dort jeweils das Texturieren
erlauben und ein Bild auf der Grafikkarte als Textur
festlegen.
Da wir beide Pyramiden direkt hintereinander aufrufen,
Schalten wir vor der ersten das Texturieren ein, und
nach der Zweiten dann erst wieder aus.
Da wir verschiedene Bilder für die beiden Pyramiden
zum Texturieren verwenden, müssen wir natürlich
direkt vor dem Aufruf der Pyramidensub jeweils
ein Bild aktivieren (klar, einmal Mauer, einmal Kirsche).

So, das hätten wir nun soweit, alle Codeschnippsel haben
wir besprochen. Wenn wir die nun alle in das Beispiel-
listing aus Tutorial 4 an den richtigen Stellen
einbauen, entsteht ein Programm, welches nach einigem
rumirren in unserer kleinen 3D-Welt folgendes Bild
anzeigt:

und wie gewohnt, hier zum Ende der Seite das komplette,
funktionsfähige Listing, mit allem was hier besprochen wurde:

Gehe zu Seite  1  2  3  4  5  6  

Zusätzliche Informationen und Funktionen
Das Tutorial wurde am 28.09.2008 von Eastler_dart angelegt. Die aktuellste Version wurde am 30.09.2008 von Eastler_dart gespeichert.	Bearbeiten     Versionen