Hi,

Mein Problem ich habe eine Bilddatei die auf BMP-Basis 8-Bit 210 MB hat (Stadtplan).
Ich habe versucht die mit Paintbox und Blt verfahren zu laden und damit dann zu navigieren. Das bedeutet zu scrollen... funzt wunderbar !!
Aber sobald ich noch die Zoom-Funktion einbauen wollte wird alles zu langsam.

Ich habe viel gelesen aber leider nicht das richtige gefunden um in opengl dieses zu realisieren.
Als Textur kann ich mein Bild nicht Laden, denn auf meiner GraKa sind nur Texturen bis max 4500x4500 erlaubt aber mein Bild hat ca.
16000x13000 px.

Ich möchte mein Stadtplan schnellstmöglich laden und damit arbeiten(scrollen,zoomen) wie ist das mit OpenGL oder egal welcher
Variante auch immer gut zu lösen ?

Ich brauch da eure Hilfe zu...

Dank im Voraus...oz

In OpenGL musst du den Stadtplan in kleinere Quadranten zerlegen.
Danach ist Zoom und Bewegung nur noch ein logistisches Problem.
Von der Geschwindigkeit sollte es auch gehen.

Ja, auf jeden Fall muss dein Gebilde in viele kleine Quadrate gesetzt werden. Ist die Frage für welche Zielsysteme das ganze gedacht ist, aber ich würde fast gen 256x256 gehen. Dennoch ist die menge ja nicht ganz ohne, so dass es ggf. Sinn macht ähnliche Verfahren zu nehmen wie z.B. Goole Earth.
1. Seperat Bilder parallel nachladen und ungeladene Bereiche solange mit einer Standard-Textur belegen, solange sie nicht geladen wurden.
2. Unbedingt eine Sichtberechnung durchführen. Was in OpenGL Geschwindigkeit kostet ist das Wechseln von Texturen und das hast Du auch hier definitiv. Also nur soviele Texturen wechseln wie auch wirklich sichtbar gebraucht werden. Zugegeben, neuere Grafikkarten hauen so manches schnell über den Äther, aber ich unterstelle Dir, dass Du auch alte nutzen willst
3. Ggf. bei einem sehr weiten Zoom umspringen auf anderes Bildmaterial. Z.B. wenn die gesamte Stadt angezeigt werden soll, nur noch ein Quad mit einer stark verkleinerten Textur deines Bildes verwenden.

_________________
"Light travels faster than sound. This is why some people appear bright, before you can hear them speak..."

Was mir gerade noch so auffält. Du hast natür das denkbar schlechteste Texturformat. Ein riesen BMP was noch mit einer Palette arbeitet. OpenGL kommt nämlich nicht mit Palettenbildern klar. Du musst das Bild vorher in RGB (24Bit) umwandeln. Das geht mit einem TBitmap recht einfach nur würde dein ganzes Bild dann mal eben über 600 MB Speicher verbraten. Was auch nicht so praktisch ist.

Ich würde da evtl. sogar schon hergehen und deine Bilder bereits bei dir in kleinere Bilder zu zerhacken. Dabei musst du jetzt sehen ob du das lieber mit einem TBitmap machst oder auf Dateiebene. Dateiebene ist zwar komplexer aber dafür sind die Anforderungen an den Rechner nicht so hoch.

Wie auch immer du es machst du solltest dabei darauf achten, dass deine ausgangsbilder Bilder 8Bit bleiben. Dadurch sind sie kleiner. Als Dateinamen würde ich etwas nehmen woraus du auf den Quadranten schließen kannst. Wenn du diese Bilder dann an OpenGL übergeben willst kannst du sie dann mittels TBitmap laden und anschließend setze du das PixelFormat auf 24 Bit. Damit wandelst du sie in RGB Bilder um und kannst sie in OpenGL verwenden.

Alles andere haben meine Vorredner ja schon gesagt.

PS: Mit diese Aufteilung der Dateien könntest du das sogar übers Internet nutzen. Wobei ich dann eher noch sagen würde, dass du beim Internet nicht mit BMPs arbeiten solltest. Dafür wäre wohl PNG am besten geeignet. Also auch wegen der Beschaffenheit eines Stadtplans. Große einfarbige Flächen.

Danke danke danke ...

Leute ihr seit gut schnell. Und so Hilfsbereit..

Also ich fasse zusammen :

1. Werden ich mein Kartenmaterial (128 indizierte Farben 128(so bleibt das ganze klein ist doch anschaulich)), in 256x256 Kleine Teile teilen.

2. Werde ich Sie in die sichtbaren Flächen in meiner Szene in OpenGL laden .

3. Bei veränderungen wie z.B Zoom oder scroll sollte ich Fragmente nachladen oder eventuell ausladen.

Hört sich gut an in sofern das Laden un d entladen nicht laggt!

(ich habe das ganze in TImage schon mal gemacht wobei meine Fragmente größer waren..)

so vorerst mal mein COde in OpenGL:

Wie zeichne ich jetzt mehrere Texturen auf ein Quad ??

Oder muss ich etw mehrere Quads aufziehen ???

und alle einzeln Texturieren ??

Mehrere Texturen kannst du nur insofern auf ein Quadrat packen, dass diese dann übereinandergeblendet werden. Das nennt sich dann Multitexturing. Das ist aber für dich eigentlich nicht relevant. Du musst also für jedes Texturschnipsel ein Quadrat erzeugen.

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com

Was genau ist deine Frage? Irgendwie verstehe ich dich nicht so ganz.

Du musst natürlich irgendwo deine Texturen halten. Bzw auch vermerken welche Teile du bereits geladen hast und was noch geladen werden muss. Da du das Bild in Quadranten zerschneidest und auch eine nicht allzu große Größe hast könntest du ein 2 Dimensionales Array benutzen. In dem Array würde ich Records ablegen. In dem Record wäre ein Boolean (Loaded) und ein Cardinal (TextureID).

Je nachdem welchen Ausschnitt du anzeigst musst du dir ausrechnen welche Quadranten sichtbar sind und diese kannst du zeichnen. Wenn die Texturen nicht geladen sind solltest du sie Laden. Für den Anfang sollte das ausreichen. Wenn es nicht ausreicht solltest du eine besser Lademöglichkeit einbauen. Das wird dann aber Komplizierter. Also erst mal weg lassen.

Das Zeichnen stimmt eigentlich schon so wie es ist. Du Bindest eine Textur und Zeichnest dann ein Quad an die entsprechende Stelle. Vergiss aber nicht die Darstellung von 2D Texturen auch zu aktivieren. Das geht mit glEnable(GL_TEXTURE_2D). Damit hast du einen Quadranten gezeichnet. Das musst du dann noch für alle anderen sichtbaren Quadranten tun. Das Aktivieren der Texturen musst du aber nicht mehrfach tun da genügt es ein mal.

Die verwaltung von Texturen, und im speziellen dein Problem, sind ideal für die Verwendung eines Texturmanagers.

In welcher Sprache schreibst du dein Programm? Ich hab hier mal einen texturmanager für C++ gepostet. Der basierte aber auf SDL. Das ist aber kein Problem, weil nur das Prizip wichtig ist:

- Wenn du eine neue Textur brauchst, sagst du dem TexManager er solle die Textur bitte ab jetzt verwenden (TexManager.bind("Textur_Q11.jpg");).
- Der Texturmanager hat eine Liste mit Texturcontainern, welche die texturen darstellen, die momentan geladen (auf der GraKa liegen) sind.
- Jeder Container enthält den Namen der Textur ("Textur_Q11.jpg") und den OpenGL-Namen (Die ID mit der OpenGL die Texturen unterscheiden kann)
- Wenn der Manager in der Liste, die Textur nicht findet, lädt er sie von der Platte, und hängt einen entsprechenden Container in die Liste vorn an. Anschließend bindet er die textur
- Findet er die Textur in der Liste, sortiert er den Container vorn, ein und bindet die Textur.

Der Witz an dieser MEthode ist folgender: Du kannst die Menge der benutzen Texturen reglementieren. Du kannst z.B. sagen: "Behalte maximal 10 Texturen im speicher".
Wenn du eine neue Textur lädst, checkst du nur noch wie lang die momentane liste ist? Ist sie länger als der Grenzwert, löscht du die Textur am Ende. (Du musst sie natürlich ach mit glDeleteTexture(TexID) aus dem GraKa entfernen)

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Na ob das immer so gut ist wage ich mal zu bezweifeln. Es kann ja sein, dass er 11 Texturen braucht. Und dann wird immer eine weggeschmissen. Üblicherweise wird für so etwas eine Referenzzählung benutzt.

Im Englisch-Forum habe ich vor einer Weile zu einer zeitgesteuerten Taktik geraten. Das könnte für dich evtl auch interessant sein. Dort wurde gespeichert wann eine Textur das Letzte mal benutzt wurde und jede Sekunde wurde überprüft ob eine Textur mittlerweile schon abgelaufen (1 Minute nicht benutzt) ist. So kannst du dann durchaus auch mal kurz den Bereich verändern ohne dass die Textur gleich gelöscht wird.

Wobei du es aber auch so machen könntest, dass nur die Texturen geladen werden die direkt sichtbar sind und die Texturen erst dann freigebenen werden, wenn du weiter weg bist. Wobei das immer darauf ankommt was du vor hast. Das kann man ja noch mit beliebigen anderen Techniken kombinieren. Der Entwicklerischen Vielfalt sind dabei keine (oder kaum) Grenzen gesetzt.

Nun die Methode, die Anzahl festzulegen bedarf einer kleinen Statistischen auswertung. Ich hab bei meinem Spiel einfach mal bisl gespielt, und dann mal nachgeguckt, welche Texturen in der Liste waren, und wann ich die zuletzt gesehen habe. Das ergebnis war, dass ich von meinen glaub >30 Texturen immer nur einen Satz von 6-7 gebraucht habe. Mit dem Wissen, kann man dann sein Programm Feintunen. Wobei das in diesem Fall ja nicht so wichtig ist. Die Hauptsache ist, das die Anzahl erlaubter Texturen nicht zu groß für den GraKa-Speicher wird. Wenn der auslagern muss ist Feierabend mit Performance. Deshalb ist die Mengenbeschränkung hier wohl die sicherste Variante eine Auslagerung zu vermeiden.

_________________
Blog: kevin-fleischer.de und fbaingermany.com