Wireframe / Flächen Shader Berechnungs- Verständnisproblem

[supermuckl]

Hallo ;)
Ich experimentiere gerade an einer kleinen SOFTWARE 3D-Engine, womit ich bis jetzt einen Würfel in 3D auf die Mattscheibe via Strahlensatz Projezier. Das tut soweit auch. Die Linien hab ich bis jetzt einfach zwischen den 3D-2DProjezierten Punkten "gespannt".

Nun wollte ich als zweiten Schritt die Linien mit einer Lichtquelle (hab da an eine normale Lichtquelle gedacht, nicht an einen Spot) "anleuchten" damit ich dann die Wireframes als Farbverläufe zeichne, die nach der Beleuchtungsberechnung ihre Werte erhalten.

Das Problem ist jetzt, das ich nicht genau weis, wie ich die Lichtberechnung Mathematisch berechnen soll und was ich eigentlich haben will *g*

Gegeben sind folgende variablen:
-Punkte des Würfels im 3D-Raum
-Kameraposition (auch abstand Viewplane) -> wobei ja der Würfel gedreht wird, und nicht die Kamera
-Normalen der Würfelecken -> 3 Kanten per Vektoraddition negiert
-Dadurch auch die Normalen der Kanten selber -> also in welche Richtung die Kanten "schauen"
-Jede Kante hat auch ihre Start und Endpunkte im 3D-Raum

Was ich jetzt schon Tagelang am überlegen bin und mein Problem habe:

Wenn ich den Lichteinfallswinkel (oder halt Vektor) mit der "Würfelkante" Verrechnen würde und dann den Austrittswinkel überprüfen würde, ob der der "Augposition" also der Kamera mehr oder weniger entgegen kommen würde, hätte ich ja damit die REFLEKTION berechnet ?!

Was ich aber eigentlich haben will, ist die (ich sag mal matte Beleuchtung), die das Objekt direkt als Streulicht weitergibt. Also kein Glanz oder sonstiges, sondern einfach nur schön beleuchtete Würfelkanten, die mir somit Visuell den Eindruck vermitteln können, wo sich das Licht befindet
-> wird da dann auch der Abstand zwischen Lichtquelle und Würfelkante und von da wiederum zur Kamera interressant ?
-> oder nur der Einfalls bzw Ausfallswinkel + ein "Streuradius" womit ich aber dann wieder beim Spotlicht wäre oder ?!

Ihr merkt, ich hab da voll die Blocker drin ;)
Was ich allerdings ziemlich sicher weis, ist das ich die Kanten (also die Linien als Farbverlauf) im Prinzip so Berechnen kann, das ich für jede Linie den Start und Endpunkt eine Farbe berechne und nicht jedes Pixel der Linie jedesmal mit der Lichtberechnung verrechne ;)

Ich hab auch schon die OpenGL Tuts und Referenzen gewälzt und die Wiki beansprucht (alles eingesehen) und irgendwie bin ich immer am Detail hängen geblieben, bzw weis eigentlich nicht, was ich eigentlich für einen Shader brauche ;)

Aber noch eines vorweg: Ich WILL das Rad neu erfinden! ich Benutze keine Hardwarebeschleunigung und auch keine Engines. ALLES reinster DelphiCode

[dizzy]

Einfaches "Flat-Shading" geht via Skalarprodukt sehr einfach. Du musst dir nichtmal einen Winkel ausrechenen.

Körperfarbe = Flächenpunkt.Lichtposition * Lichtfarbe (*Lichtintensität)

Wobei:
Körperfarbe,
Lichtfarbe: Color
Flächenpunkt,
Lichtposition: Vektor
Lichtintensität: Float
. ist das Skalarprodukt
* einfach Multiplikation

Die o.g. Formel müsstest du für jeden Farbanteil separat durchführen, Lichtintensität ist optional (lässt sich ja auch, nur nicht so schön, über die Lichtfarbe regeln)).
Du musst zudem darauf achten die Farbanteile auf 255 zu Clippen, da sie ja durchaus größer werden können. Wenn du später auch zu dieser sog. "diffusen Beleuchtung" auch noch Glanzpunkte haben möchtest, dann informiere dich über "Phong-Shading" (ist sehr ähnlich im Grunde).

Gruss,
Fabian

\\Edit: Wenn du die Lichtabnahme bei wachsender Entfernung auch mit berücksichtigen willst, füge noch folgenden Faktor an obige Formel an: *(1 / ||Flächenpunkt-Lichtposition||²) Knallt natürlich wenn das Licht exakt auf einem Punkt liegt -> vorher abprüfen.
Aus der Physik bekannt als 1/r² :)

[supermuckl]

so ungefär stell ich mir das ganze auch vor.. aber ein echtes flat shading wäre das ja nicht, weil ich ja für eine linie 2 punkte habe, die ich einmal berechne und dann dazwischen alle werte als gradient darstelle

also wäre das dann phong ohne glanz und ambientes licht?

wenn ich dann die flächen per scanline rendering ausfüllen würde, müsste ich dann einfach nur die farbwerte der rand-linien (also die kanten des würfels) nehmen, und da dann gradienten "scannen" ?

noch zum verständniss, das ich die beleuchtungsmodelle jetzt richtig kapiert hab:
(mit unterstützung von wiki http://de.wikipedia.org/wiki/Beleuchtungsmodell )

beim flat shading wird nur der einfallswinkel gegen die flächen-normale via Skalarprodukt berechnet, und somit die helligkeit ermittelt. der austrittswinkel wird nicht gebraucht, da die fläche das licht streut ( diffuses licht )

beim phong shading wird das genauso gemacht, blos kommt noch das diffuse licht der umgebung dazu (einfach eine konstante helligkeit dazugerechnet) + den glanz, der durch einfallswinkel UND austrittswinkel berechnet wird, der dann in richtung kamera liegt, wenn der pixel am hellsten glänzen würde.

wäre das dann so richtig?

ich hoffe ich kann dann die flächen, wenn ich jetzt mal keinen glanz will, mit scanlinerendering und meinen "schattierten wireframes" die würfelei beleuchten ?

normal zu meinem pseudocode, wie ich jetzt den shader bauen WÜRDE:
-> NormalVektoren der Kanten berechnen
-> Start und Endpunkt Vektoren der Kanten zur Lichtquelle berechnen
-> Flatshading für diese Punkte berechnen
-> Gradient zwischen diesen Punkten als Linie Zeichnen
-> Scanline Rendering, wenn alle Linien um eine Fläche gerendert sind ausführen, um die Flächen zu füllen (mit Start und Endwerten von den Linien-Gradient Colorwerten)
-> fertig ;)

Ich kann auch mal das Projekt wie es jetzt aussieht, anfügen falls noch Fragen sind

[dizzy]

Zitat:

Zitat von supermuckl

so ungefär stell ich mir das ganze auch vor.. aber ein echtes flat shading wäre das ja nicht, weil ich ja für eine linie 2 punkte habe, die ich einmal berechne und dann dazwischen alle werte als gradient darstelle

Naja, Flat-Shading kann man hier auf zweierlei Weise interpretieren:
1) Rein diffuse Beleuchtung
2) Nur diffus und nur Vertex-basiert
Du hast 2) im Kopf ;)

Beides firmiert imho als "Flat-Shading". Als nächst höhere Form der Beleuchtung sieht man das sog. "Gourad-Shading" bei dem jeder Pixel separat beleuchtet wird, und zudem werden die Normalen an den Stellen so interpoliert dass der Eindruch einer "smoothen" Oberfläche entsteht.
Das Phong-Shading ist hiervon unabhängig eine Methode um Glanzpunkte (simulation einer direkt reflektierten Lichtquelle) zu erzeugen. Ich habe für meinen Raytracer 2 Varianten versucht. Zum einen die, die auch den reflektierten Vektor mit berücksichtigt, und zum anderen eine vereinfachte Form, welche ich am Ende beibehalten habe, da es sonst zu einer sehr unschönen Verschiebung des Glanzpunktes relativ zum hellsten Punkt der diffusen Beleuchtung kam. Diese Phong-Werte werden im Allgemeinen additiv zur diffusen Beleuchtung gepackt.

Zitat:

wenn ich dann die flächen per scanline rendering ausfüllen würde, müsste ich dann einfach nur die farbwerte der rand-linien (also die kanten des würfels) nehmen, und da dann gradienten "scannen" ?

Dann machst du es so wie alte Grafikkarten. Vertexbasiert. Hat allerdings einige unschöne Effekte - nämlich dass du dein Wireframe durch die Beleuchtungsmethode immer "durchscheinen" siehst, auch bei eigentlich ebenen Flächen. Ich würde es nicht via Gradientenbildung machen, sondern ganz einfach jeden Vektor der Oberfläche wirklich durch die Beleuchtung schicken. Dann können Highlights auch mitten auf einer Fläche entstehen, was vertexbasiert nicht geht.

Zitat:

beim flat shading wird nur der einfallswinkel gegen die flächen-normale via Skalarprodukt berechnet, und somit die helligkeit ermittelt. der austrittswinkel wird nicht gebraucht, da die fläche das licht streut ( diffuses licht )

Japp. Noch dazu findet keine Normaleninterpolation statt.

Zitat:

beim phong shading wird das genauso gemacht, blos kommt noch das diffuse licht der umgebung dazu (einfach eine konstante helligkeit dazugerechnet) + den glanz, der durch einfallswinkel UND austrittswinkel berechnet wird, der dann in richtung kamera liegt, wenn der pixel am hellsten glänzen würde.

Das ambiente Licht ist keine Eigenschaft von Phong. Das kannst du einfach dazu nehmen oder weglassen, ganz egal was für Beleuchtungsmodelle du noch nutzt. Und wie gesagt: Ich habe das mit dem Austrittswinkel sein gelassen. Es sieht in meiner einfacheren Fassung gut und recht richtig aus, wogegen die andere Variante z.T. nicht mehr ganz überzeugte. (Was aber durchaus auch an u.U. nicht ganz richtiger Implementierung gelegen haben konnte - das weiss ich nicht ;))

Zitat:

ich hoffe ich kann dann die flächen, wenn ich jetzt mal keinen glanz will, mit scanlinerendering und meinen "schattierten wireframes" die würfelei beleuchten ?

Würde ich wie gesagt nicht machen. Aber halt! Was hast du eigentlich vor? Willst du realtime 3D mit zig FPS? Dann wäre mein Vorschlag jeden Punkt separat zu beleuchten u.U. nicht so schnell. Die Gradientenbildung ist nun aber auch nicht ganz ohne. Somit müsste man mal testen was schneller ist, bzw. was man der guten Beleuchtung an Speed opfert. Besser aussehen tut es NICHT mit Gradienten ;).

Zitat:

normal zu meinem pseudocode, wie ich jetzt den shader bauen WÜRDE:
-> NormalVektoren der Kanten berechnen
-> Start und Endpunkt Vektoren der Kanten zur Lichtquelle berechnen
-> Flatshading für diese Punkte berechnen
-> Gradient zwischen diesen Punkten als Linie Zeichnen
-> Scanline Rendering, wenn alle Linien um eine Fläche gerendert sind ausführen, um die Flächen zu füllen (mit Start und Endwerten von den Linien-Gradient Colorwerten)
-> fertig ;)

An sich kann man's so machen joa =)

Zitat:

Ich kann auch mal das Projekt wie es jetzt aussieht, anfügen falls noch Fragen sind

Auch ohne Fragen hätte ich Interesse dran ;).

[Speedmaster]

Zitat:

Zitat von dizzy

Zitat:

Ich kann auch mal das Projekt wie es jetzt aussieht, anfügen falls noch Fragen sind

Auch ohne Fragen hätte ich Interesse dran ;).

Dito, würde mich auch mal Interessieren, auch wenn es nur ein Softwarerenderer ist!

[supermuckl]

also es soll eine echtzeit 3d engine werden, die nicht unbedingt die supertollen realistischen beleuchtungseffekte können soll ( also farbige objekte werfen licht auf andere objekte und solche krassen sachen )
es soll eine engine werden, die dem USI 3/4 gleicht
das game ansich hab ich schon auf meine art komplett neu gecoded (60% fertig)
und jetzt wollte ich schauen ob ich das nicht gleich in 3D umsetzen kann und bin somit direkt in die 3D welt eingestiegen und bin jetzt ganz hin und weg sowas auch zu coden ;)

ich bin net grad begabt in mathe usw.. aber bis jetzt hab ich mir die vektorrechnungen und winkelberechnungen usw alle selber eingegoogled ;)

mir fehlen halt noch paar anhaltspunkte, die mich aus den wilden formelsammlungen retten, von denen ich teilweise 0 Peilung hab ;)

Die engine ist also ein neues Projekt, das ich dann später als klasse in mein vorhandenes 2D game integrieren würde.

Dabei will ich auf kompletter Hardwarebeschleunigung verzichten, da ich selber wissen will, ob ich sowas schaffe ;)

deshalb sind codefetzen nicht das was ich gerne haben würde ;) -> wills ja selber machen.

was mich jetzt halt noch kitzelt, ist die tatsache, das das vektor-scanline shading wohl fast genauso schnell sein würde wie das shading eines jeden pixels ?!
rein code technisch seh ichs auchnoch leichter an :)
dann kann ich das scanline rendering einfacher auf vielecke usw übertragen und muss da nicht jedesmal ne neue klasse schreiben

ich werde eventuell rein für die 2D darstellung DirectX Directdraw verwenden, damit das schneller geht ;) aber das sind ja dann 4 zeilen mehr code mit DelphiX für den flipcode

ich hab mal das mini projekt angehängt wie es gerade aussieht. eine ecke hängt halt runter weil ich als test mal den punkt versetzt hab und sie ist per gradient gezeichnet

der kleine stummel der da aus dem würfel noch raushängt, ist die überprüfung ob die Normale der "ecke" so im 3D passt wie ich mir das vorgestellt hatte ;)

was jetzt noch (warscheinlich kommen später noch paar kleinigkeiten an fragen) wissen würde :)
ist, wie ich die kanten einer zusammenhängenden fläche ( z.b. Kugel aus Dreieckigen flächen) "smooth" darstelle ?
da muss ich ja dann alle übergänge von einer fläche zur anderen irgendwie interpolieren.. aber was genau interpoliere ich da? und wie mach ich das am geschicktesten :) ganz abgesehen davon, das ich nich viel übers interpolieren im mathematischen sinne weis.
ich würde da jetzt die vektoren entlang der kanten irgendwie mitteln und dann je nach entfernung von der kante weg, immer weniger mitteln ?!
oder ich nehm mir die "gaussche verteilungskurve?" ka ;)

lange rede wenig sinn ;)
nub am 3D werkeln :P

[Speedmaster]

Obwohl ich mir den Quelltext nicht ganz angesehen habe gebe ich dir ein paar Tipps mit auf den Weg, der dich vermutlich dazu veranlassen kann es neu zu Programmieren. Alle Tipps sind natürlich Teil meiner Erfahrung mit Grafikapis!

• Erstelle eine Matrix, d.h. eine Form eines Leeren Universums
• In diese Matrix schreibst du alle deine Objekte rein( Ums dynamisch zu machen: ein Vertexarray )
• TRENNE die gesammte Engine von der Form!
• Jetzt fängst du an alles nacheinander aufzubauen: Line, Polygon, Quad,...
• Um es sehr gut und übersichtlich zu machen, übergibst du sämtliche Lines, Polygonen & Co als Objekt o. Record
• Gibt noch viel mehr, aber bin jetzt zu müde..

[supermuckl]

Zitat:

Erstelle eine Matrix, d.h. eine Form eines Leeren Universums

das mit der matrix hab ich noch net so verstanden. ich weis von openGL aus, das dort alles 0 und maximum 1 ist
aber wie ich das dann nacher wieder alles berechnen kann.. da hakts bei mir

Zitat:

In diese Matrix schreibst du alle deine Objekte rein( Ums dynamisch zu machen: ein Vertexarray )

logisch.

Zitat:

TRENNE die gesammte Engine von der Form!

ich weis! das ist nubkram, den ich zum testen halt so gelassen hab.. das soll ja keine fertige engine darstellen

Zitat:

Jetzt fängst du an alles nacheinander aufzubauen: Line, Polygon, Quad,...

so wollt ichs machen :)

Zitat:

Um es sehr gut und übersichtlich zu machen, übergibst du sämtliche Lines, Polygonen & Co als Objekt o. Record

das hab ich auch vor.. also die objekte der funktion übergeben und nicht die funktion in die klasse des objekts hängen ;)

Zitat:

Gibt noch viel mehr, aber bin jetzt zu müde..

bin ich auch ;)
hast du eventuell irgendwelche links usw die du mir direkt nennen kannst, die ich unbedingt sehen muss ? ;)
ich hab da auch schon so einige gamedevsites usw gefunden aber so eine allumfassende irgendwie noch net..

achja.. ich will auch nichts überstürzen. das soll keine modulare super dynamische professionelle alleskönner engine werden ;) sondern nur aufs nötigste beschränkt ;)
ich weis ja noch nicht ob das überhaupt was wird mit only software rendering