Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
 
FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen  RegistrierenRegistrieren
ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin
Zur Begleitseite des Forums / Chat / Impressum
Aktueller Forenpartner:

OpenGL - was braucht Ihr? JETZT TESTPROGRAMM DRIN

 
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC.
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Eastler_dart



Anmeldungsdatum: 25.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 22.08.2008, 15:53    Titel: OpenGL - was braucht Ihr? JETZT TESTPROGRAMM DRIN Antworten mit Zitat

Hallo Leute,

der Eine oder Andere hat vielleicht schon gesehen, hab ein Tutorial zu OpenGL angefangen.

Jetzt steh ich an dem Punkt, an dem ich das Texturieren erklären sollte.
Ein Programmrohling zum Einlesen von Bildern aus Dateien in den Ram sowie danach Kopieren aus dem Ram auf den Grafikkartenspeicher steht mittlerweile und läuft.

Bzw. lief, bis ich damit auf ne alte Maschine gewechselt hab. Dort läufts nämlich nicht mit dem Kopf durch die Mauer wollen

So, wie ich bis jetzt recherchieren konnte, läuft mein Beispiel auf Karten mit OpenGL Version ab 1.3.3259 Win9x Release. Hm. Diesen Rechner schätze ich auf ein Alter von 4 bis 5 Jahren.

Aber auf den rund 10 Jahre alten Rechnern, auf denen mein Beispiel nicht läuft, ist
-------------------------------------------------------------------------------
GL-Hersteller = Microsoft Corporation
GL-Renderer = GDI Generic
GL-Version = 1.1.0
GL-Erweiterungen = GL_WIN_swap_hint GL_EXT_bgra GL_EXT_paletted_texture
-------------------------------------------------------------------------------
als OpenGL-Implementierung drin (300-500Mhz-CPU, 4MB-Grafikkarten unter W98SE)

Jetzt steh ich da, mit meinem Beispielprogramm und grüble:

1. Soll ich im Tutorial wirklich auf diese alten Geräte eingehen?
Eigentlich ja, ich hab ja solche Geräte auch noch am Laufen.
2. Den Beispielcode find ich aber genial schnell,
bei Berücksichtigung der alten Maschinen werd ich bestimmt
wieder ältere OpenGL-Befehle nehmen müssen, und damit
wird die Geschwindigkeit wieder in die Knie gehen.

Nun bitte ich Euch, mal so locker hier zu schreiben, wie alt Computer sein dürfen, auf denen euer (fiktives?) OpenGL-Programm laufen soll.

Denn, wenn ich eine OpenGL-3D-Welt mit zahlreichen Objekten erstelle, und diese noch texturiere, da glühen zwar die Alten Prozessoren auf höchster Stufe, aber wirklich flüssig wird das dann trotzdem nicht sein.
Oder?

Bin gespannt auf eure Antworten

Eastler
_________________
Kaum macht mans richtig, schon geht's


Zuletzt bearbeitet von Eastler_dart am 30.08.2008, 21:46, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
nemored



Anmeldungsdatum: 22.02.2007
Beiträge: 4704
Wohnort: ~/

BeitragVerfasst am: 22.08.2008, 16:17    Titel: Antworten mit Zitat

Sofern der Code nicht nur auf den allerneusten Rechnern läuft, würde ich ihn schon so ins Tutorial aufnehmen mit einem Hinweis darauf, dass er auf alten Rechnern nicht funktioniert. Wie du schon sagst - wenn der Rechner zu alt ist, dann ruckelt eine umfangreiche 3D-Darstellung sowieso.
_________________
Deine Chance beträgt 1:1000. Also musst du folgendes tun: Vergiss die 1000 und konzentriere dich auf die 1.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
28398



Anmeldungsdatum: 25.04.2008
Beiträge: 1917

BeitragVerfasst am: 22.08.2008, 16:46    Titel: Antworten mit Zitat

Zitat:
GL-Hersteller = Microsoft Corporation
GL-Renderer = GDI Generic


Die Grafikkarte unterstützt nichteinmal openGL. Das ist nämlich der Microsoft-Software-openGL-Treiber. Den hat jeder Windumm Computer.

Notfalls nimmst du eben wie die Profis mehrere Renderpfade... das mache ich auch! (Ich habe mehrere DLLs im Engine Folder liegen, GLRenderer1.3.dll, GLRenderer1.5.dll, GLRenderer2.0.dll und den Container GLRenderer3.0.dll (FB hat noch keine Header & Binds, und ich noch keine Treiber (weils noch gar keine gibt^^)), die werden dann dynamisch geladen und intern an eine Klasse gebunden... so einfach ist das grinsen Im Engine src findest du nicht eien gl*, glX*, wgl*, glu* oder glut*-Befehl grinsen

(Theoretisch könnte man wohl auch DX zum Rendern benutzten, aber dann müsste ich alle Shader von GLSL nach HLSL konvertieren ... kb)

Jedenfalls brauchst du nicht auf Grafikkarten achten, oder dich mit irgendwelchen Software-Treiber rumplagen. Sag' einfach mindestens openGL 1.3 oder 1.5 oder 2.0 oder wie auch immer und basta^^ oder eben mehrere Renderpfade, was aber komplex ist und viel speicher und zeit braucht (bei der entwicklung)
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Eastler_dart



Anmeldungsdatum: 25.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 22.08.2008, 18:50    Titel: Antworten mit Zitat

Hallo alle,

erst mal danke, für eure Antworten.
Aber irgendwie.....

Klar, wenn ich ein komplettes Programm schreibe, entscheide ich ja selbst, mit welcher OpenGL-Version ich mindestens arbeiten möchte. Das hängt ja klar an den Anzahlen von Objekten und verwendeten Befehlen, somit eindeutig.

Aber mir gehts hier ja darum ein Tutorial übers Texturieren in OpenGL zu schreiben - also der Versuch, zu erklären, mit welchen Befehlen in welcher Reihenfolge das Texturieren funktioniert.
Somit entscheide nicht ich, welche Version notwendig ist, sondern das hängt daran, was der Leser nach dem Tutorial noch so in den Beispielcode dazuschreibt.

Und deshalb die Frage, ab welcher Version Ihr programmieren möchtet.

NAJA, eins is ja geklärt, meine antiken 10jahresrechner (ich hatte es schon vermutet) fahren 3D also per Software im Ram über die CPU, die haben gar kein OpenGL auf der Grafikkarte fest drauf traurig.
Kann mich jedoch erinnern, daß ich mit Anim8tor auf einer solchen Maschine Fotos einer 3D-Figur geschossen hatte.
Aber ich glaub, die erklär ich im Tutorial trotzdem nicht.

Stellt sich also nur die Frage, läuft mein Beispielprogramm auch auf "richtigem" OpenGL 1.0 / 1.1 oder 1.2, kann ja sein.
Bei mir kann ichs nicht testen, hab sowas nicht.

Mal sehen, ich versuche mal ein Testprogramm zu schreiben. Wenn ichs hinkriege, stell ichs hier rein. Vielleicht finden sich hier Forum-Leser, die für mich testen - hoff.

Schreibt aber bitte trotzdem weiter eure Meinungen hier rein

danke - Eastler
_________________
Kaum macht mans richtig, schon geht's
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
cadrat



Anmeldungsdatum: 09.08.2008
Beiträge: 14
Wohnort: Jork

BeitragVerfasst am: 22.08.2008, 20:13    Titel: Antworten mit Zitat

Hallo Eastler,

klar, wenn ich helfen kann bin ich dabei. Ich begeistere mich auch für die openGL-Programmierung und hab auch schon von deinen Tutorials mächtig Honig gesaugt, also erstmal Anerkennung und Dank für dein Engagement.
Mein Profil wäre so: Notebook, ca. 5 Jahre alt. Pentium 1500 Mhz, 500 MB RAM. Läuft unter Suse-Linux 12 und der openGL-Version weisichwas (Testprogramm?). Intel 855 GM mit 3D-Unterstützung wird angezeigt. Ich schraub mal auf und sehe nach.
Ich vermute dadurch bin ich ein Kandidat der es in aktuellen Versionen wissen will?
Aber ich vermute 28398 hat schon Recht, soweit ich ihn/sie verstanden habe zwinkern zum Glück schreibst Du das Tutorial zwinkern

Wie wäre es mit einem Tutorial und zugehörigem Thread? Wäre so die didaktische Symbiose schlechthin.

Gruß

cadrat
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
28398



Anmeldungsdatum: 25.04.2008
Beiträge: 1917

BeitragVerfasst am: 22.08.2008, 20:37    Titel: Antworten mit Zitat

cadrat hat Folgendes geschrieben:
(Testprogramm?)

http://forum.qbasic.at/viewtopic.php?t=5750&start=0
http://28398labs.28.funpic.de/stuff/fbSysMon.7z (source)

Report erstellen, da stehts.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
cadrat



Anmeldungsdatum: 09.08.2008
Beiträge: 14
Wohnort: Jork

BeitragVerfasst am: 22.08.2008, 21:03    Titel: Antworten mit Zitat

Na, das Fragebein hinterm Testprogramm meinte, ob Eastler, das mit seinem Testprogramm meinte, was wir laufen lassen sollen, aber nach Nachlesen glaube ich er meint ein openGL-Testprogramm. Aber ich hoffe mein Anwenderprofil war der Sache dienlich.

PS: .7z könnt ich ja mal recherchieren was das ist, aber was um alles in der Welt sind .exe-Dateien? zwinkern
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Eastler_dart



Anmeldungsdatum: 25.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 22.08.2008, 22:43    Titel: Antworten mit Zitat

Hallo nochmal,

ja. ich versuche ein Testprogramm zu erstellen, daß Ihr als Source speichern , kompilieren und ausführen könnt. Und dieses Programm soll euch anzeigen, was ich und evtl viele Andere brauchen können.

Das Testprogramm frägt eure Grafikkarte ab, welche GL-Version von welchem Hersteller und mit welchen Extensions aufgelötet sind. Soweit für alle interessant. Sowas steht zwar normalerweise auch auf der Schachtel der Grafikkarte, aber wer kauft die schon einzeln und hat dann die Schachtel noch parat zwinkern

Aber das Testprogramm soll noch mehr können. Meine gewählten OGL-Befehle, zum speichern eines Texturebildes auf der Grafikkarte sind unterschiedlich, jenachdem, ob Opengl in nem 15/16/24/32-bit-Fenster gestartet wird und nochmal zusätzlich unterschiedlich, ob das Bild im Speicher in 15/16 oder 32-bit vorliegt.
Keinen Einfluß auf diese Befehlsoptionen hat scheinbar (auf meinen Kisten) ob man auf der Grafikkarte dann die Textur in 15/16/24/32-bit Auflösung speichert.

@cadrat: bin mir sicher, auf deinm Laptop läuft meine Routine zwinkern
Laß sie zu, nicht aufschrauben. Sollte ich das Testprogramm nicht hinkriegen, haste spätestens im Tutorial dann ne Routine, die dir sagt, was in deinem Lap an OpenGL eingebaut ist.

@28398: ist super dein Programm, aber das wird soviel Infos über den PC auswerfen, daß die paar speziellen, die ich brauche, dabei vielleicht untergehen. Und ob meine gewählten Ogl-Befehle laufen, sagt dein Tool nicht, denn sonst wäre das ein Programm, dessen Code so 60MB groß wäre zwinkern.

Also: Wer wissen will, was er drin hat, nimmt 28398's Programm, für meine konkreten Infos stell ich noch was hier rein.

Danke schon mal für die bisherigen Ausführungen, ich versuch mich zu beeilen.

Eastler
_________________
Kaum macht mans richtig, schon geht's
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
28398



Anmeldungsdatum: 25.04.2008
Beiträge: 1917

BeitragVerfasst am: 23.08.2008, 14:34    Titel: Antworten mit Zitat

Also wer heute noch 15/16 Bit Modi verwendet hat was hinter die Ohren verdient. Nicht nur, dass die Alt sind, sondern auch, weil sie deutlich langsamer sind als 32 Bit Modi.
Nach meinem Wissensstand "castet" die Windows-GDI intern alle Farben schon auf 32 Bit, selbst wenn die Desktopfarbtiefe nur 15/16 Bit beträgt.
Und spätestens seit Format wie PNG oder G3T (gut, dass kennt noch keiner ausser mir, ist aber 100% einfach, ist schnell (nach)ladbar und hat trotzdem eine gute Kompression...) ist das Argument, dass man so weniger Speicherplatz braucht auch nicht mehr das Wahre.
Jede Grafikkarte nach openGL 1.1 dürfte auf jeden Fall 32 Bit Farbtiefe unterstützten... man kann eben NICHT immer selbst die ältesten Schrottkisten unterstützen. Man muss nunmal eine klare Untergrenze ziehen.
Und sobald jemand auch die "richtigen" Herstellertreiber installiert, gibt es zumindest openGL 1.5, denn mir wäre kein zumindest HW basierender (windows) Treiber bekannt, der kein openGL 1.5 mitbringt. Und sogar MESA 3D unterstütz (glaube ich^^) openGL 1.5 .

Zitat:
Und ob meine gewählten Ogl-Befehle laufen, sagt dein Tool nicht, denn sonst wäre das ein Programm, dessen Code so 60MB groß wäre zwinkern .

Das bezweifle ich.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Eastler_dart



Anmeldungsdatum: 25.09.2005
Beiträge: 177
Wohnort: Baden-Würtemberg + Sachsen

BeitragVerfasst am: 30.08.2008, 21:45    Titel: Antworten mit Zitat

Hallo Leute,

So, ich glaub, ich habs geschafft, puh. Und beim Erarbeiten erkannt, daß eine "Umfrage", welche OpenGL-Versionen Ihr auf euren Kisten so in Betrieb habt, sehr informativ für alle sein wird.
Jedenfalls ein Testprogramm hab ich beisammen, ist nur etwas lang geworden.

BESCHREIBUNG: das Programm startet nacheinander 4 mal ein OpenGL-Fenster, jeweils in unterschiedlichen Farbtiefen (15, 16, 24 und 32 bits). In jedem dieser vier Fensteraufrufe werden jeweils drei Texturen erzeugt, die wiederum aus 3 verschiedenen Farbtiefen heraus an OpenGL übermittelt wurden.
Die vier Aufrufe von OpenGL warten jeweils auf einen Tastendruck von euch, damits weiter geht.
Am Ende kommt eine Schlußmaske, die die Ergebnisse anzeigt und auf weiteren Tastendruck in Dateien speichert.
Unter XP werden dann diese erzeugten Html-Dateien mit eurem Lieblingsbrowser angezeigt, unter W98 muß man diese separat doppelklicken, um sie in einem Browser zu öffnen.

WAS KOMMT RAUS: na hoffentlich, daß alle eure Rechner diese vielen Texturen anzeigen - grübel - bei mir sinds auch nicht alle Rechner.
Für Euch zeigt das Programm viele Infos über das aufgelötete OpenGL an. Und wenn Ihr dann aus dem Html-Ergebnis den Textteil anreißt, in die Zwischenablage kopiert und hier reinstellt, kann ich erahnen, für welche Rechnergenerationen ich das Tutorial zum Thema Texturieren ausrichten soll.

WIE GEHT DAS: wie grad gesagt. In der vom Testprogram erzeugten Html-Datei "test.htm" stehen die Infos drin, die interessant wären. Anzeigen lassen, anreißen (0hne Bilder), kopieren und hier reinstellen.

DAS PROGRAMM:
Mit dem Link: http://www.eastler.de/FreeBasic/forums/test.zip Könnt Ihr eine Zip-Datei mit 72kb runterladen, in der der Quellcode und eine für WINDOWS fertig kompilierte EXE drin liegen.
Falls Ihr selber kompilieren wollt, das TESTPROGRAMM kann nur mit FREEBASIC V 0.20 KOMPILIERT werden. Für diesen Fall setz ich das Listing gleich hier rein, dann braucht Ihr die Zip nicht zu ziehen:
Code:

'REM Testprogramm, ob auf Ihrem Rechner alle OpenGL-Befehle von mir laufen
'Eastler     22-30..Aug 2008
TYPE AuswertungsType
   OglHersteller    AS STRING * 60
   OglRenderer      AS STRING * 60
   OglVersion       AS STRING * 60
   OglErweiterungen AS STRING * 4096
   OglTreiberName   AS STRING * 32
   OglFensterBreite AS INTEGER
   OglFensterHoehe  AS INTEGER
   OglFensterTiefe  AS INTEGER
   OglColBufRotBits       AS INTEGER
   OglColBufBlauBits      AS INTEGER
   OglColBufGruenBits     AS INTEGER
   OglColBufAlphaBits     AS INTEGER
   MaxTexGroesse    AS INTEGER
   RgbaModus        AS INTEGER
   DoppelPuffer     AS INTEGER
   Stereo           AS INTEGER
   AlphaTest        AS INTEGER
   Stencil          AS INTEGER
   DepthTest        AS INTEGER
   Blending         AS INTEGER
   Dithering        AS INTEGER
   Lighting         AS INTEGER
   ColorMaterial    AS INTEGER
   TextureTest(2)   AS STRING*25
   TestTxtSource(2) AS STRING*13
END TYPE
'-------------------------
'DIMs
'-------------------------
DIM SHARED AS INTEGER AufrufLaufNr
DIM SHARED Auswertung(4) AS AuswertungsType
DIM SHARED AS STRING  Taste, FensterTreiberName
DIM SHARED AS ANY PTR TestBildPtr15, TestBildPtr16, TestBildPtr32, TestPixelPtr, TestPixelDataPtr, TmpBildPtr
DIM SHARED AS INTEGER BildHoehe, BildBreite, BildTiefe, BildZeilenBytes, BildDatenMenge, Dateinummer, TestPixel
'-------------------------
'Includes
'-------------------------
#include "fbgfx.bi"
#include once "GL/gl.bi"
#include once "GL/glu.bi"
#include once "vbcompat.bi" '<--------------um Zahlen per "format()" formatieren zu können
'-------------------------
'Declarationen
'-------------------------
DECLARE FUNCTION BildErstellen(FBBildFarbTiefe AS INTEGER) AS ANY PTR
DECLARE SUB OpenGLProgramm(OGLFarbTiefe AS INTEGER, ImageCreateTiefe AS INTEGER)
DECLARE SUB ZeigEinstellungen(Lfnr AS INTEGER)
DECLARE SUB FehlerMeldung(Art AS INTEGER, MeldeText AS STRING)
DECLARE SUB HolOpenGlInfos(LaufNr AS INTEGER)
DECLARE SUB ExtensionZerlegen(DateiNr AS INTEGER)
DECLARE SUB SpiegleBildVertikal(ByRef TestPixelPtr AS ANY PTR, ZielBildTiefe AS INTEGER)
DECLARE SUB ErstelleHtmls()
'-------------------------
'HAUTPTEIL
'-------------------------


'wir stehen in der Console.
'also Grafikfenster öffnen

   PRINT "Testprogramm, ob Eastler's TutorialOpenGLBefehle auf Ihrem Rechner laufen"
   PRINT "22-30. August 2008     V0.2"

   'das TestBild hier im FB-Screen anzeigen
   SCREEN 19,32
   LOCATE ,19 : PRINT "Testprogramm, ob Eastler's TutorialOpenGLBefehle auf Ihrem Rechner laufen"
   LOCATE ,19 : PRINT "22-30. August 2008     V0.2"
   TestBildPtr32 = BildErstellen(32)
   LOCATE ,19 : PRINT "-------------------------------------------------------------------------"
   LOCATE ,19 : PRINT "Per ImageCreate werden drei Bildpuffer erstellt,"
   LOCATE ,19 : PRINT "    je einer in 15-bit/16-bit/32-bit Farbtiefe"
   LOCATE ,19 : PRINT "per Line() wird in jeden Puffer folgendes Bild reingemalt:"
   Put ( 1,1 ), TestBildPtr32 ,(1, 1)-( 128, 128) ,PSET
   IMAGEDESTROY TestBildPtr32
   LOCATE 11
   PRINT "OpenGL wird vier mal mit unterschiedlichen Farbtiefen aufgerufen,"
   PRINT "   1 x mit 15-bit, 1 x mit 16-bit, 1 x mit 24-bit, 1 x mit 32-bit."
   PRINT
   PRINT "Und in jedem dieser verschiedenen OpenGL-Aufrufen wird getestet,"
   PRINT "ob Ihre Grafikarte die drei Texturaufloesungen in 15/16/32bit richtig anzeigt."
   PRINT
   PRINT "Sie sehen jeweils ein OpenGL-Fenster mit 3 Vierecken,"
   PRINT "jedes dieser Vierecke ist mit einer Textur aus den 3 verschiedenen Quellen"
   PRINT "texturiert worden."
   PRINT
   PRINT "Dieses Programm prueft selber, ob die Textur auch angezeigt wird,"
   PRINT "die drei OpenGL-Fenster koennen Sie einfach jeweils "
   PRINT "mit einem Tastendruck Ihrer Wahl bestaetigen."
   PRINT
   PRINT "Nach Testdurchlauf und Beendigung dieses Programmes finden Sie im Verzeichnis"
   PRINT "in dem das Programm steht, 4 Bilddateien, das sind Bildschirmkopien der"
   PRINT "einzelnen OpenGL-Anzeigen."
   PRINT
   PRINT "Ebenfalls finden Sie dort auch die Dateien Test.htm sowie Extens.txt"
   PRINT "in der Test.htm steht nochmal der Testbericht, "
   PRINT "in Extens.htm finden Sie saemtliche, auf Ihrer Grafikkarte vorhandenen"
   PRINT "OpenGL-Erweiterungen."
   PRINT "-------------------------------------------------------------------------"
   PRINT "Tastendruck = TEST STARTEN  [Esc]=Abbruch";
   Taste = INPUT(1)
   IF Taste = CHR(27) THEN IMAGEDESTROY(TestBildPtr32) : END
   PRINT "   ...gestartet..."

   OpenGLProgramm(15, 15)
   SCREEN 19,32
   OpenGLProgramm(16, 15)
   SCREEN 19,32
   OpenGLProgramm(24, 15)
   SCREEN 19,32
   OpenGLProgramm(32, 15)
   SCREEN 19,32
   'Die Ergebnisse auf dem Monitor anzeigen
   ZeigEinstellungen(4)
   PRINT "----------------------------------------------------------------------------------------"
   PRINT "Tastendruck = Ergebnisdateien Test.htm und Extens.txt erstellen"
   PRINT "  [Esc]=Abbruch"
   Taste = INPUT(1)
   IF Taste = CHR(27) THEN IMAGEDESTROY(TestBildPtr32) : END
   ErstelleHtmls()
   IF TestPixelPtr<>0 THEN IMAGEDESTROY(TestPixelPtr)
   SHELL "test.htm"
'-------------------------
SUB OpenGLProgramm(OGLFarbTiefe AS INTEGER, ImageCreateTiefe AS INTEGER)
         STATIC AS ANY PTR BildPointer(2), BildDatenPtr
         STATIC AS INTEGER Bild, Zaehler, Abstand
         STATIC AS STRING  TastenDruck, Dummy
         STATIC AS DOUBLE Zeit
         STATIC AS UINTEGER TexturNr(2), internFormat, QuellFormat, QuellTyp
   '-------------------------
   ' Open-GL Init
   '-------------------------
   AufrufLaufNr = AufrufLaufNr + 1
   SCREEN 18, OGLFarbTiefe, ,2 :'OGL-Fenster 640x480
   BildPointer(0) = BildErstellen(15)
   BildPointer(1) = BildErstellen(16)
   BildPointer(2) = BildErstellen(32)
   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
   glDisable GL_DITHER
   glClear GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT  'Tiefen- und Farbpufferbits löschen
   'TEXTURE LADEN/VORBEREITEN
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL)         :' Modus für Texturen: GL_DECAL heißt egal welche Farbe Objekt hat, voll drauf, vom Objekt schimmert nix durch
   'DIE DREI VERSCHIEDENEN(Tiefenbits) TEXTUREN AN OPENGL SCHICKEN:
   FOR Zaehler = 0 TO 2
         'Rauskriegen, in welcher Tiefe das OpenGL-Fenster gestartet wurde
         SCREENINFO Auswertung(AufrufLaufNr).OglFensterBreite, Auswertung(AufrufLaufNr).OglFensterHoehe, Auswertung(AufrufLaufNr).OglFensterTiefe,,,,Dummy
         Auswertung(AufrufLaufNr).OglTreiberName=LEFT(Dummy, 32)
         'Rauskriegen, in welcher Tiefe das Bild vorliegt:
         IF ImageInfo ( BildPointer(Zaehler), BildBreite, BildHoehe, BildTiefe, BildZeilenBytes, BildDatenPtr, BildDatenMenge)<> 0 THEN
            FehlerMeldung(1, "Fehler, die geladenen Bilddaten im Ram können nicht ausgwertet werden!")
         END IF
         Auswertung(AufrufLaufNr).TestTxtSource(Zaehler) = "(" & BildBreite & "x" & BildHoehe & "x" & BildTiefe*8 & ")"
         BildTiefe = BildTiefe * 8
         'in Abhängigkeit der "rausgekriegten" Daten das Bild als Textur auf die Grafikkarte schicken
         glGenTextures 1, @TexturNr(Zaehler)            :'OpenGl schreibt an Speicher von TexturNr den Namen(=Nummer als UINTEGER)der vorgerichteten Textur
         glBindTexture GL_TEXTURE_2D, TexturNr(Zaehler) :'Diese Textur "binden" = bei folgenden Textureinsätzen (glTexCoord2d) diese Textur verwenden
         'Rausfieseln, mit welchen Quell- Ziel- und Typ-Parametern glTexImage2D aufzurufen ist
         IF Auswertung(AufrufLaufNr).OglFensterTiefe = 15   OR Auswertung(AufrufLaufNr).OglFensterTiefe = 16  THEN internFormat = 3
         IF Auswertung(AufrufLaufNr).OglFensterTiefe = 24   OR Auswertung(AufrufLaufNr).OglFensterTiefe = 32  THEN internFormat = 4
         IF BildTiefe    = 15   OR BildTiefe = 16     THEN QuellFormat  = GL_RGB  : QuellTyp = GL_UNSIGNED_SHORT_5_6_5
         IF BildTiefe    = 32                         THEN QuellFormat  = GL_BGRA : QuellTyp = GL_UNSIGNED_INT_8_8_8_8_REV
         'MIt GL_UNSIGNED_SHORT_5_6_5 bzw. GL_UNSIGNED_INT_8_8_8_8_REV als QuellTyp braucht man keine Farben Tauschen,
         'aber läuft nicht überall, da alte OpenGL-Implementierungen diese QuellTypAngaben nicht verstehen
         glTexImage2D GL_TEXTURE_2D, 0, internFormat, BildBreite, BildHoehe, 0, QuellFormat, QuellTyp, BildDatenPtr
         glTexParameteri GL_Texture_2D, GL_Texture_Min_Filter, GL_Linear
         glTexParameteri GL_Texture_2D, GL_Texture_Mag_Filter, GL_Linear
         IMAGEDESTROY BildPointer(Zaehler)                :' Bild ist jetzt im Grafikkartenram, kann im Arbeitsspeicher wieder gelöscht werden
   NEXT Zaehler
         HolOpenGlInfos(AufrufLaufNr)
         TastenDruck = ""
         Abstand = -5
         DO WHILE TastenDruck = ""                              :'die Schleife solange immer wiederholen, bis irgendeine Taste gedrückt wird
            TastenDruck = INKEY                                 :'Verschachtelte Inkey spinnen, aber Hauptprog mit INPUT(1) und dann hier Inkey geht
            glEnable GL_TEXTURE_2D                           :' Enable 2D Texture Mapping
            glClear GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT  :'bisherig erstellte Objekte löschen, unsere 3D-Welt wieder von Neuem an erstellen
            glPushMatrix                                        :'aktuelle Position + Drehgrade sichern (2.Zettel mit gleicher Pos auf PositionsSTACK)
            glTranslatef 0, 0, 0                                :'Verschiebung der "Kamera" sodaß sie das Objekt "sieht"
            'einfach drei Vierecke (gegen Uhrzeiger) nebeneinander mit den 3 Texturen
            glColor3f 1.0,0.0,0.0
            FOR Zaehler=0 TO 2
            glBindTexture GL_TEXTURE_2D, TexturNr(Zaehler)
            glBegin GL_QUADS
               glTexCoord2d 0.0, 1.0
               glVertex3f -2.5+Zaehler*1.5, 0.5, Abstand
               glTexCoord2d 0.0, 0.0
               glVertex3f -2.5+Zaehler*1.5, -0.5,Abstand
               glTexCoord2d 1.0, 0.0
               glVertex3f -1.5+Zaehler*1.5, -0.5,Abstand
               glTexCoord2d 1.0, 1.0
               glVertex3f -1.5+Zaehler*1.5, 0.5, Abstand
            glEnd
            NEXT Zaehler
            glDisable GL_TEXTURE_2D
            'angezeigtes OpenGL-Bild (colorbuffer) in ImageCreate-Ramspeicher kopieren
         IF TestPixelPtr=0 THEN TestPixelPtr=ImageCreate(640, 480, 0, 32)
         DIM AS INTEGER TestBreite, TestHoehe, TestTiefe, TestZeilenBytes, TestDatenMenge
         IF ImageInfo(TestPixelPtr, TestBreite, TestHoehe, TestTiefe, TestZeilenBytes, TestPixelDataPtr, TestDatenMenge)<> 0 THEN BEEP
         glReadPixels(1, 1, TestBreite, TestHoehe, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, TestPixelDataPtr)
         'Auswerten ob Rotes Quadrat oder texturiertes angezeigt wurde
         glReadPixels( 40, 365, 1, 1,  GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, @TestPixel)
         IF (TestPixel AND 255) > 240 AND (TestPixel SHR 8 AND 255) > 240 AND (TestPixel SHR 16 AND 255) < 10 THEN
            Auswertung(AufrufLaufNr).TextureTest(0) = " JA "
         ELSE Auswertung(AufrufLaufNr).TextureTest(0) = " NEIN "
         END IF
         Auswertung(AufrufLaufNr).TextureTest(0) = Auswertung(AufrufLaufNr).TextureTest(0) & "(RGBA=" & (TestPixel AND 255) & "x" &(TestPixel SHR 8 AND 255) & "x" &(TestPixel SHR 16 AND 255) & "x" &(TestPixel SHR 24 AND 255) & ")"
         glReadPixels(259, 365, 1, 1,  GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, @TestPixel)
         IF (TestPixel AND 255) > 240 AND (TestPixel SHR 8 AND 255) > 240 AND (TestPixel SHR 16 AND 255) < 10 THEN
            Auswertung(AufrufLaufNr).TextureTest(1) = " JA "
         ELSE Auswertung(AufrufLaufNr).TextureTest(1) = " NEIN "
         END IF
         Auswertung(AufrufLaufNr).TextureTest(1) = Auswertung(AufrufLaufNr).TextureTest(1) & "(RGBA=" & (TestPixel AND 255) & "x" &(TestPixel SHR 8 AND 255) & "x" &(TestPixel SHR 16 AND 255) & "x" &(TestPixel SHR 24 AND 255) & ")"
         glReadPixels(475, 365, 1, 1,  GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, @TestPixel)
         IF (TestPixel AND 255) > 240 AND (TestPixel SHR 8 AND 255) > 240 AND (TestPixel SHR 16 AND 255) < 10 THEN
            Auswertung(AufrufLaufNr).TextureTest(2) = " JA "
         ELSE Auswertung(AufrufLaufNr).TextureTest(2) = " NEIN "
         END IF
         Auswertung(AufrufLaufNr).TextureTest(2) = Auswertung(AufrufLaufNr).TextureTest(2) & "(RGBA=" & (TestPixel AND 255) & "x" &(TestPixel SHR 8 AND 255) & "x" &(TestPixel SHR 16 AND 255) & "x" &(TestPixel SHR 24 AND 255) & ")"
         FLIP
         LOOP
         glDisable GL_TEXTURE_2D
         'Ram-Kopie Colorbuffer als Bitmapdatei speichern
         SpiegleBildVertikal(TestPixelPtr, 32) :'Bild ist vertikal falschrum bei OpenGL, auf FreeBasicFormat umstellen
         BSave( "durchlauf" & AufrufLaufNr & ".bmp", TestPixelPtr )
END SUB
'-------------------------
FUNCTION BildErstellen(FBBildFarbTiefe AS INTEGER) AS ANY PTR
   STATIC AS ANY PTR BildAdresse
   DIM AS INTEGER Zaehler
   'EIN Bild IM RAM ERZEUGEN, DAS ALS TEXTUR VERWENDET WERDEN SOLL
   BildAdresse = IMAGECREATE(128,128,RGB(0,0,255), FBBildFarbTiefe)  :'Ramspeicherbereich für Bild 128x128 Pixel x FBBildFarbTiefe-bits, erst mal blau
   IF BildAdresse = 0 THEN
      PRINT "FEHLER, Imagecreate hat keinen Speicher erhalten!"
      PRINT "Breche ab"
      DO WHILE INKEY="" : LOOP
      END
   END IF
   FOR Zaehler=1 to 64
      Line BildAdresse, (64-Zaehler, 64-Zaehler)-(64+Zaehler, 64+Zaehler), RGB(0, Zaehler*4, Zaehler*4), B
   NEXT Zaehler
   BildErstellen = BildAdresse
END FUNCTION
'-------------------------
SUB FehlerMeldung(Art AS INTEGER, MeldeText AS STRING)
   'einen Fehlertext auf dem Consolefenster ausgeben
   'falls in Art eine 1 drin ist, Programm beenden
   DIM AS INTEGER Dateinummer
   DIM AS STRING Taste
   DateiNummer = FREEFILE
   OPEN CONS FOR OUTPUT AS #Dateinummer
   PRINT #DateiNummer, MeldeText
   IF Art = 1 THEN
      PRINT #DateiNummer, "Taste = Programmende"
      Taste = ""
      DO WHILE Taste = ""
         Taste = INPUT(0)
      LOOP
      CLOSE #Dateinummer
      END
   END IF
   CLOSE #Dateinummer
END SUB
'-------------------------
SUB HolOpenGlInfos(LaufNr AS INTEGER)
         DIM AS STRING Dummy1, Dummy2, Dummy3, Dummy4
         DIM AS UBYTE PTR GlTextPtr
         DIM AS INTEGER Zaehler
         'Infos zu OpenGL
         GlTextPtr = glGetSTring(GL_Vendor)
         FOR Zaehler = 0 TO 59 : IF GlTextPtr[Zaehler] <> 0 THEN Auswertung(LaufNr).OglHersteller = Auswertung(LaufNr).OglHersteller & chr(GlTextPtr[Zaehler]) ELSE Zaehler = 60 END IF : NEXT Zaehler
         GlTextPtr = glGetSTring(GL_Renderer)
         FOR Zaehler = 0 TO 59 : IF GlTextPtr[Zaehler] <> 0 THEN Auswertung(LaufNr).OglRenderer = Auswertung(LaufNr).OglRenderer & chr(GlTextPtr[Zaehler]) ELSE Zaehler = 60 END IF : NEXT Zaehler
         GlTextPtr = glGetSTring(GL_Version)
         FOR Zaehler = 0 TO 59 : IF GlTextPtr[Zaehler] <> 0 THEN Auswertung(LaufNr).OglVersion = Auswertung(LaufNr).OglVersion & chr(GlTextPtr[Zaehler]) ELSE Zaehler = 60 END IF : NEXT Zaehler
         GlTextPtr = glGetSTring(GL_Extensions)
         FOR Zaehler = 0 TO 4096 : IF GlTextPtr[Zaehler] <> 0 THEN Auswertung(LaufNr).OglErweiterungen = Auswertung(LaufNr).OglErweiterungen & chr(GlTextPtr[Zaehler]) ELSE Zaehler = 4096 END IF : NEXT Zaehler
         'OpenGL-Einstellungen abfragen für spätere Anzeige
         glGetIntegerV(GL_MAX_TEXTURE_SIZE, @Auswertung(AufrufLaufNr).MaxTexGroesse)
         glGetIntegerV(GL_RGBA_MODE,        @Auswertung(AufrufLaufNr).RgbaModus)
         glGetIntegerV(GL_DOUBLEBUFFER    , @Auswertung(AufrufLaufNr).DoppelPuffer)
         glGetIntegerV(GL_STEREO,           @Auswertung(AufrufLaufNr).Stereo)
         IF glIsEnabled(GL_ALPHA_TEST)     THEN Auswertung(AufrufLaufNr).AlphaTest = 1 ELSE Auswertung(AufrufLaufNr).AlphaTest = 0
         IF glIsEnabled(GL_STENCIL_TEST)   THEN Auswertung(AufrufLaufNr).Stencil = 1 ELSE Auswertung(AufrufLaufNr).Stencil = 0
         IF glIsEnabled(GL_DEPTH_TEST)     THEN Auswertung(AufrufLaufNr).DepthTest = 1 ELSE Auswertung(AufrufLaufNr).DepthTest = 0
         IF glIsEnabled(GL_BLEND)          THEN Auswertung(AufrufLaufNr).Blending = 1 ELSE Auswertung(AufrufLaufNr).Blending = 0
         IF glIsEnabled(GL_DITHER)         THEN Auswertung(AufrufLaufNr).Dithering = 1 ELSE Auswertung(AufrufLaufNr).Dithering = 0
         IF glIsEnabled(GL_LIGHTING)       THEN Auswertung(AufrufLaufNr).Lighting = 1 ELSE Auswertung(AufrufLaufNr).Lighting = 0
         IF glIsEnabled(GL_COLOR_MATERIAL) THEN Auswertung(AufrufLaufNr).ColorMaterial = 1 ELSE Auswertung(AufrufLaufNr).ColorMaterial = 0
         'die Bit-Tiefen der einzelnen Farbebenen Im ColorBuffer abfragen
         glGetIntegerV(GL_Red_Bits,   @Auswertung(AufrufLaufNr).OglColBufRotBits)
         glGetIntegerV(GL_Green_Bits, @Auswertung(AufrufLaufNr).OglColBufGruenBits)
         glGetIntegerV(GL_Blue_Bits,  @Auswertung(AufrufLaufNr).OglColBufBlauBits)
         glGetIntegerV(GL_Alpha_Bits, @Auswertung(AufrufLaufNr).OglColBufAlphaBits)
END SUB
'-------------------------
SUB ZeigEinstellungen(Lfnr AS INTEGER)
   DIM AS INTEGER Zaehler
   DIM AS STRING Taste
   COLOR &hFFFFFF
   FOR Zaehler = 1 TO Lfnr
      IF Zaehler=1 THEN
         PRINT "OPEN-GL-TEST Eastler_dart V0.2 Testen, ob Ihr OpenGL Texturen aus ImageCreate laden kann"
         PRINT "----------------------------------------------------------------------------------------"
            COLOR &h6666FF : PRINT "OPEN-GL " : COLOR &hFFFFFF
            PRINT "Hersteller:";     : LOCATE ,16 : PRINT Auswertung(Zaehler). OglHersteller
            PRINT "Version:";        : LOCATE ,16 : PRINT Auswertung(Zaehler).OglVersion
            PRINT "Renderer:";       : LOCATE ,16 : PRINT Auswertung(Zaehler).OglRenderer
            'Das Feld Erweiterungen ist zu lang für eine Anzeigezeile, zerlegen
            PRINT "Erweiterungen: "; : LOCATE ,16 : PRINT LEFT(Auswertung(Zaehler).OglErweiterungen, 60);"..."
            IF Auswertung(Zaehler).RgbaModus    THEN PRINT "RGBA-Modus=vorhanden ";
            IF Auswertung(Zaehler).DoppelPuffer THEN PRINT "Doppelpuffermodus=vorhanden ";
            IF Auswertung(Zaehler).Stereo       THEN PRINT "StereoBilderModus=vorhanden ";
            PRINT "Maximale Texturgroesse=" & Auswertung(Zaehler).MaxTexGroesse
            COLOR &h6666FF : PRINT "EINSTELLUNGEN:" : COLOR &hFFFFFF
            IF Auswertung(Zaehler).AlphaTest = 1 THEN PRINT "Alpha-Test=EIN ";   ELSE PRINT "Alpha-Test=AUS ";
            IF Auswertung(Zaehler).Stencil   = 1 THEN PRINT "Stencil-Test=EIN "; ELSE PRINT "Stencil-Test=AUS ";
            IF Auswertung(Zaehler).DepthTest = 1 THEN PRINT "Depth-Test=EIN ";   ELSE PRINT "Depth-Test=AUS ";
            IF Auswertung(Zaehler).Blending = 1  THEN PRINT "Blending=EIN ";     ELSE PRINT "Blending=AUS ";
            IF Auswertung(Zaehler).Dithering = 1 THEN PRINT "Dithering=EIN ";    ELSE PRINT "Dithering=AUS ";
            IF Auswertung(Zaehler).Lighting = 1  THEN PRINT "Lighting=EIN "      ELSE PRINT "Lighting=AUS "
            IF Auswertung(Zaehler).ColorMaterial = 1 THEN PRINT "ColorMaterial=EIN " ELSE PRINT "ColorMaterial=AUS "
      END IF
      COLOR &h6666FF : PRINT "TESTERGEBNISSE "; : COLOR &hFFFFFF : PRINT "Durchgang " & Zaehler & " (von 4)";
      PRINT "OpenGL-Testfenster war:" & Auswertung(Zaehler).OglFensterBreite & " X " & Auswertung(Zaehler).OglFensterHoehe & " X ";
      COLOR &hFF0000 : PRINT Auswertung(Zaehler).OglFensterTiefe : COLOR &hFFFFFF
      PRINT "OGL-Farbtiefen: R/G/B/A:" & Auswertung(Zaehler).OglColBufRotBits & "/" & Auswertung(Zaehler).OGLColBufGruenBits & "/" & Auswertung(Zaehler).OGLColBufBlauBits & "/" & Auswertung(Zaehler).OGLColBufAlphaBits
      PRINT "TexturQuelle 15/16/32bit:";
      COLOR &hFF0000 : PRINT Auswertung(Zaehler).TestTxtSource(0) & Auswertung(Zaehler).TextureTest(0); : COLOR &hFFFFFF
      PRINT "/";
      COLOR &hFF0000 : PRINT Auswertung(Zaehler).TestTxtSource(1) & Auswertung(Zaehler).TextureTest(1); : COLOR &hFFFFFF
      PRINT "/";
      COLOR &hFF0000 : PRINT Auswertung(Zaehler).TestTxtSource(2) & Auswertung(Zaehler).TextureTest(2)  : COLOR &hFFFFFF
   NEXT Zaehler
END SUB
'-------------------------
SUB ExtensionZerlegen(DateiNr AS INTEGER)
   DIM AS STRING Dummy
   DIM AS INTEGER LfNr, Laeufer, Zeilenlaenge = 63
      Dummy = Auswertung(1).OglErweiterungen :'Inhalt in Kopievariable "Dummy"
      Dummy = RTRIM(Dummy)                      :'Hinten dran hängende Leerzeichen entfernen
      DO WHILE LEN(Dummy) > Zeilenlaenge
         IF INSTR(   MID(Dummy,1,Zeilenlaenge), " "  ) <> 0 THEN
            'Wenn in den ersten 63 Buchstaben (passen in die Zeile) ein Leerzeichen vorkommt,
            'das am hintensten liegende raussuchen,
            Laeufer = Zeilenlaenge
            DO WHILE MID(Dummy,Laeufer,1 ) <> " "
               Laeufer = Laeufer - 1
            LOOP
            'Text bis zu diesem Leerzeichen anzeigen
            PRINT #DateiNr, "<TR><TD></TD><TD>"; MID(Dummy, 1, Laeufer ); "</TD></TR>"
            'und den Angezeigten Text vorne von Dummy wegnehmen
            Dummy = MID(Dummy, Laeufer+1 )
         ELSE
            'Falls kein Leerzeichen in den ersten 63 Buchstaben
            ' "brutal" bis zum 63. anzeigen und dort umbrechen
            PRINT #DateiNr, "<TR><TD></TD><TD>"; MID(Dummy, 1, Zeilenlaenge ); "</TD></TR>"
            'und diese 63 Zeichen vorne von Dummy wegnehmen
            Dummy = MID(Dummy, Zeilenlaenge+1 )
         END IF
      LOOP
      'Jetzt ist noch der Rest in Dummy, der in eine Zeile paßt
      PRINT #DateiNr, "<TR><TD></TD><TD>"; Dummy; "</TD></TR>"
      PRINT #DateiNr, "<TR><TD></TD><TD>"; "Laenge String Erweiterungen: " & LEN(  RTRIM( Auswertung(1).OglErweiterungen )  ) & " Bytes</TD></TR>"
END SUB
'-------------------------
SUB SpiegleBildVertikal(ByRef TestPixelPtr AS ANY PTR, ZielBildTiefe AS INTEGER)
   DIM AS ANY PTR BildPixelDataPtr, tempPixelDataPtr
   DIM AS INTEGER BildBreite, BildHoehe, BildTiefe, BildZeilenBytes, BildDatenMenge, ZeilenZaehler, KopieZeile
   DIM AS INTEGER tempBreite, tempHoehe, tempTiefe, tempZeilenBytes, tempDatenMenge, QuellOffset, ZielOffset
   'Infos über Quellbild holen
   IF ImageInfo(TestPixelPtr, BildBreite, BildHoehe, BildTiefe, BildZeilenBytes, BildPixelDataPtr, BildDatenMenge)<> 0 THEN
      FehlerMeldung(1, "SpiegleBildVertikal: ImageInfo erhielt keine InfoDaten aus dem OriginalBild!")
   END IF
   'Speicherplatz für Kopie reservieren
'   TmpBildPtr = ImageCreate(BildBreite, BildHoehe, 0, ZielBildTiefe)
   TmpBildPtr = ImageCreate(BildBreite, BildHoehe, 0, 32)
   IF TmpBildPtr=0 THEN FehlerMeldung(1, "SpiegleBildVertikal: ImageCreate erhielt keinen Ram für Bildkopie!")
   'Infos zu der Kopie holen (Datenpointer)
   IF ImageInfo(TmpBildPtr, tempBreite, tempHoehe, tempTiefe, tempZeilenBytes, tempPixelDataPtr, tempDatenMenge)<> 0 THEN
      FehlerMeldung(1, "SpiegleBildVertikal: ImageInfo erhielt keine InfoDaten zu dem Kopie-Bild!")
   END IF
   'Die Pixelzeilen aus TestPixelPtr(=Quelle) vertauscht nach TmpBildPtr(=Ziel) schreiben
   FOR ZeilenZaehler = 0 TO BildHoehe-1
      QuellOffset = ZeilenZaehler*BildZeilenBytes
      ZielOffset  = (BildHoehe-1)*BildZeilenBytes-ZeilenZaehler*BildZeilenBytes
      ImageConvertRow(BildPixelDataPtr + QuellOffset,        BildTiefe*8, _
                      tempPixelDataPtr + ZielOffset ,       tempTiefe*8, _
                      BildBreite, 0)
   NEXT ZeilenZaehler
   SWAP TestPixelPtr, TmpBildPtr
   IF TmpBildPtr <> 0 THEN IMAGEDESTROY TmpBildPtr
END SUB
'-------------------------
SUB ErstelleHtmls()
   DIM AS INTEGER Zaehler, DateiNummer
   DIM AS STRING Taste, DateiName
   DateiName = "test.htm"
   DateiNummer = FREEFILE
   OPEN DateiName FOR OUTPUT AS #DateiNummer
   PRINT #DateiNummer, "<HTML><HEAD><TITLE>Eastlers OpenGL-Test-Bericht</TITLE></HEAD><BODY><TABLE Border=0>"
   FOR Zaehler = 1 TO 4
      IF Zaehler=1 THEN
         PRINT #DateiNummer, "<TR><TD COLSPAN=2>OPEN-GL-TEST Eastler_dart      Testen, ob Ihr OpenGL Texturen aus ImageCreate laden kann</TD></TR>"
         PRINT #DateiNummer, "<TR><TD COLSPAN=2><hr></TD></TR>"
            PRINT #DateiNummer, "<TR><TD COLSPAN=2><H3> OPEN-GL </H3></TD></TR>"
            PRINT #DateiNummer, "<TR><TD>Hersteller:</TD><TD>"; RTRIM(Auswertung(Zaehler).OglHersteller); "</TD></TR>"
            PRINT #DateiNummer, "<TR><TD>Version:   </TD><TD>"; RTRIM(Auswertung(Zaehler).OglVersion);    "</TD></TR>"
            PRINT #DateiNummer, "<TR><TD>Renderer:  </TD><TD>"; RTRIM(Auswertung(Zaehler).OglRenderer);   "</TD></TR>"
            'Das Feld Erweiterungen ist zu lang für eine Anzeigezeile, zerlegen
            PRINT #DateiNummer, "<TR><TD><A HREF=extens.htm TITLE=Alle_Erweiterungen_Auflisten ALT=Alle_Erweiterungen_Auflisten> Erweiterungen:</A></TD>"
            PRINT #DateiNummer, "<TD>"; LEFT(Auswertung(1).OglErweiterungen, 50);"...</TD></TR>"
            PRINT #DateiNummer, "<TR><TD>RGBA-Modus</TD><TD>"           :IF Auswertung(Zaehler).RgbaModus    THEN PRINT #DateiNummer, "vorhanden </TD></TR>"; ELSE PRINT #DateiNummer, "nicht vorhanden </TD></TR>";
            PRINT #DateiNummer, "<TR><TD>DoppelPuffer-Modus</TD><TD>"   :IF Auswertung(Zaehler).DoppelPuffer THEN PRINT #DateiNummer, "vorhanden </TD></TR>"; ELSE PRINT #DateiNummer, "nicht vorhanden </TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Stereo-Modus</TD><TD>"         :IF Auswertung(Zaehler).Stereo       THEN PRINT #DateiNummer, "vorhanden </TD></TR>"; ELSE PRINT #DateiNummer, "nicht vorhanden </TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Maximale Texturgroesse</TD><TD>" & Auswertung(Zaehler).MaxTexGroesse & "</TD></TR>"
            PRINT #DateiNummer, "<TR><TD COLSPAN=2><H3>EINSTELLUNGEN:</H3></TD></TR>"
            PRINT #DateiNummer, "<TR><TD>Alpha-Test</TD><TD>"   :IF Auswertung(Zaehler).AlphaTest = 1     THEN PRINT #DateiNummer, "EIN</TD></TR>";    ELSE PRINT #DateiNummer, "AUS</TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Stencil-Test</TD><TD>" :IF Auswertung(Zaehler).Stencil = 1       THEN PRINT #DateiNummer, "EIN</TD></TR> "; ELSE PRINT #DateiNummer, "AUS</TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Depth-Test</TD><TD>"   :IF Auswertung(Zaehler).DepthTest = 1     THEN PRINT #DateiNummer, "EIN</TD></TR> ";   ELSE PRINT #DateiNummer, "AUS</TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Blending</TD><TD>"     :IF Auswertung(Zaehler).Blending = 1      THEN PRINT #DateiNummer, "EIN</TD></TR> ";     ELSE PRINT #DateiNummer, "AUS</TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Dithering</TD><TD>"    :IF Auswertung(Zaehler).Dithering = 1     THEN PRINT #DateiNummer, "EIN</TD></TR> ";    ELSE PRINT #DateiNummer, "AUS</TD></TR>";
            PRINT #DateiNummer, "<TR><TD>Lighting</TD><TD>"     :IF Auswertung(Zaehler).Lighting = 1      THEN PRINT #DateiNummer, "EIN</TD></TR>"      ELSE PRINT #DateiNummer,  "AUS</TD></TR>"
            PRINT #DateiNummer, "<TR><TD>ColorMaterial</TD><TD>":IF Auswertung(Zaehler).ColorMaterial = 1 THEN PRINT #DateiNummer, "EIN</TD></TR>" ELSE PRINT #DateiNummer, "AUS </TD></TR>"
      END IF
      PRINT #DateiNummer, "<TR><TD COLSPAN=2><H3>TESTERGEBNISSE </H3>"; " Durchgang " & Zaehler & " (von 4)</TD></TR>";
      PRINT #DateiNummer, "<TR><TD>OpenGL-Testfenster war:</TD><TD>" & Auswertung(Zaehler).OglFensterBreite & " X " & Auswertung(Zaehler).OglFensterHoehe & " X ";
      PRINT #DateiNummer, Auswertung(Zaehler).OglFensterTiefe;"</TD></TR>"
      PRINT #DateiNummer, "<TR><TD>OGL-Farbtiefen: R/G/B/A:</TD><TD>" & Auswertung(Zaehler).OglColBufRotBits & "/" & Auswertung(Zaehler).OGLColBufGruenBits & "/" & Auswertung(Zaehler).OGLColBufBlauBits & "/" & Auswertung(Zaehler).OGLColBufAlphaBits;"</TD></TR>";
      PRINT #DateiNummer, "<TR><TD>TexturQuelle 15/16/32bit:</TD><TD>"; Auswertung(Zaehler).TestTxtSource(0) & Auswertung(Zaehler).TextureTest(0);
      PRINT #DateiNummer, "/"; Auswertung(Zaehler).TestTxtSource(1) & Auswertung(Zaehler).TextureTest(1);
      PRINT #DateiNummer, "/"; Auswertung(Zaehler).TestTxtSource(2) & Auswertung(Zaehler).TextureTest(2);"</TD></TR>"
   NEXT Zaehler
   PRINT #DateiNummer, "<TR><TD COLSPAN=2><IMG SRC=durchlauf1.bmp></IMG>  </TD></TR>"
   PRINT #DateiNummer, "<TR><TD COLSPAN=2><IMG SRC=durchlauf2.bmp></IMG>  </TD></TR>"
   PRINT #DateiNummer, "<TR><TD COLSPAN=2><IMG SRC=durchlauf3.bmp></IMG>  </TD></TR>"
   PRINT #DateiNummer, "<TR><TD COLSPAN=2><IMG SRC=durchlauf4.bmp></IMG>  </TD></TR>"
   PRINT #DateiNummer, "</TABLE></BODY></HTML>"
   CLOSE #DateiNummer
   DateiName = "extens.htm"
   DateiNummer = FREEFILE
   OPEN DateiName FOR OUTPUT AS #DateiNummer
   PRINT #DateiNummer, "<HTML><HEAD><TITLE>Eastlers OpenGL-Test-Bericht</TITLE></HEAD><BODY><TABLE Border=0>"
   PRINT #DateiNummer, "<TR><TD COLSPAN=2> <A HREF=test.htm>Zurück zu den Testergebnissen</A></TD></TR>"
   PRINT #DateiNummer, "<TR><TD COLSPAN=2><h4>auf Ihrer Grafikkarte installierte Erweiterungen:</h4></TD></TR>"
   ExtensionZerlegen(DateiNummer)
   PRINT #DateiNummer, "<TR><TD COLSPAN=2> <A HREF=test.htm>Zurück zu den Testergebnissen</A></TD></TR>"
   PRINT #DateiNummer, "</TABLE></BODY></HTML>"
   CLOSE #DateiNummer

END SUB


bin ja gespannt was da jetzt so rauskommt

Eastler
_________________
Kaum macht mans richtig, schon geht's


Zuletzt bearbeitet von Eastler_dart am 31.08.2008, 20:08, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen Yahoo Messenger
28398



Anmeldungsdatum: 25.04.2008
Beiträge: 1917

BeitragVerfasst am: 31.08.2008, 00:54    Titel: Antworten mit Zitat

Wie nicht anders zu erwarten läuft alles mit den Augen rollen

Zitat:
OPEN-GL-TEST Eastler_dart Testen, ob Ihr OpenGL Texturen aus ImageCreate laden kann

OPEN-GL
Hersteller: NVIDIA Corporation
Version: 2.1.2
Renderer: GeForce 8800 GTS/PCI/SSE2
Erweiterungen: GL_ARB_color_buffer_float GL_ARB_depth_texture GL_...
RGBA-Modus vorhanden
DoppelPuffer-Modus vorhanden
Stereo-Modus nicht vorhanden
Maximale Texturgroesse 8192
EINSTELLUNGEN:
Alpha-Test AUS
Stencil-Test AUS
Depth-Test EIN
Blending AUS
Dithering AUS
Lighting AUS
ColorMaterial AUS
TESTERGEBNISSE
Durchgang 1 (von 4)
OpenGL-Testfenster war: 640 X 480 X 16
OGL-Farbtiefen: R/G/B/A: 8/8/8/0
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=247x247x0x255)
TESTERGEBNISSE
Durchgang 2 (von 4)
OpenGL-Testfenster war: 640 X 480 X 16
OGL-Farbtiefen: R/G/B/A: 8/8/8/0
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=247x247x0x255)
TESTERGEBNISSE
Durchgang 3 (von 4)
OpenGL-Testfenster war: 640 X 480 X 32
OGL-Farbtiefen: R/G/B/A: 8/8/8/0
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=247x247x0x255)
TESTERGEBNISSE
Durchgang 4 (von 4)
OpenGL-Testfenster war: 640 X 480 X 32
OGL-Farbtiefen: R/G/B/A: 8/8/8/0
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=247x247x0x255)
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
cadrat



Anmeldungsdatum: 09.08.2008
Beiträge: 14
Wohnort: Jork

BeitragVerfasst am: 31.08.2008, 21:04    Titel: Antworten mit Zitat

Musste grad den Rechner komplett neu aufbauen mit dem Kopf durch die Mauer wollen . Bekomme im Moment die Meldung:

/usr/share/freebasic/bin/linux/ld: cannot find -lX11

Von 0.2 auf 1.85 zurückgedatet (wasn das fürn Wort mit den Augen rollen ) :

Code:
test.bas(160) error 41: Variable not declared, ImageInfo in 'IF ImageInfo ( BildPointer(Zaehler), BildBreite, BildHoehe, BildTiefe, BildZeilenBytes, BildDatenPtr, BildDatenMenge)<> 0 THEN
test.bas(160) warning 12(0): Implicit variable allocation, ImageInfo
test.bas(208) error 67: Array not dimensioned, before '(' in 'IF ImageInfo(TestPixelPtr, TestBreite, TestHoehe, TestTiefe, TestZeilenBytes, TestPixelDataPtr, TestDatenMenge)<> 0 THEN BEEP'
test.bas(381) warning 12(0): Implicit variable allocation, ImageInfo
test.bas(381) error 67: Array not dimensioned, before '(' in 'IF ImageInfo(TestPixelPtr, BildBreite, BildHoehe, BildTiefe, BildZeilenBytes, BildPixelDataPtr, BildDatenMenge)<> 0 THEN'
test.bas(389) error 67: Array not dimensioned, before '(' in 'IF ImageInfo(TmpBildPtr, tempBreite, tempHoehe, tempTiefe, tempZeilenBytes, tempPixelDataPtr, tempDatenMenge)<> 0 THEN'


PS: Glaub die 0.20 Installation für Linux ist im Dutt, läßt sich nicht dekomprimieren: ARK mosert ...


Zuletzt bearbeitet von cadrat am 01.09.2008, 18:53, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
nemored



Anmeldungsdatum: 22.02.2007
Beiträge: 4704
Wohnort: ~/

BeitragVerfasst am: 31.08.2008, 22:29    Titel: Antworten mit Zitat

Ich habe gar nicht vor, auf meinem Laptop großartig 3D-Programme laufen zu lassen, hier aber dessen Testergebnisse:
Zitat:
Hersteller: Tungsten Graphics, Inc
Version: 1.3 Mesa 7.0.3-rc2
Renderer: Mesa DRI Intel(R) 852GM/855GM 20061017 x86/MMX/SSE2
Erweiterungen: GL_ARB_imaging GL_ARB_multisample GL_ARB_multitext...
RGBA-Modus vorhanden
DoppelPuffer-Modus vorhanden
Stereo-Modus nicht vorhanden
Maximale Texturgroesse 2048
EINSTELLUNGEN:
ALPHA-Test AUS
Stencil-Test AUS
Depth-Test EIN
Blending AUS
Dithering AUS
Lighting AUS
ColorMaterial AUS
TESTERGEBNISSE
Durchgang 1 (von 4)
OpenGL-Testfenster war: 640 X 480 X 16
OGL-Farbtiefen: R/G/B/A: 8/8/8/8
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=248x248x0x255)
TESTERGEBNISSE
Durchgang 2 (von 4)
OpenGL-Testfenster war: 640 X 480 X 16
OGL-Farbtiefen: R/G/B/A: 8/8/8/8
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=248x248x0x255)
TESTERGEBNISSE
Durchgang 3 (von 4)
OpenGL-Testfenster war: 640 X 480 X 32
OGL-Farbtiefen: R/G/B/A: 8/8/8/8
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=248x248x0x255)
TESTERGEBNISSE
Durchgang 4 (von 4)
OpenGL-Testfenster war: 640 X 480 X 32
OGL-Farbtiefen: R/G/B/A: 8/8/8/8
TexturQuelle 15/16/32bit: (128x128x16) JA (RGBA=255x252x0x255)/(128x128x16) JA (RGBA=247x246x0x255)/(128x128x32) JA (RGBA=248x248x0x255)

_________________
Deine Chance beträgt 1:1000. Also musst du folgendes tun: Vergiss die 1000 und konzentriere dich auf die 1.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC. Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.

 Impressum :: Datenschutz