Hallooo!

Irgendwie will das Färben nach z-Werten (Höhe von Landschaften) nicht funktionieren . Ich habe vor je nach z-Wert anderen Farben zu vergeben, sodass ein schöner Farbverauf z.B. von Rot nach Hellrot nach Blau nach Hellblau etc. entsteht. Da dachte ich mir ein VBO mit der entprechenden Farbe je Vertex zu versehen und es dann einfach weitergeben an den Vertexshader. Der sollte dann ja gewöhnlich schön zwischen den Farbeninterpolieren, sodass ein Verlauf ensteht.
Was ich bekomme ist aber ein buntes Objekt, bei dem fast jedes Dreieck anders gefärbt ist.

Ist mein Ansatz denn falsch? Außerdem gibt es bestimmt eine elegantere Lösung..?


//wieder mal mit webgl/opengl es 2.0 obwohl das hier wohl nicht so erheblich ist.

Öhm. Ich bin leider gerade nicht zu Haus, komme also nicht an meine Kristallkugel, nein, ehrlich, Etwas mehr Hintergrundinfo oder Sourcecode wäre ne gute Idee. So ist es buntes Bilderraten. Ich mein, ich kann mir unter dem, was du beschrieben hast, nichtmal wirklich was vorstellen.

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Ich denke mal er meint das so ungefähr wie im Tutorial: ganz unten Blau für Wasser, dann irgendwann Grün für Wiese, Braun für Berge und Weiß für Schnee.

_________________
Bringe einen Menschen zum grübeln, dann kannst du heimlich seinen Reis essen.
(Koreanisches Sprichwort)

Da du in WebGL sowieso auf Shader angewiesen bist schlage ich folgendes vor:

• Deine Vertices bekommen nur eine Position (und falls benötigt Normale/Texcoords, jedenfalls keine Farbe)
• Der Vertexshader gibt die z-Koordinate (Höhe) der Position in Weltkoordinaten an den Fragmentshader weiter. Dazu braucht der Vertexshader zusätzlich zur ModelViewProjection-Matrix auch die Model-Matrix alleine (sofern diese nicht sowieso eine Einheitsmatrix ist)
• Der Fragmentshader bekommt eine eindimensionale Textur mit dem gewünschten Farbverlauf. Die vom Vertexshader erhaltene z-Koordinate mappt er in 1D-Texturkoordinaten (0...1) und fragt dann die Textur nach der Farbe.

ABER: Ich möchte noch mal darauf hinweisen das ich solche Terrains extrem hässlich finde. Beziehe doch lieber zusätzlich die Steigung des Terrains (dot-Produkt zwischen Normale und (0,0,1)) in deine Berechnungen mit ein. An steilen Stellen nimmst du Fels, flache Stelle bekommen abhängig von der Höhe Gras oder Schnee. Außerdem sind natürlich auch Texturen viel schöner als einfache Farben. Hier haben wir z.B. an steilen Stellen eine Felstextur und an flachen Stellen Sand:
(klicken zum vergrößern)

Anstatt die Berechnungen im Shader auszuführen könntest du auch eine Alphamap benutzen die die entsprechenden Blending-Werte für die Texturen liefert. Diesen Shader könntest du ggf. interessant finden: shader_Terrain_GPU4 und diesen Thread.

_________________
Yeah!

Wozu denn? Soll sich die Farbe beim Rotieren ändern?

Wenn das Terrain außerhalb der Z-Achse rotiert wird schon, würde ich sagen. Aber du hast Recht, üblicherweise hat man da bei einem Terrain höchstens eine Translation auf der X- oder Y-Achse. Indem Fall kann man sich die Model-Matrix sparen.

_________________
Yeah!

Ich will so etwas wie eine ganz einfache Höhenkarte erstellen:

(Q: http://www.zipfelmaus.com/blog/3d-scann ... map-to-3d/)

Noch ein Beispiel:

(Q: http://users.ece.gatech.edu/~msalman/ )
Meine Objekte sind von der Form her so wie das bunte Modell im 2.Beispiel. Nur dass meine Objekte noch nicht so gefärbt sind, aber so gefärbt werden sollen.


Muss das denn mit einer Textur sein? Ich frage die Vertexdaten von einer externen Datenbank ab, d.h. ich kann verschiedenste Modelle bekommen, von denen oder zu denen ich kein Texturimage habe. Ich dachte, dass ich jedem Vertex je z-Wert(Objektkoordinaten)eine Farbe geben kann und schon geschieht die Färbung mit den Verläufen...


Was ist eine Modelmatrix, wenn es nicht die ModelView oder Projektionsmatrix ist?

Naja....öhm...nein, aber es ist das einfachste Es ging um eine 1D-Textur mit Farbverlauf. Also z.B. 1 Pixel hoch und 256 Pixel breit. Irgendwie musst du halt festlegen wo du welche Farbe haben willst. Vom Prinzip genau der Farbbalken in deinem ersten Bild.

Letztlich brauchst du nur irgendwie ein Array mit den Farbwerten für jede Höhe. Du kannst auch einfach ein Array im Shader als Konstante (oder Uniform) definieren und dann selbst das interpolieren übernehmen. Bei einer Textur geht das halt automatisch.


Ah, es geht also nicht um ein schönes Terrain/Landschaft sondern um die Visualisierung von irgendwelchen Daten. Dann machen auch die Farben nach Höhenwerten auch Sinn


Die ModelView-Matrix ist die Multiplikation von Model- und View-Matrix. Dabei ist die View-Matrix die Kamera-Transformation, z.B. mit gluLookAt erzeugt. Die Model-Matrix (auch World-Matrix) ist entsprechend die ModelView-Matrix ohne Kamera-Transformation und transformiert daher die Objekt in das Welt-Koordinatensystem. OpenGL fasst beide Matrizen zusammen, es gibt nur eine Trennung zwischen ModelView und Projection. In WebGL musst du sowieso alles selbst machen, daher kommt man leicht an die Model-Matrix.

_________________
Yeah!

Gut, dann mache ich mich mal auf die Suche nach Textur-Tutorials.


Was hat es dann mit dem Interpolieren im Vertexshaders auf sich? Wenn ich dort Farben reinstecke, erstellt er mir doch automatisch einen Verlauf oder nicht?

Ja genau, es geht um ganz einfache Visualisierung von Daten.

Natürlich. Alles was der Vertexshader produziert wird interpoliert, da ein Dreieck ja bekanntlich aus drei Vertices besteht und nicht nur einem. Der Fragmentshader erhält also interpolierte Werte. In diesem Fall lassen wir die als Varying übergebene z-Koordinate interpolieren und ermitteln die eigentliche Farbe erst im Fragmentshader. Warum zeige ich mal an einem kleinen Beispiel:

Wir haben drei Farben:
Höhe 0 -> Farbe RGB(0,0,0)
Höhe 1 -> Farbe RGB(255,0,0)
Höhe 2 -> Farbe RGB(255,255,255)
Und zwei Höhenwerte zwischen denen wir interpolieren: 0 und 2

Wird bei diesem Setting die Farbe durch den Vertexshader interpoliert gibt es nur Graustufen, obwohl die Mitte eigentlich rot sein sollte. Darum war mein Vorschlag die Höhe zu interpolieren (da kann nix schief gehen) und die Farbe erst im Fragmentshader zu ermitteln. Dort würde man das rot dann sehen sofern genug Pixel dazwischen sind.


Ich weiß nicht ob es hilft, aber im WebGL-Tutorial hier im Wiki wird auch kurz auf Texturen eingegangen:
http://wiki.delphigl.com/index.php/Tuto ... L#Texturen
Allerdings ist das Tutorial ggf. veraltet weil ich die API geändert hat. Hier gibt es auch noch ein anderes ausführlicheres Tutorial:
http://learningwebgl.com/blog/?p=507

_________________
Yeah!

Ich wollte schon gerne wissen, warum die Szene keinen schönen Farbverlauf hat, sondern ein Mosaikartiges Gebilde bekomme, wenn ich einzelne Vertices je nach Höhe mit einer Farbe verpasse:


In diesem Beispiel gehen die Höhenwerte von 100 bis -5000.
Das Ergebnis ist dieses Durcheinander:


Eigentlich müsste es doch so funktionieren, also mit einem eigenen Farb-Array?

Wenn ich nur zwei Farben einsetze sieht es etwas besser aus, obwohl ich Zweifel habe, dass tatsächlich richtig gefärbt wurde:

Ich brauche aber weit mehr als nur 2Farben..

Dann habe ich noch vesucht, es mal mit nur zwei Farben im Shader zu probieren, ebenfalls erfolglos:





Ihr könnt mir bestimmt sagen, worin meine dummen Fehler liegen?

----

Ich habe es noch nicht mit der TExtur versucht, habe aber die Befürchtung zu ähnlichen Ergebnissen zu kommen.
In den Tutorials muss zu jeder Vertexposition auch die entsprechende Texturkoordinate ermittelt werden. Muss ich das auch für meinen Farbbalken (das Image mit 1x256px Größe) tun, d.h. für jedes Objekt individuell tun ? Wie sonst soll der Fragmentshader wissen, welchen Farbwert oder welche Position der Textur er für die jeweilige Höhe verwenden muss?

Hat Coolcat zwar schon gesagt, aber, da kriegst du eine lineare Interpolation zwischen den Farban auf deinen Vertices, und nicht die Farben, die eigentlich noch dazwischen liegen müssten.

Nich zufällig im Vertexshader? Sieht nämlich sehr danach aus. Die Farbe muss im Pixelshader bestimmt werden, egal, ob das jetzt aus einer Textur gelesen wird oder nicht. Die Höhe übergibst du idealerweise als varying vom Vertexshader in den Pixelshader

Vertexshader:
Pixelshader: Ist nur ein Beispiel. Kann man sicher noch vieles anders machen, besonders kann die Funktion, die die Farbe bestimmt, anders aussehen.

Ich glaube nicht, dass diese Befürchtungen begründet sind. In der Textur hast du schließlich den Farbverlauf drinnen, und ausgelesen wird sie für jeden Pixel und nicht für jeden Vertex. Die Texturkoordinaten sind dann nur abhängig von der Höhe, also können die ohne weiters im Vertexshader festgelegt werden. Weiß jetzt nicht, ob das ein vec3 ist, aber ich nehms mal an. Und SomeFactor sollte halt sinnvol gewählt werden

mfg

sharkman

ps: hoffe, das war einigermaßen verständlich.

Ah, stimmt, alles klar!


Ist das nicht egal, ob ich die Farben im Vertex oder im Pixelshader bestimme?
Ich habe das jetzt mal so gemacht wie du meintest und die Farbe erst im Pixelshader berchnen lassen. Es ist kein Unterschied zu vorher zu erkennen.Gleiches Ergebnis wie vorher.


Ja, dass es nicht funktioniert, liegt tatsächlich an der Funktion, nicht am Pixelshader..
Naja das mit der Shader-Farbberechnung war eh nicht so wichtig, wollte nur rumspielen.



Joa doch, nur das letzte mit der Textur habe ich wieder nicht verstanden.
[/quote]

Ich habe immer noch keine Ahnung, wie der Fragmentshader, der ja die z-Werte vom Vertexshader bekommt auf die Textur zugreift bzw. wie er jedem z-Wert den entsprechenden Farbwert aus der TExtur zuweist
Bei der üblichen TExturierung geht man ja so vor, dass für jedes Vertex eine x,y Koordinaten zuweist (VBO).

Texturzugriffe gehen im Pixelshader etwa so:

Texture0 ist die TMU, auf die die Textur gebunden wurde, also irgendwas von 0 bis 15 normalerweise. Hab das aber noch nie benutzt, könnte also auch so falsch sein, wie der code in meinem letzten Beitrag.
bzw Wenn du das über die z koordinate (Höhe) machst, siehts etwa so aus:

ggf muss es auch vec2(0.0, altitude) heißen, bzw es kann auch sein, dass auch (oder nur?) ein dir die richtigen Werte zurückgibt.
Kommt wahrscheinlich darauf an, ob dus als 2d Textur oder als 1d Textur erzeugt hast.

Grundsätzlich kannst du aber auch auf shader verzichten, und dann ganz normal die uv koordinaten (*) in dein VBO schreiben, und die halt abhängig von der Höhe machen. (hoffe, das stimmt)
(*): Wenns ne 2d Textur ist zumindest. Bei ner 1d Textur kanns sein, dass da nur ne u koordinate hingehört.

Anscheinend noch nicht alles klar Wenn du die Farban im Vertexshader bestimmst, wird zwischen den Vertices linear interpoliert. Dadurch werden Farben, die dazwischen liegen sollten, nicht beachtet.

Wenn du die n-te TMU nutzen willst muss das ca. so aussehen:

_________________
Yeah!