Hi,

schau dir mal dashier an:
<a href='http://www.Koshigaya.de/DelphiGL/Lightmapping.exe' target='_blank'>http://www.Koshigaya.de/DelphiGL/Lightmapping.exe</a>

In der mitte sehen die Texturen ok aus, aber an den Polen der Sphere... ich weiß nich, irgendwas stimmt da net (und diese 4 Schwarzen stellen... *guckt verwirrt*)

Ne idee was das sein kann???

Au'revoir,
Aya~

PS: Mit der Maus kannst du die Kugel drehen.

Habs mir grad mal angesehen, und es sieht so aus als ob da was mit deiner Projektion der Dreicke auf die korrespondierenden Achsen nicht stimmt, und das Lightmapping deshalb an bestimmten Stellen schiefläuft.Schau dir das von mir ganz oben gepostete Dokument mal an, denn dort wird die Projektion zum Auffinden der korrekten Texturkoordinaten sehr ausführlich erklärt.

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

Zu der Geschwindigkeit:
Bei Unreal Tournament wird mit Hilfe eines Software Renderers vom Licht aus gesehen in 6 Richtungen gerendert und dadurch schnell geprüft, ob eine Lichtquelle sichtbar ist. Deshalb dauert es auch nicht solange wie in Quake3 ein Level neu zu berechnen. Ob das im neuen UT2003 auch noch so geschieht weiß ich nicht, aber man könnte auf aktueller HW so was ähnliches mit Hilfe der Occlussion Queries machen. Man erstellt für jeden Punkt eine Occlusion Query und rendert dann in alle sechs Richtungen von der Lichtquelle aus gesehen. Die Punkte auf der Lightmap werden dann ebenfalls als Punkte ohne DepthWrite gezeichnet. Wenn ein Punkt mindenstens einmal sichtbar war, dann gibt es eine Sichtlinie. Ich habe das noch nicht ausprobiert, aber das sollte auf allen Karten ab GF3 ziemlich schnell gehen. Da man dabei nur alles zeichnet und testet, was in Lichtentfernung liegt, muß man nicht allzuviele Occlusion Queries erstellen.
Die Queries haben zwar eine kleine Wartezeit wegen der asyncronen Berechnung auf der Grafikkarte, aber wenn man erst alle Punkte zeichnet und dann die Queries abfragt, dürfte das kein Problem sein.

Nachtrag:
Wenn man die Punkte, die man testen will, nicht als Punkte, sondern als Quads rendert, dann kann man ja auch sehen, wie viele Pixel davon sichtbar sind und entsprechend die Helligkeit für diesen Texel der Lightmap skalieren.

Unter <a href='http://www.flipcode.com/articles/article_lightmapping.shtml' target='_blank'>http://www.flipcode.com/articles/article_l...htmapping.shtml</a> gibt es ein neues Tutorial vom 21.07.03 zum Thema Lightmapping.

Hi,

also irgendwie will das nich so recht klappen bei mir...
<a href='http://www.Koshigaya.de/DelphiGL/Lightmapping.exe' target='_blank'>http://www.Koshigaya.de/DelphiGL/Lightmapping.exe</a>

Ich hab jetzt das PlanarMapping so gemacht:
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre><span class='reserved'>function</span> TLightMapSystem.PlanarMapping(VertexData: TVertexData): TTexCoordArray;
<span class='reserved'>var</span>
i: Integer;
XMax, XMin, YMax, YMin, ZMax, ZMin: Single;
XDiv, YDiv, ZDiv: Single;
D: <span class='reserved'>String</span>;
<span class='reserved'>begin</span>
SetLength(Result,Length(VertexData));
XMin:=VertexData[Low(VertexData)].X;
XMax:=VertexData[Low(VertexData)].X;
YMin:=VertexData[Low(VertexData)].Y;
YMax:=VertexData[Low(VertexData)].Y;
ZMin:=VertexData[Low(VertexData)].Z;
ZMax:=VertexData[Low(VertexData)].Z;
<span class='reserved'>for</span> i:=Low(VertexData)+<span class='integer'>1</span> <span class='reserved'>to</span> High(VertexData) <span class='reserved'>do</span> <span class='reserved'>begin</span>
<span class='reserved'>if</span> VertexData[i].X<XMin <span class='reserved'>then</span>
XMin:=VertexData[i].X;
<span class='reserved'>if</span> VertexData[i].X>XMax <span class='reserved'>then</span>
XMax:=VertexData[i].X;
<span class='reserved'>if</span> VertexData[i].Y<YMin <span class='reserved'>then</span>
YMin:=VertexData[i].Y;
<span class='reserved'>if</span> VertexData[i].Y>YMax <span class='reserved'>then</span>
YMax:=VertexData[i].Y;
<span class='reserved'>if</span> VertexData[i].Z<ZMin <span class='reserved'>then</span>
ZMin:=VertexData[i].Z;
<span class='reserved'>if</span> VertexData[i].Z>ZMax <span class='reserved'>then</span>
ZMax:=VertexData[i].Z;
<span class='reserved'>end</span>;
XDiv:=abs(XMax - XMin);
YDiv:=abs(YMin - YMax);
ZDiv:=abs(ZMin - ZMax);
D:=GetTriangleAlignement(VertexData);
<span class='reserved'>for</span> i:=Low(VertexData) <span class='reserved'>to</span> High(VertexData) <span class='reserved'>do</span> <span class='reserved'>begin</span>
<span class='reserved'>if</span> D='XY' <span class='reserved'>then</span> <span class='reserved'>begin</span>
Result[i].U:=abs(VertexData[i].X - XMin) / XDiv;
Result[i].V:=abs(VertexData[i].Y - YMin) / YDiv;
<span class='reserved'>end</span>;
<span class='reserved'>if</span> D='XZ' <span class='reserved'>then</span> <span class='reserved'>begin</span>
Result[i].U:=abs(VertexData[i].X - XMin) / XDiv;
Result[i].V:=abs(VertexData[i].Z - ZMin) / ZDiv;
<span class='reserved'>end</span>;
<span class='reserved'>if</span> D='YZ' <span class='reserved'>then</span> <span class='reserved'>begin</span>
Result[i].U:=abs(VertexData[i].Z - ZMin) / ZDiv;
Result[i].V:=abs(VertexData[i].Y - YMin) / YDiv;
<span class='reserved'>end</span>;
<span class='reserved'>end</span>;
<span class='reserved'>end</span>;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->

Ist doch eigentlich alles richtig so..??
Aber trotzdem stimmt bei den Texturen was nich... *seufzt*

Irgendne Idee woran das liegen kann?? (Vorallem, wo kommen die 4 Schwarzen flecke auf der Textur her?!)

Au'revoir,
Aya~

Wollt die neue Version grade ausprobieren, allerdings kommt beim Starten ein "Unbekannter Softwarefehler", und direkt danach eine EInOutError-Exception, bevor sich die Demo dann komplett verabschiedet.

Allerdings schätz ich mal, dass das planare Mapping evtl. Probleme mit bestimmten Winkeln hat und dadurch die Lumelpositionen (besonders an den Polen einer Sphere) falsch berechnet werden.
Hab mir für meinen Lightmapper nen ASE-Importer geschrieben und selbst mal zwei verschiedene Kugeltypen im 3D Studio gemacht, einmal ne Geosphere und einmal eine normale Sphere.Bei beiden gibts Probleme, was man auch dann sieht wenn man durch das planare Mapping die Texturkoordinaten selbst errechnen lässt.
Bin momentan auch auf der Suche nach einer Lösung für das Problem und werd dann bescheid sagen wenn ich was gefunden hab!

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

Ok
Ich werd aber auch mal schaun ob ich vieleicht was find' woran's liegt

Hab jetzt mal mit meinem ASE-Importer für den Lightmapper rumgespielt, und bin mir fast zu 100% sicher, dass das planare Mapping Probleme mit einer solch komplexen Form wie einer Kugel hat, denn andere (eckige) Objekte funzen einwandfrei, hab auch Testweise mal ne komplette Szene in 3D Studio MAX gebastelt und mit meinem Lightmapper einwandfrei beleuchtet und schattiert.
Evtl. wäre es deshalb eine Möglichkeit, die UV-Koordinaten im 3D-Modeller generieren zu lassen (geht ja in jedem 3D-Modeller über UVW-Map) und diese dann einfach für die Lightmaps als Berechnungsgrundlage holen.Rein theoretisch dürfte das dann funktionieren, ansonsten müsste man sich in mathematische Tiefen wühlen um die korrekten Lightmapkoordinaten für z.B. Kugeln zu berechnen.

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

mh... also du meinst den Lightmapper nich selber UV-Koordinaten errechnen lassen, sondern ihm feste vorschreiben???

Ich versuch's mal grad

Jepp, ganz genau das hab ich gemeint.Man lässt den 3D-Modeller die ganze Arbeit der Koordinatengeneration (in 3DStudio nennt sich das UVW-Map) machen, und nutzt diese dann, anstatt übers planare Mapping die Lightmapkoordinaten zu ermitteln.Denn dann hat man mit grosser Wahrscheinlichkeit korrekte Koordinaten, während planares Mapping je nach Polygonlage anscheinend fehlschlägt.

Berichte auf jeden Fall mal obs funzt, bin grad mit was anderem beschäftigt...

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

So, hab es jetzt mal versucht... sieht zwar schon anders aus, aber wirklich richtig immernochnet *g*

Aber... müßte dann nicht so rein theoretisch hier auch nen fehler drin sein?? ->
<!--pas--></span><table border='0' align='center' width='95%' cellpadding='3' cellspacing='1'><tr><td>Delphi-Source </td></tr><tr><td id='CODE'><!--pas1--><pre> <span class='reserved'>if</span> PolyPlane='XZ' <span class='reserved'>then</span> <span class='reserved'>begin</span>
y:=-(PolyNormal.x*uMin + PolyNormal.z*vMin + PlaneDistance) / PolyNormal.y;
UVVector:=Vertex(uMin, y, vMin);
y:=-(PolyNormal.x*uMax + PolyNormal.z*vMin + PlaneDistance) / PolyNormal.y;
Vect1:=Vertex(uMax, y, vMin);
y:=-(PolyNormal.x*uMin + PolyNormal.z*vMax + PlaneDistance) / PolyNormal.y;
Vect2:=Vertex(uMin, y, vMax);
<span class='reserved'>end</span>;
<span class='reserved'>if</span> PolyPlane='YZ' <span class='reserved'>then</span> <span class='reserved'>begin</span>
x:=-(PolyNormal.z*uMin + PolyNormal.y*vMin + PlaneDistance) / PolyNormal.x;
UVVector:=Vertex(x, vMin, uMin);
x:=-(PolyNormal.z*uMax + PolyNormal.y*vMin + PlaneDistance) / PolyNormal.x;
Vect1:=Vertex(x, vMin, uMax);
x:=-(PolyNormal.z*uMin + PolyNormal.y*vMax + PlaneDistance) / PolyNormal.x;
Vect2:=Vertex(x, vMax, uMin);
<span class='reserved'>end</span>;
<span class='reserved'>if</span> PolyPlane='XY' <span class='reserved'>then</span> <span class='reserved'>begin</span>
z:=-(PolyNormal.x*uMin + PolyNormal.y*vMin + PlaneDistance) / PolyNormal.z;
UVVector:=Vertex(uMin, vMin, z);
z:=-(PolyNormal.x*uMax + PolyNormal.y*vMin + PlaneDistance) / PolyNormal.z;
Vect1:=Vertex(uMax, vMin, z);
z:=-(PolyNormal.x*uMin + PolyNormal.y*vMax + PlaneDistance) / PolyNormal.z;
Vect2:=Vertex(uMin, vMax, z);
<span class='reserved'>end</span>;</pre><!--pas2--></td></tr></table><span class='postcolor'><!--pas3-->

Denn hier benutzen wir ja schonwieder PlanarMapping... oder seh ich das grad falsch??

Au'revoir,
Aya~

Das ist ja dass dumme an dieser Lightmappingmethode.Die basiert komplett auf planarem Mapping, weshalb es da schwierig werden dürfte.Evtl. könntest du aber trotzdem die UV-Koordinaten aus deinem 3D-Modeller übernehmen, dann trotzdem prüfen auf welcher Ebene das Dreieck liegt, und dann den von dir geposteten Teil mit den UV-Koordinaten des 3D-Modellers weiternutzen...ob das funzt ist allerdings fraglich.

Bin momentan selbst über ne Lösung am grübeln, aber da ich kein Mathegenie bin könnts noch etwas länger dauern bis ich mit ner Lösung rauskomme...

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

Für alle die unter dem gleichen Problem leiden : Ich hab zumindest die Ursache für das Fehlbeleuchten von "runden" Oberflächen wie Kugeln oder Zylindern gefunden.

Ich hab mir in meiner Matheunit ne Logdatei angelegt, in der die Normalvektoren der Flächen abgelegt werden, falls das planare Mapping deren Ausrichtung nicht ermitteln kann, und dabei ist genau das eingetreten womit ich gerechnet habe :
Das planare Mapping ermittelt die Achse auf der ein Polygon liegt ja anhand der größten Komponente seiner Flächennormalen.Nun gibt es aber dumemrweise (besonders leicht bei nem Zylinder nachzuvollziehen) aber Polygone, bei denen die Flächennormale zwei gleichgroße Komponenten hat (in meinem Zylinder ist das z.B. ein Dreieck mit der Flächennormalen x:50,4750022888184 y:0 z:50,4750022888184).Natürlich scheitert das planare Mapping hier, da es keine eindeutig größere Komponente finden kann.
Evtl. lässt sich das dadurch lösen, das wenn zwei Komponenten gleich sind, die dritte als größter Wert angenommen wird.Ich probiers mal aus, und werd dann ein Ergebnis posten.

Hoffe das hilfe allen die an dem Problem arbeiten ein wenig weiter, ansonsten ist mein Lightmapper nämlich schon einsatzbereit und lädt seine Szenen inzwischen in Dreiecksform direkt aus einer ASE-Datei.

Für alle Neugierigen gibts <a href='http://www.delphigl.de/lmapperag.jpg' target='_blank'>hier nen Screenshot</a>. (1280x960)

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

Sorry for this english answer, my german writing is not that good...

This is an interesting thread to folow.

I wonder on how i ad dynamic meshes to a ligtmapped world? Should i give that mesh a lightmap and recalculate that every move? Otherwise the dynamic mesh does not blend in with the surroundings. I dont want to know what happens to the framerate when many dynamic meshes appear in a world. Or is it not that bad on the framerate.

_________________
http://3das.noeska.com - create adventure games without programming

Isn't there any chance to combine Static and Dynamic lightmaps?
I thing i should work: you could create Static Lightmaps for every Object in your scene and then when rendering you only calculate the texture for the dynamic lights...
but than you have to search an method to combine the two lightmaps to one (or to add the dynamic infos to the static lightmap)... might be faster then calculating everyting new...

(i am sorry of my bad english... hobe the content is clear )

_________________
Es sind immer die guten,
welche zu früh von uns gehen müssen...
Meine bislang 13 Open Gl - Tuts findet ihr auf www.dcw-group.net
Neu! Ein großer Teil der Demos nach Kylix übersetzt!