DGL • Thema anzeigen - Radiosity Lighting

Radiosity Lighting

Moderator: DGL-Team

Seite 1 von 2

[ 20 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Finalspace

Betreff des Beitrags:

Verfasst: Di Apr 29, 2003 21:19

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Tach,

ich habe mir mal die Tutorials (Trocken wie sau), von Flipcode, Delphi3d.net und anderen seiten angeschaut und ich peil nix... in google hab ich auch schon gesucht... nix gescheites gefunden. Nen richtigen source in c++ oder delphi hab ich nirgends gefunden.

Wenn jemand damit erfahrung hat, wäre ich dankbar für Ratschläge...

Muss ich wirklich nen Triangle Patchen also in mehrere Triangles aufteilen ??
Wie bekomm ich den Vector raus der zwischen dem Licht und dem Triangle sein muss... ?
Eigentlich muss ich mal alles fragen... ich peil nix... nieda...

matane,
Final

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Fr Mai 02, 2003 08:55

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Das zu erklären ist ehrlich gesagt recht komplex, und wenn du schon bei den Flipcode-Artikeln Probleme hast, dann wirds vielleicht etwas problematisch.Ich hab den Lightmapper für ZornGL mit Hilfe des folgenden Dokumentes aufgebaut : <a href='http://users.pandora.be/BluePrint/thesis/Website/files/THESIS_English.pdf' target='_blank'>http://users.pandora.be/BluePrint/thesis/W...SIS_English.pdf</a>

Dort ist die Berechnung der Lumel und des Winkels den du suchst so gut wie nur möglich erklärt, und wenn mans erstmal gerafft hat, wird einem schnell klar das die Sache doch eigentlich recht einfach ist.

Denn den schwersten Teil der Arbeit hast du ja bereits in deiner Engine integriert : Das Herausfinden und Projezieren auf die Ebene auf der das Dreieck liegt, das du auch zum automatischen Generieren der Texturkoordinaten nutzt.Mit dieser Methode kannst du dann die Maße der Lightmap berechnen (sprich das Rechteck, dass das Dreieck umschliesst), und wenn du die Maße des Rechteckes hast, kannst du ganz einfach anhand der Größe deiner Lightmaptextur (größer 64x64 lohnt sich übrigens nicht, eher im Gegenteil) die Position der einzelnen Lumel auf der vorher festgestellten Ebene herausfinden.
Im Dokument findest du dann auch die Formel, mit der du die Helligkeit eines bestimmten Lumels berechnest, die ohne Patches auskommt und ein simpleres Beleuchtungsmodell zugrunde legt.Dieses reicht allerdings für den Anfang, und erleichtert die Berechnung der Lightmap stark.

Obiger Paragraph ist in dem von mir verklinktem Dokument noch ne Nummer ausführlicher beschrieben, und sollte eigentlich keine Probleme machen.

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

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Fr Mai 02, 2003 12:19

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Für alle die interessiert, wie die Beleuchtungsgleichung aus dem von mir erwähnten Dokument aussieht, hab ich unter folgendem Link ein Demo meines Lightmapgenerators hochgeladen : <a href='http://www.delphigl.de/files/lightmap.zip' target='_blank'>http://www.delphigl.de/files/lightmap.zip</a> (320KByte, BIN only)

Ob ich den Quellcode veröffentlich weiss ich noch nicht, ich arbeite momentan allerdings daran den Lightmapgenerator von der ZornGL-Engine losuzukoppeln, damit ich ihn evtl. veröffentlichen kann.Allerdings steht alles was mein Lightmapper macht im von mir erwähnten Dokument drin, und sollte recht einfach zu implementieren sein.

Wer ein wenig rumexperimentieren will, der kann in der Datei lights.cfg die Eigenschaften der Lichtquellen verändern.Die Datei ist wie folgt aufgebaut :
Anzahl der Lichtquellen
für jede Lichtquelle eine Zeile : Position.x Position.y Position.z Radius Farbwert.Rot Farbwert.Grün Farbwert.Blau

Mit L kann man die Lightmaps an bzw. ausschalten. ESC beendet die Demo.

P.S. : Der Lightmapper speichert die Lightmaps in Bitmapdateien zwischen, die man sich später ansehen kann.Wer also seine Szenengeometrie in die Datei scene.cfg (Formatbeschreibung in der Datei) importiert, kann den Lightmapper theoretisch für kleine Projekte nutzen.Allerdings ist er bei weitem noch nicht komplett, und ich garantiere nicht für 100%ige Funktionalität in allen Szenen.

P.P.S. : Nochn Screenshot für die die sich das File nicht ziehen wollen :
Bild

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 11:34

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Tach, irgendwie kann ich das PDF Doku nicht lesen, bzw runterladen

Kannst du mir das mal an finalspace@web.de schicken ??

Danke,
Final

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 11:40

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Komisch.Bei mir funzt der Link ohne Probleme.Sowohl das Speichern als auch das Betrachten des Dokuments machen bei mir keine Probleme...das Dokument sollte aber gezippt innerhalb der nächsten paar Minuten in deinem Postfach landen.

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 11:48

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

thx

ich weiss au net, warum das nit geht... sobald ich anfang das zu saugen... dann springt die progressbar auf 100 percent... und wenn ich dann das dok öffne... dann seh ich nur das Deckblatt

Aber jetzt hab ich´s ja, hoffe ich raff dat... wenn nich... dann wirste wieda hier nen entry finden

matane,
Final

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 16:21

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Tach, schon gehen die probleme los:
Bin gerade dabei blind den code aus dem PDF Doku in delphi zu konvertieren und versteh schon einiges nicht, was machen diese zeilen ??

Code:

 
//now that we have our lumel array, get the lumel quad back on the triangle
//plane
//So, we get the intersection point with our triangle, if there is any...
//define our triangle conform MagicFM library
MgcT.Origin() = Triangle.Vertex[0];
MgcT.Edge0() = Triangle.Vertex[1]-Triangle.Vertex[0];
MgcT.Edge1() = Triangle.Vertex[2]-Triangle.Vertex[0];
//for every lumel
for(i=0; i< LMHEIGHT; i++)
{
for(int j=0; j<LMWIDTH; j++)
{
//origin
line.Origin() = lumels[j][i];
//direction
if(ProjType==XY)
{
line.Direction() = Vector3(0,0,1);
}
else if(ProjType==XZ)
{
line.Direction() = Vector3(0,1,0);
}
else if(ProjType==YZ)
{
line.Direction() = Vector3(1,0,0);
}
//find point on our triangle
if(FindIntersection(line, MgcT, pointofintersection))
{
lumels[j][i] = pointofintersection;
} else { /*Keep current coordinates, don't really need
them anyway*/ }
}
}
 

FindIntersection ?? MagicFM ? Ich will keine lib benutzen

warum eigentlich am anfang das:

Code:

 
 &nbsp;// 1.) Minimaler und Maximaler wert setzen
 &nbsp;highx := 100000000; highy := 100000000; highz := 100000000;
 &nbsp;lowx := -100000000; lowy := -100000000; lowz := -100000000;
 

matane,
Final

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 16:29

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Zitat:

FindIntersection ?? MagicFM ? Ich will keine lib benutzen

MagicFM ist eine Bibliothek zur Kollisionsberechnung, und deren Funktion FindIntersection führt eine Dreieckes/Linien-Kollisionsprüfung durch.Die benötigst du logischerweise, da du ja z.B. Stellen eines Polygons die vor dem Licht von einem anderen Polygon verdeckt werden nicht beleuchten willst.

Kurzer Quellcodeablauf:

Code:

MgcT.Origin() = Triangle.Vertex[0];
MgcT.Edge0() = Triangle.Vertex[1]-Triangle.Vertex[0];
MgcT.Edge1() = Triangle.Vertex[2]-Triangle.Vertex[0];

Übergibt die Vertexdaten an die MagicFM-Library.Den Teil mußt du natürlich an deine Linien-Dreiecks-Kollision anpassen.

Code:

for(i=0; i< LMHEIGHT; i++)
{
for(int j=0; j<LMWIDTH; j++)
{
//origin
line.Origin() = lumels[j][i];
//direction
if(ProjType==XY)
{
line.Direction() = Vector3(0,0,1);
}
else if(ProjType==XZ)
{
line.Direction() = Vector3(0,1,0);
}
else if(ProjType==YZ)
{
line.Direction() = Vector3(1,0,0);
}
//find point on our triangle
if(FindIntersection(line, MgcT, pointofintersection))
{
lumels[j][i] = pointofintersection;
} else { /*Keep current coordinates, don't really need
them anyway*/ }
}
}

line.Origin() = lumels[j][i]; teilt der MagicFM-Lib mit, wo die Kollisionslinie beginnt, und zwar auf dem Lumel das gerade in der Schleife bearbeitet wird.Das If-Konstrukt prüft, auf welcher Ebene das Dreieck liegt, und setzt dementsprechend die Ausrichtung der Kollisionslinie.Am Schluß wird dann nurnoch mittels FindIntersection(line, MgcT, pointofintersection) geprüft, ob etwas zwischen dem Lumel in dem Licht liegt.Ist dies der Fall, so wird er Lumel nicht beleuchtet.

Zitat:

warum eigentlich am anfang das:

Code:

 // 1.) Minimaler und Maximaler wert setzen
 highx := 100000000; highy := 100000000; highz := 100000000;
 lowx := -100000000; lowy := -100000000; lowz := -100000000;

Um sicherzustellen das beim Finden der Grenzen auch sicher keine falschen Werte vom Anfang übernommen werden.

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 22:43

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

die MagicFM Library,... woher find ich die ??? Ist das OpenSource ??
Oder reicht es wenn ich ne LineIntersection überprüfung mache, anstatt die intersection von MagicFM ?

also ich hab r3d_IntersectionPoint, r3d_IntersectedPlane in der math unit drin... was brauch ich dann noch ???

matane,
Final

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 22:47

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Finalspace hat geschrieben:

Oder reicht es wenn ich ne LineIntersection überprüfung mache, anstatt die intersection von MagicFM ?

Ja, das ist auch die einzige Funktion die in diesem Quellcodeteil aus der MagicFM genutzt wird.Eine einfache Line-Triangle-Intersection (auf sulaco.co.za gibts dazu übrigens ein Delphisample)...wenn du sowas schon für Kollisionstestzwecke in deiner Engine drin hast, dann brauchst du die MagicFM-Lib wie ich schon erwähnt habe nicht, und kannst stattdessen deine eigenen Routinen nutzen.

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 03, 2003 23:39

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Noch ne frage:

was ist das lambda.Unitize(); ???

Code:

 
float red,green,blue;
lambda = Light.pos - lumels[j][i];
float L = lambda.Length()/Light.strength;
lambda.Unitize();
float costheta = lambda.Dot(Triangle.Normal);
float theta = acos(costheta)*180/3.14152;
 

dann noch ne frage:

was ist dat:

Code:

 
rgb[0] = red > 255 ? 255 : red;
rgb[1] = green > 255 ? 255 : green;
rgb[2] = blue > 255 ? 255 : blue;
 

matane,
Final

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: So Mai 04, 2003 00:01

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Zitat:

was ist das lambda.Unitize();

Mit dem Quelltext hab ich micht eigentlich noch nie befasst, sondern habs so gemacht wie mans eigentlich machen sollte : Statt den Code blind von C nach Delphi zu konvertieren hab ich mir nur den Text zum Thema Lightmaperstellung durchgelesen und dann alles selbst implementiert.
Deshalb kann ich nur tippen und denke mal das dies dazu dient die Helligkeit Lambda in einen bestimmten Bereich (0..1) zu zwengen, so wie man das z.B. mit den Normalen unter OpenGL macht.

Zitat:

rgb[0] = red > 255 ? 255 : red;

Diese Zeile sorgt dafür, das der Rotwert (und die anderen Zeilen für Grün bzw. Blau) nicht über 255 hinausgeht, was bei einem Bytewert nämlich dazu führen würde, das der bedingt durch den Überlauf wieder bei 0 anfangen würde.Dadurch hätte man dann z.B. bei einem Lumel der von zwei roten Quellen beleuchtet wird im Extremfall einen vollkommen falschen Farbwert.

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: So Mai 04, 2003 01:04

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Also bis jetzt funzt gar nix was ich gemacht habe

Kommt sogar ne Access Violation

, aber nur wenn eine Kollision gefunden wurde.... hmpf..
Werden voll die komischen Texturen erstellt

(Hab das wie du als BMP mal speichern lassen)

Ich finds auch scheisse einfach alles blind nachzuproggen... aba ich versteh das ganze zeugs mal überhaupt nicht. Ich weiss ja nicht einmal was nen Cross Product oder Dot Product macht.
Das ist alles viel zu hoch für mich... ich war ja schon froh das ich Dynamic Lighting in crackout integrieren konnte und das war auch nur total gefaket

Und Leider findet man keine gescheiten Deutschen erklärungen dafür... eigentlich hab ich mit english keine probleme... aber wenn es um höhere mathematik geht... dann versteh ich gar nix mehr.

Das einzigste was ich endlich verstanden habe so einigermasen ist das Planarmapping, ansonsten...

Ich muss dich immer wieder bewundern wie schnell du die Theorie von 3d progging verstehst und dann mal schnell nen sourcecode hinprogst, der auch noch super aussieht.

Hier der code wie es momentan ist:

Code:

 
procedure TR3DEditorWorld.CreateLightmapTexture(const _Index : Integer; const _Obj : TR3DEditorObject; Triangle : array of TR3DVector; const Light : TR3DLight);
type
 &nbsp;TRGB = record
 &nbsp; &nbsp;R,G,B: Byte;
 &nbsp;end;
 
 &nbsp;TLightmapRGB = array of array of TRGB;
 
var
 &nbsp;Face &nbsp; &nbsp;: TR3DEditorFace;
 &nbsp;nNormal : TR3DVector;
 
 &nbsp;highx,highy,highz,
 &nbsp;lowx,lowy,lowz,
 &nbsp;highminuslowx, highminuslowy, highminuslowz: TR3DFloat;
 
 &nbsp;Plane &nbsp; &nbsp; : TR3DPlane;
 &nbsp;I, J &nbsp; &nbsp; &nbsp;: Integer;
 &nbsp;Tri &nbsp;: array [0..2] of TR3DVector;
 &nbsp;Quad : array [0..3] of TR3DVector;
 &nbsp;MappingCoords : array [0..2] of TR3DTexcoord;
 &nbsp;Lumels : array of array of TR3DVector;
 &nbsp;Line : array [0..1] of TR3DVector;
 &nbsp;pointofintersection : TR3DVector;
 
 &nbsp;LightmapRGB: TLightmapRGB;
 
 &nbsp;Red, Green, Blue : Integer;
 &nbsp;lambda : TR3DVector;
 &nbsp;L,
 &nbsp;theta,
 &nbsp;costheta : TR3DFloat;
 &nbsp;xrgb : Array [0..2] of byte;
 
 &nbsp;bmp : TBitmap;
begin
 &nbsp;Face := cFaces[_Index];
 
 &nbsp;// Normale
 &nbsp;nNormal.Assign(cNormals[_Index]);
 
 &nbsp;// 0.) Initialsieren
 &nbsp;Bmp := TBitmap.Create;
 &nbsp;Bmp.Width := LightMapSize;
 &nbsp;Bmp.Height := LightMapSize;
 
 &nbsp;SetLength(LightmapRGB, LightMapSize, LightMapSize);
 
 &nbsp;// 1.) Minimaler und Maximaler wert setzen
 &nbsp;highx := 100000000; highy := 100000000; highz := 100000000;
 &nbsp;lowx := -100000000; lowy := -100000000; lowz := -100000000;
 
 &nbsp;// 2.) Plane berechnen
 &nbsp;Plane := r3d_PlaneContruct(Triangle);
 
 &nbsp;// 3.) ???
 &nbsp;for I := 0 to 2 do
 &nbsp;begin
 &nbsp; &nbsp;case Plane.side of
 &nbsp; &nbsp; &nbsp;psYZ:
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].X := 0;
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].Y := Triangle[I].Y;
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].Z := Triangle[I].Z;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp; &nbsp;psXZ:
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].X := Triangle[I].X;
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].Y := 0;
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].Z := Triangle[I].Z;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp; &nbsp;psXY:
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].X := Triangle[I].X;
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].Y := Triangle[I].Y;
 &nbsp; &nbsp; &nbsp; &nbsp;Tri[I].Z := 0;
 &nbsp; &nbsp; &nbsp;end;
 &nbsp; &nbsp;end;
 &nbsp;end;
 
 &nbsp;// 4.) ???
 &nbsp;For I := 0 to 2 do
 &nbsp;begin
 &nbsp; &nbsp;if (Tri[I].X > highX) then highX := Tri[I].X;
 &nbsp; &nbsp;if (Tri[I].Y > highY) then highY := Tri[I].Y;
 &nbsp; &nbsp;if (Tri[I].Z > highZ) then highZ := Tri[I].Z;
 &nbsp; &nbsp;if (Tri[I].X < lowX) then lowX := Tri[I].X;
 &nbsp; &nbsp;if (Tri[I].Y < lowY) then lowY := Tri[I].Y;
 &nbsp; &nbsp;if (Tri[I].Z < lowZ) then lowZ := Tri[I].Z;
 &nbsp;end;
 
 &nbsp;highminuslowx := abs(highX-lowX);
 &nbsp;highminuslowy := abs(highY-lowY);
 &nbsp;highminuslowz := abs(highZ-lowZ);
 
 &nbsp;case Plane.side of
 
 &nbsp; &nbsp;psXY:
 &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp;For I := 0 to 3 do Quad[I].Z := 0;
 
 &nbsp; &nbsp; &nbsp;Quad[0].X := lowX;
 &nbsp; &nbsp; &nbsp;Quad[1].X := highX;
 &nbsp; &nbsp; &nbsp;Quad[2].X := highX;
 &nbsp; &nbsp; &nbsp;Quad[3].X := lowX;
 
 &nbsp; &nbsp; &nbsp;Quad[0].Y := lowY;
 &nbsp; &nbsp; &nbsp;Quad[1].Y := lowY;
 &nbsp; &nbsp; &nbsp;Quad[2].Y := highY;
 &nbsp; &nbsp; &nbsp;Quad[3].Y := highY;
 
 &nbsp; &nbsp; &nbsp;// Mapping Koordinaten
 &nbsp; &nbsp; &nbsp;For I := 0 to 2 do
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;MappingCoords[I].U := abs(Tri[I].X-lowx)/highminuslowx;
 &nbsp; &nbsp; &nbsp; &nbsp;MappingCoords[I].V := abs(Tri[I].Y-lowy)/highminuslowy;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp;end;
 
 &nbsp; &nbsp;psXZ:
 &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp;For I := 0 to 3 do Quad[I].Y := 0;
 
 &nbsp; &nbsp; &nbsp;Quad[0].X := lowX;
 &nbsp; &nbsp; &nbsp;Quad[1].X := highX;
 &nbsp; &nbsp; &nbsp;Quad[2].X := highX;
 &nbsp; &nbsp; &nbsp;Quad[3].X := lowX;
 
 &nbsp; &nbsp; &nbsp;Quad[0].Z := highZ;
 &nbsp; &nbsp; &nbsp;Quad[1].Z := highZ;
 &nbsp; &nbsp; &nbsp;Quad[2].Z := lowZ;
 &nbsp; &nbsp; &nbsp;Quad[3].Z := lowZ;
 
 &nbsp; &nbsp; &nbsp;// Mapping Koordinaten
 &nbsp; &nbsp; &nbsp;For I := 0 to 2 do
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;MappingCoords[I].U := abs(Tri[I].X-lowX)/highminuslowx;
 &nbsp; &nbsp; &nbsp; &nbsp;MappingCoords[I].V := abs(Tri[I].Z-lowZ)/highminuslowz;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp;end;
 
 &nbsp; &nbsp;psYZ:
 &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp;For I := 0 to 3 do Quad[I].X := 0;
 
 &nbsp; &nbsp; &nbsp;Quad[0].Z := highZ;
 &nbsp; &nbsp; &nbsp;Quad[1].Z := lowZ;
 &nbsp; &nbsp; &nbsp;Quad[2].Z := lowZ;
 &nbsp; &nbsp; &nbsp;Quad[3].Z := highZ;
 
 &nbsp; &nbsp; &nbsp;Quad[0].Y := lowY;
 &nbsp; &nbsp; &nbsp;Quad[1].Y := lowY;
 &nbsp; &nbsp; &nbsp;Quad[2].Y := highY;
 &nbsp; &nbsp; &nbsp;Quad[3].Y := highY;
 
 &nbsp; &nbsp; &nbsp;// Mapping Koordinaten
 &nbsp; &nbsp; &nbsp;For I := 0 to 2 do
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;MappingCoords[I].U := abs(Tri[I].Y-lowY)/highminuslowy;
 &nbsp; &nbsp; &nbsp; &nbsp;MappingCoords[I].V := abs(Tri[I].Z-lowZ)/highminuslowz;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp;end;
 
 &nbsp;end;
 
 &nbsp;// 5.) Lumel Array von Bounding Quader erstellen
 &nbsp;SetLength(Lumels, LightMapSize, LightMapSize);
 
 &nbsp;For I := 0 to LightMapSize-1 do
 &nbsp;begin
 &nbsp; &nbsp;For J := 0 to LightMapSize-1 do
 &nbsp; &nbsp;begin
 
 &nbsp; &nbsp; case Plane.side of
 
 &nbsp; &nbsp; &nbsp; psXY:
 &nbsp; &nbsp; &nbsp; begin
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].x := Quad[0].x + ( j*( (Quad[1].x - Quad[0].x)/LightMapSize ) );
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].y := Quad[0].y + ( i*( (Quad[3].y - Quad[0].y)/LightMapSize ) );
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].z := 0;
 &nbsp; &nbsp; &nbsp; end;
 
 &nbsp; &nbsp; &nbsp; psXZ:
 &nbsp; &nbsp; &nbsp; begin
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].x := Quad[0].x + ( j*( (Quad[1].x - Quad[0].x)/LightMapSize ) );
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].y := 0;
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].Z := Quad[0].z + ( i*( (Quad[3].z - Quad[0].z)/LightMapSize ) );
 &nbsp; &nbsp; &nbsp; end;
 
 &nbsp; &nbsp; &nbsp; psYZ:
 &nbsp; &nbsp; &nbsp; begin
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].x := Quad[0].x + ( j*( (Quad[1].x - Quad[0].x)/LightMapSize ) );
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].y := Quad[0].y + ( i*( (Quad[3].y - Quad[0].y)/LightMapSize ) );
 &nbsp; &nbsp; &nbsp; &nbsp; lumels[j][i].Z := 0;
 &nbsp; &nbsp; &nbsp; end;
 
 &nbsp; &nbsp; end;
 
 
 &nbsp; &nbsp;end;
 &nbsp;end;
 
 &nbsp;//6.) now that we have our lumel array, get the lumel quad back on the triangle
 &nbsp;// &nbsp; &nbsp;plane
 &nbsp;// &nbsp; &nbsp;So, we get the intersection point with our triangle, if there is any...
 &nbsp;For I := 0 to LightMapSize-1 do
 &nbsp;begin
 &nbsp; &nbsp;For J := 0 to LightMapSize-1 do
 &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp;// Begin der Linie
 &nbsp; &nbsp; &nbsp;line[0] := lumels[j][i];
 
 &nbsp; &nbsp; // Richtung bestimmen, dementsprechend wie die Plane liegt
 &nbsp; &nbsp; case Plane.side of
 &nbsp; &nbsp; &nbsp; psXY: line[1].Setup(0,0,1);
 &nbsp; &nbsp; &nbsp; psXZ: line[1].Setup(0,1,0);
 &nbsp; &nbsp; &nbsp; psYZ: line[1].Setup(1,0,0);
 &nbsp; &nbsp; end;
 
 &nbsp; &nbsp; // Kollision zwischen Polygon und Linie, wenn ja Lumel ändern
 &nbsp; &nbsp; if r3d_IntersectedPolygon(Triangle, line, pointofintersection) then
 &nbsp; &nbsp; begin
 &nbsp; &nbsp; &nbsp; lumels[j][i] := pointofintersection;
 &nbsp; &nbsp; &nbsp; showmessage(Format('%f %f %f',[pointofintersection.X, pointofintersection.Y, pointofintersection.Z]));
 &nbsp; &nbsp; end;
 
 &nbsp; &nbsp;end;
 &nbsp;end;
 
 &nbsp;// 7.) Texture erstellen, ENDLICH;)
 &nbsp;For I := 0 to LightMapSize-1 do
 &nbsp;begin
 &nbsp; &nbsp;For J := 0 to LightMapSize-1 do
 &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp;lambda := r3d_VectorSub(Light.Position, lumels[j][i]);
 &nbsp; &nbsp; &nbsp;L := lambda.Length/Light.Strength;
 &nbsp; &nbsp; &nbsp;lambda.Unitize;
 &nbsp; &nbsp; &nbsp;costheta := r3d_DotProduct(lambda, nNormal);
 &nbsp; &nbsp; &nbsp;theta := arccos(costheta)*180/3.14152;
 
 &nbsp; &nbsp; &nbsp;//calculate light strength
 &nbsp; &nbsp; &nbsp;if (theta < 90) and (theta > -90) then //triangle faces the light
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;red := Trunc(255 * Light.Color[0] * costheta / L);
 &nbsp; &nbsp; &nbsp; &nbsp;green := Trunc(255 * Light.Color[1] * costheta / L);
 &nbsp; &nbsp; &nbsp; &nbsp;blue := Trunc(255 * Light.Color[2] * costheta / L);
 &nbsp; &nbsp; &nbsp;end
 &nbsp; &nbsp; &nbsp;else //triangle is backfacing from light
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;red := 0;
 &nbsp; &nbsp; &nbsp; &nbsp;green := 0;
 &nbsp; &nbsp; &nbsp; &nbsp;blue := 0;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp; &nbsp;if red > 255 then red := 255;
 &nbsp; &nbsp; &nbsp;if green > 255 then green := 255;
 &nbsp; &nbsp; &nbsp;if blue > 255 then blue := 255;
 
 &nbsp; &nbsp; &nbsp;if Plane.side = psXY then
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;LightmapRGB[j, i].R := red;
 &nbsp; &nbsp; &nbsp; &nbsp;LightmapRGB[j, i].G := green;
 &nbsp; &nbsp; &nbsp; &nbsp;LightmapRGB[j, i].B := blue;
 &nbsp; &nbsp; &nbsp;end
 &nbsp; &nbsp; &nbsp;else
 &nbsp; &nbsp; &nbsp;begin
 &nbsp; &nbsp; &nbsp; &nbsp;LightmapRGB[j, LightMapSize - (i+1)].R := red;
 &nbsp; &nbsp; &nbsp; &nbsp;LightmapRGB[j, LightMapSize - (i+1)].G := green;
 &nbsp; &nbsp; &nbsp; &nbsp;LightmapRGB[j, LightMapSize - (i+1)].B := blue;
 &nbsp; &nbsp; &nbsp;end;
 
 &nbsp; &nbsp; &nbsp;Bmp.Canvas.Pixels[J,I] := RGB(LightmapRGB[J,I].R, LightmapRGB[J,I].G, LightmapRGB[I,J].B);
 &nbsp; &nbsp;end;
 &nbsp;end;
 
 &nbsp;// Lightmap in datei speichern.
 &nbsp;Bmp.SaveToFile('.&#092;textures&#092;lightmaps&#092;lightmap'+inttostr(testidx)+'.bmp');
 &nbsp;Bmp.Free;
 &nbsp;inc(testidx);
end;
 

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: So Mai 04, 2003 15:24

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Zitat:

Also bis jetzt funzt gar nix was ich gemacht habe
Kommt sogar ne Access Violation , aber nur wenn eine Kollision gefunden wurde.... hmpf..

Das liegt dann wohl eher an der Kollisionserkennung in deiner Engine als an dem Code zur Lightmaperstellung...also schau mal, ob du bei der Line-Triangle-Intersection nicht irgendwo nen Fehler machst.

Zitat:

Ich finds auch scheisse einfach alles blind nachzuproggen... aba ich versteh das ganze zeugs mal überhaupt nicht. Ich weiss ja nicht einmal was nen Cross Product oder Dot Product macht.Das ist alles viel zu hoch für mich... ich war ja schon froh das ich Dynamic Lighting in crackout integrieren konnte und das war auch nur total gefaket Und Leider findet man keine gescheiten Deutschen erklärungen dafür... eigentlich hab ich mit english keine probleme... aber wenn es um höhere mathematik geht... dann versteh ich gar nix mehr.

Dann würd ich, bevor du ne komplette 3D-Engine aufziehen willst, mal ein paar Bücher bzw. Tuts zum Thema Vektoren- und 3D-Berechnungen lesen.Ich hab mir die Sachen (da wir das bei uns auf der Schule nicht gemacht haben) auch selbst beibringen müssen.Es ist zwar stressig, sich in seiner Freizeit hinzusetzen und sich mit Dingen wie Kreuzprodukten oder Punktprodukten vertraut zu machen, allerdings hats ganz einfach keinen Zweck sich großartig in die 3D-Welt zu stürzen, wenn man bei diesen Themen schon den Durchblick verliert.
Nach einigen wenigen Wochen hatt ich dann dank diverser Tuts zum Thema Vektorenrechnung ausm Netz (zum Größtenteil in Englisch verfasst) alle nötigen Kenntnisse in diesem Gebiet zusammen.Es ist weder besonders schwer noch besonders stressig, zumal man sich in seiner Freizeit die Dinge ja einteilen kann wie man will...aber die Grundlagen in Sachen Vektorenrechnung solltest du unbedingt drauf haben.
Falls dir die Tuts im Netz nicht weiterheilfen, dann gibts ja Amazon.de genug Bücher zu diesem Thema.

Zitat:

Ich muss dich immer wieder bewundern wie schnell du die Theorie von 3d progging verstehst und dann mal schnell nen sourcecode hinprogst, der auch noch super aussieht.

Wie ich schonmal gesagt hab, ists halt wichtig zu verstehen was hinter den Kullissen läuft.Wenn ich irgend eine neue Technik ausprobieren will, dann implementiere ich sie erst, wenn ich komplett verstanden hab wie die Sache funzt.Selbst wenn ich mir Dokument XY von nVidia zum Thema Z zehnmal oder gar öfter durchlesen müsste, würd ich die Technik erst umsetzen, wenn ich wüsste wie genau sie funktioniert.

@Quellcode :
Ich halte es für ne schlechte Idee den von jemand anderem korrigieren zu lassen...deshalb werd ichs auch nicht machen.Nutz die Debuggingfähigkeiten der Delphi-IDE, und der Fehler sollte im Null-Komma-Nix gefunden sein.

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Mo Mai 05, 2003 07:38

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Tach,

also es ja nicht so das ich überhaupt nix raff in der 3d programmierung, sieht man ja auch an crackout.
Aber es ist nun mal so, das ich probleme haben, mit englishsprachiger 3D Geometrie seiten.
Ich hab schwerwiegende probleme NVIDIA PDF Dokumententen zu verstehen.

Wenn ich nen Deutsches Radiosity Lighting Tutorial hätte, dann würde ich das wahrscheinlich ohne probleme raffen... aber leider spuckt google nur englishe seites aus

Momentan würds mir schon reichen, wenn ich genau wüsste was nen Punkt Produkt macht und nen Kreuz produkt, dann könnte man sich selber was überlegen.

Was ich auch noch gern wissen würde, AngleBetweenVector(V1, V2)... von Welcher Achse gibt die funktion den winkel aus ? Und was zum teufel macht das verdammte Normal(V) bzw Normalize(V), berechnet den Normal Vector würd ich mal raten. Warum muss man manchmal nen Vector normaliesieren...

Für was man ne Normale braucht weiss ich ja, für Backface culling, und Licht sind normale sehr wichtig und vor allem für Planar mapping.

Erklär mir mal bitte die paar sachen, da ich keine gescheiten Deutschen Dokus darüber finden kann.

Danke,
Final

Nach oben

Seite 1 von 2

[ 20 Beiträge ]

Gehe zu Seite 1, 2 Nächste

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.