Hallo,

ich verwende Multitexturing um sechs verschiedene Texturen zu überlagern. Bei Grafikchips von ATI und Intel funktioniert das auch tadellos, aber nvidia bietet dafür anscheinend nur vier texture units an, womit die letzten beiden Texturen nicht dargestellt werden. Ich vermute man kann das mit Shaderprogrammierung umgehen, aber damit kenne ich mich noch nicht so aus. Gibt es dafür ein einfacheres Workaround?

Marcel

_________________
Just do it!

Nein, das ist bei NVidia schon lange so. Die komplette Zahl der Textureinheiten kann man dort nur im Shader nutzen, in der festen Funktionspipeline gibt es keine Möglichkeit mehr als 4 zu nutzen, und mehrere Durchgänge sind auch keine Lösung. Um einen Shader wirst du also nicht herumkommen.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Korrekt, auch bei meiner Geforce 9800 GT ist der Wert von GL_MAX_TEXTURE_UNITS_ARB = 4. Dagegen ist bei mir der Wert von GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 32. In Vertex- und Fragmentshader zusammengenommen kann ich also bis zu 32 verschiedene Texturen nutzen.


Ich würde das benutzen eines Shaders jetzt als einfachen Workaround bezeichnen. Allerdings sehe ich ein das jemand der noch nie mit Shader gearbeitet hat dies anders sehen könnte.

In jedem Fall fällt mir keine andere Möglichkeit ein in einem Pass mehr Texturen zu benutzen. Ein aufteilen in mehrere Passes wäre natürlich möglich. Wenn ich mehr darüber weiß was du genau machen willst kann ich dir vielleicht einen anderen Weg nennen.

_________________
Yeah!

Danke erstmal!

Was ich vorhabe: Ich habe eine Basistextur und darüber blende ich die anderen Texturen (Falschfarbentexturen, oder Texturen in denen nur Teilbereiche eingefärbt sind). Der Anwender kann mittels Schieberegler die Alphawerte der oberen Texturen verändern und so sein Bild komponieren. Dabei soll einfach möglichst viel Information grafisch einfach zugänglich gemacht werden.

Ich denke mal das ich mich mittelfristig wohl mal mit Shadern auseinander setzen werde. Schließlich lassen sich damit ja auch eine ganze Menge anderer Effekte erzielen.

_________________
Just do it!

Okay, das ist mit einem Shader wahrscheinlich einfacher zu realisieren als mit der festen Pipeline

_________________
Yeah!

Du könntest das auch manuell mit Blending machen.
Da ich davon ausgehe, dass die Fläche zum Nutzer hin ausgerichtet ist, kannst du das im Orthomodus machen. Dort ist es dann auch kein Problem 6 Quads Deckungsgleich zu platzieren.

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

Ja, das im Orthomodus wäre möglich, hab ich auch schon mal drüber nachgedacht. Allerdings wird das ganze auch noch um eine Kugel in der perspektivischen Ansicht gewickelt, und da sieht das schon wieder anders aus. Ich denke Anwender mit nvidia karten werden erst mal mit 4 Texturen vorlieb nehmen müssen, bis ich das ganze mit nem Shader umgesetzt habe.

Vielen Dank jedenfalls, werde in Zukunft sicher noch mal ein paar Fragen zu Shadern hier posten

Marcel

_________________
Just do it!

Stimmt. Wenn du ne Kugel haben wölltest, müsstest du dann 2 Passes rendern, bzw. du must die erzeugte "Textur" aus dem Orthomodus-Buffer in eine Textur kopieren und die verwenden.

Je nachdem wie du renderst geht das vermutlich sogar in einem Pass.

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

@Flash: Ich weiß nicht was du da genau vorschlägst, aber in irgendwelchen Buffern rum kopieren nur um die Geometrie nicht nochmal zu rendern ist eine aufwendige Lösung. Mit einem Shader löst sich das Problem in wenigen Zeilen in Luft auf!

_________________
Yeah!

Das erstellen der nötigen Shaderobjekte sollte ja kein Problem sein und den Shader selbst können wir dir hier auch zusammenschustern.
Musst nur mal posten, was dein Multitexturing da kombiniert.

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Wenn ich richtig verstanden habe, was gemacht werden soll, dann gibt es einen Bereich der Ausgabe, wo die Texturen zusammengeblendet werden. Das kann man mit einer Orthogonalprojektion und Blending machen.

Dann gibt es noch einen bereich, wo die erstellte Textur auf ein Objekt gebunden werden soll. Dazu kopiert man im selben Pass den Inhalt des Framebuffers an der Stelle wo die Textur zusammengemischt wurde zurück in einen Texturbuffer und bindet das dann als Textur.

Ich hab selbst sowas noch nicht gemacht, aber so müsste das doch gehn. Oder nicht?

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

Gehen würde das, aber es wäre viel komplexer und weitaus weniger performant als es in einem Shader zu tun. Blending im Shader zu implementieren ist selbst für Einsteiger eine Sache von wenigen Minuten. Bei deiner Lösung müsste man sich erstmal mit RTT beschäftigen (PixelBuffer oder FBO) und dann auch noch mehrere Passes machen.

Methode mit Shader : Ein Pass mit einer Berechnung und 6 Texturefetches
Deine Methode : Zwei Passes mit Blending (kostet Füllrate und Geometriedurchsatz), in eine Textur rendern (dauert, kostet auch Füllrate)

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Das Shader performanter sind habe ich nicht angezweifelt.
Auf meiner Hardware wären sie keine Lösung.

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

Mein Vorhaben:

Eine Kugel mit Planetentextur, darüber sind transparent verschiedene andere Texturen gelegt, z.B. Temperaturverteilung und Sonnenlichteinstrahlung als Falschfarbenmodell. Weiterhin könnten beispielsweise Erdbeobachtungssatelliten den Planeten/Kugel umkreisen und das Sichtfeld deren Kameras soll ebenfalls in Texturen gemappt werden. Alle Texturen, bis auf die grundlegende Planetentextur, können mit beliebiger Transparenz übereinander gelegt werden. Zusätzlich werden die Texturen ähnlich kombinierbar und unabhängig von der Kugeldarstellung in 2D als Plattkarte gerendert. Bis hierhin bin ich ohne Shader ausgekommen, die Performance war ausreichend.

Die zusätzlichen Texturen werden von der CPU berechnet, im Hauptspeicher erzeugt und anschließend an die Grafikkarte übergeben. Möglicherweise wäre selbst das schon eine Anwendung für einen Pixelshader.


Vielleicht an dieser Stelle noch eine andere Frage, die mich darin bestärken könnte, mich schneller mit Shadern zu befassen (ich kanns auch noch mal in einem neuen Thread posten, aber hier hab ich die Anwendung eh grad erklärt ):
Die Kameras haben ein bestimmtes Sichtfeld, z.B. Kegel- oder Pyramidenförmig und blicken mit ihrer optischen Achse nicht zwangsläufig zum Planetenmittelpunkt, sondern evtl. auch um einen Winkel versetzt gegen den Horizont. Diese Geometrie schneidet die Planetenoberfläche und die Schnittkanten bilden das von der Kamera abgedeckte Feld. Diese projizierte Fläche ist irgend ein verzerrtes sphärisches Viereck oder eine verzerrte Elipse. Bis jetzt berücksichtige ich dafür nur die Breite der Bodenspur und zeichne diese immer ein Stück weiter.
Ließe sich mit Hilfe von Shadern diese projizierte Fläche leichter, schneller oder eleganter berechnen? Mir würde jetzt nur einfallen, dass man für jedes Pixel der Textur einen Vektor zur Kamera bildet und prüft, ob dieser sich in deren Viewing Volume befindet. Wenn ja wird das Pixel eingefärbt. Das ist allerdings sehr rechenlastig (vor allem für die CPU).

p.s.

_________________
Just do it!

Warum genau musst du den Geometrieausschnitt kennen der innerhalb des Viewing-Frustum liegt? Pixel außerhalb des Viewing-Frustum werden von der Grafikkarte sowieso nicht gerendert. Die Geometrie wird im "Clipping"-Schritt vorher passend zurecht geschnitten. Das macht aber auch die feste Funktionspipeline so.

_________________
Yeah!