DGL • Thema anzeigen - Radiosity Lighting

Radiosity Lighting

Moderator: DGL-Team

Seite 2 von 2

[ 20 Beiträge ]

Gehe zu Seite Vorherige 1, 2

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Mars

Betreff des Beitrags:

Verfasst: Mo Mai 05, 2003 09:05

DGL Member

Registriert: Fr Dez 13, 2002 12:18
Beiträge: 1063

Das kann man dir schon erklären, anschaulicher wirds aber deswegen nicht - da muss du dich schon eine Weile selbst damit beschäftigen, wenn du noch nie mit Vektoren und Matrizen gearbeitet hast.

Punktprodukt:
Die Komponenten der Vektoren werden multipliziert, das Ergebnis entspricht: v1 · v2 = |v1| * |v2| * cos(ø), wobei ø der Winkel zwischen den Vektoren ist

Kreuzprodukt:
a × b = c

es steht c senkrecht auf a und b, und zwar so, dass a, b und c ein Rechtssystem bilden. Das Vektorprodukt ist somit anti-kommutativ; es gilt a × b = - b × a.
Der Vektor c hat die Länge

|c| = |a||b| sin ø

was der Fläche des zwischen a und b aufgespannten Parallelogramms entspricht.
Das Vektorprodukt ist nur für dreidimensionale Räume definiert und berechnet sich wie folgt:

c1 = a2b3 - a3b2 / c1 \
c2 = a3b1 - a1b3 c = | c2 |
c3 = a1b2 - a2b1 \ c3 /

Weil ich zu faul war, das Ganze selbst hinzuschreiben (steht ja auch in jedem Buch über lineare Algebra drin - und auch in den meisten Schulbüchern der oberen Stufen drin!) habe ich das Ganze aus der zweiten oder dritten Seite die von Google zum Thema aufgelistet wurden rauskopiert, was deine Aussage, dass es keine deutschen Dokus gibt glatt Lügen straft.

Evtl. solltest du dich nicht so sehr auf OpenGL Tutorials konzentrieren - klar dass es bei denen eher um OpenGL Funktionalität geht, als um die Mathematik die dahinter steckt (ich würd mich auch sauber bedanken, wenn in jedem Dokument etwa das Kreuzprodukt wieder erklärt würde), such dir lieber ein einfachen Text über Vektorrechnung und du schneidest besser ab.

_________________
Viel Spaß beim Programmieren,
Mars
http://www.basegraph.com/

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Mo Mai 05, 2003 15:02

DGL Member

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

Ich werd mir einfach ne Testapplikation machen... und dann mal nen bisserl damit rumexperimentieren.
Mit Dot Product, Cross Produkt, Angel between vectors usw.

Aber jetzt mal meine frage, was genau macht den das Radiosity Lighting eigentlich ??
Ich find nur PDF Dokumenten mit irgendwelchen Formeln... ich würd aber mal gern genau wissen, das da wirklich passiert...

Ich les dann andauernd was von Patches und so... also muss ich meine Polygone nochmal teilen in mehrere polygone ??? Was soll das für ein sinn machen ?

Eigentlich wenn man nen Radiosity Processor programmiert hat, dann hat man nen kleinen Raytraycer seh ich das richtig ???

Hmpf, viele Diplomarbeiten sind über Radiosity geschrieben worden und dann wundert ihr euch wenn nen unwissender hauptschüler nicht rafft

matane,
Final

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Mo Mai 05, 2003 15:07

DGL Member

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

Zitat:

Aber jetzt mal meine frage, was genau macht den das Radiosity Lighting eigentlich ??

Es berechnet für einen bestimmten Punkt auf einer gegebenen Fläche den Lichteinfall einer oder mehrerer Lichtquellen...mehr gibts dazu eigentlich nicht zu sagen.

Zitat:

Ich les dann andauernd was von Patches und so... also muss ich meine Polygone nochmal teilen in mehrere polygone ??? Was soll das für ein sinn machen ?

Nein, mußt du nicht.Das wird ja auch in dem Dokument das ich gepostethabe nicht gemacht.Die Sache mit den Patches ist nur ne temporäre Unterteilung deines Polygones für eine verbesserte Beleuchtung.Dein Polygon bleibt dabei allerdings unangetastet, und wird nur für die Lichtberechnungsprozedur unterteilt.

Zitat:

Eigentlich wenn man nen Radiosity Processor programmiert hat, dann hat man nen kleinen Raytraycer seh ich das richtig ???

Nein, nicht wirklich...ein RayTracer ist weitaus komplexer und kaum mit nem Radiosity Processor zu vergleichen.Bei einem Raytracer würde das Licht, das auf eine Fläche fällt z.B. je nach deren Beschaffenheit reflektiert.Allerdings sind einige Grundansätze eines Raytracers in nem Radiosity Processor enthalten.

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

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 10, 2003 20:35

DGL Member

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

Tach,

ich habs hinbekommen... endlich... ABER... leider nicht ganz korrekt.
Zum kurzen verständnis:

Code:

 
  Light.Position.Setup(-2.0, 1.5, 2.0);
  
  glPushMatrix;
    glDisable(GL_BLEND);
    glColor3f(Light.Red, Light.Green, Light.Blue);
    glTranslatef(Light.Position.X, Light.Position.Y,Light.Position.Z);
    gluSphere(gTempQuadric, 0.1, 10, 10);
  glPopMatrix;
 

Normalweise, würde die Sphere von nullpunkt aus, 2 einheiten nach links verschoben sein X, 1.5 einheiten nach oben Y und 2 einheiten nach vorne oder irr ich mich ???

Mein rechner allerdings rendert die sphere mit den selben Lichtpositionskoordinaten an:

X = 2 Einheiten nach Links (Korrekt)
Y = 1.5 Einheiten nach Oben (Korrekt)
Z = 2 Einheiten nach Hinten (Falsch)

wieso ? An der Camera liegts auch nciht, wenn ich das ganze normal über gluLookAt oder glTranslate anschauen lasse, siehts überall gleich aus... also keine achse ist vertauscht.

Jetzt kommt aber das komischste an der ganzen sache:

Ich lass mir für jedes Face ( 1 Face = Polygon ) die 3 Vertices aus meinem vertices array ausgeben:
also so:

Code:

 
function TR3DEditorWorld.GetPolygonFromFace(const _Index : Integer; const _Obj : TR3DEditorObject) : TR3DPolygon;
var
  Face    : TR3DEditorFace;
  I       : Integer;
  Vec     : TR3DVector;
  TInfo   : TR3DEditorTextureInfo;
  nTriangleIdx : Integer;
  nTriangle : TR3DPolygon;
  nNormal   : TR3DVector;
  nPlane    : TR3DPlane;
begin
  // Face auslesen
  Face := cFaces[_Index];
  nNormal.Assign(cNormals[_Index]);
 
  // Texture Daten auslesen
  TInfo := cTextureInfos[Face.TextureIndex];
 
  // Vertices in Triangle Array speichern
  nTriangleIdx := 0;
  For I := Face.StartIndex to (Face.StartIndex+2) do
  begin
    // Vector
    Vec.Assign(cVertices[I]);
 
    // Invertieren... warum bloss ?
    Vec.X := -Vec.X;
 
    // Transformieren
    Vec.RotateX(_Obj.Rotate.X);
    Vec.RotateY(_Obj.Rotate.Y);
    Vec.RotateZ(_Obj.Rotate.Z);
    Vec.Add(_Obj.Position);
    Vec.Multiply(_Obj.Scale);
 
    // In Triangle speichern für Normale zeichnen
    nTriangle.Vecs[nTriangleIdx].Assign(Vec);
 
    Inc(nTriangleIdx);
  end;
 
  Result := nTriangle;
end;
 

Mit diesem Dreieck rechne ich dann weiter mit der Radiosity Lighting berechnung.
Das komische ist aber, wenn ich keine invertierung von der Vec achse mache, egal ob X, Y, Z.
dann funzt die berechnung überhaupt nicht mehr.

Die Transformierungsdaten für das Object ist immer Pos 0,0,0 Rotate 0,0,0 Scale 1,1,1
Also wird eigentlich gar nix am vector geändert.

Hier ist das Tutorial das ich verwendet habe::: <a href='http://members.net-tech.com.au/alaneb/lightmapping_tutorial.html' target='_blank'>Radiosity Tut</a>

Hier der komplette code des Radiosity Processors, da dieser auch nur ne konversation von c in delphi ist postet ich den:

Code:

 
type
 &nbsp;TR3DTextureData = array of array of TR3DRGBA;
 
 &nbsp;TR3DRGBA = record
 &nbsp; &nbsp;R,G,B,A : Byte;
 &nbsp;end;
 
{-----------------------------------------------------------------------------
  Procedure:   TR3DEditorWorld.CreateLightmapTextures
  Author:      Finalspace
  Date:        10-Mai-2003
  Arguments:   NumPolys : Integer; Polys : array of TR3DPolygon
  Result:      None
  Call from:   None
  Type:        None
  Description: Für Alle Polygone Lichtmaps über Radiosity berechnen
-----------------------------------------------------------------------------}
procedure TR3DEditorWorld.CreateLightmapTextures(NumPolys : Integer; Polys : array of TR3DPolygon);
const
  WIDTH = 16;
  HEIGHT = 16;
var
  Lumels             : array [0..WIDTH-1, 0..HEIGHT-1] of TR3DVector;
  Edge1, Edge2       : TR3DVector;
  NewEdge1, NewEdge2 : TR3DVector;
  Vect1, Vect2       : TR3DVector;
  UVVector           : TR3DVector;
  Poly_Normal        : TR3DVector;
  LightVector        : TR3DVector;
  PointOnPlane       : TR3DVector;
  LumelColor         : array [0..WIDTH-1, 0..HEIGHT-1] of TR3DRGB;
  lightdistance      : TR3DFloat;
  uvMin_U            : TR3DFloat;
  uvMin_V            : TR3DFloat;
  uvMax_U            : TR3DFloat;
  uvMax_V            : TR3DFloat;
  cosAngle           : TR3DFloat;
  X, Y, Z            : TR3DFloat;
  Distance           : TR3DFloat;
  uvDelta_U          : TR3DFloat;
  uvDelta_V          : TR3DFloat;
  ufactor            : TR3DFloat;
  vfactor            : TR3DFloat;
  CombinedRed        : TR3DFloat;
  CombinedGreen      : TR3DFloat;
  CombinedBlue       : TR3DFloat;
  Intensity          : TR3DFloat;
  Flag               : Integer;
  Temp               : String[255];
  Lightmap           : TR3DTextureData;
  Loop, i, iX, iY    : Integer;
  Bmp                : TBitmap;
begin
  // Arrays Initialsieren
  SetLength(Lightmap, WIDTH, HEIGHT);
 
  // Alle Polygone/Faces durchgehen (Jedes Face hat ein Polygon)
  For Loop := 0 to NumPolys-1 do
  begin
    // Normale holen
    Poly_Normal := Polys[loop].GetNormal;
    Poly_Normal.Normalize;
 
    PointOnPlane.x := Polys[loop].Vecs[0].X;
    PointOnPlane.y := Polys[loop].Vecs[0].Y;
    PointOnPlane.z := Polys[loop].Vecs[0].Z;
 
    // find plane to map onto
    if (abs(Poly_Normal.x) > abs(Poly_Normal.y)) and (abs(Poly_Normal.x) > abs(Poly_Normal.z)) then
    begin
      Flag := 1;
      cFaces[Loop].Lightmap.Vertex_u[0] := Polys[loop].Vecs[0].y;
      cFaces[Loop].Lightmap.Vertex_v[0] := Polys[loop].Vecs[0].z;
      cFaces[Loop].Lightmap.Vertex_u[1] := Polys[loop].Vecs[1].y;
      cFaces[Loop].Lightmap.Vertex_v[1] := Polys[loop].Vecs[1].z;
      cFaces[Loop].Lightmap.Vertex_u[2] := Polys[loop].Vecs[2].y;
      cFaces[Loop].Lightmap.Vertex_v[2] := Polys[loop].Vecs[2].z;
    end
    else
    begin
 
      if (abs(Poly_Normal.y) > abs(Poly_Normal.x)) and (abs(Poly_Normal.y) > abs(Poly_Normal.z)) then
      begin
        Flag := 2;
        cFaces[Loop].Lightmap.Vertex_u[0] := Polys[loop].Vecs[0].x;
        cFaces[Loop].Lightmap.Vertex_v[0] := Polys[loop].Vecs[0].z;
        cFaces[Loop].Lightmap.Vertex_u[1] := Polys[loop].Vecs[1].x;
        cFaces[Loop].Lightmap.Vertex_v[1] := Polys[loop].Vecs[1].z;
        cFaces[Loop].Lightmap.Vertex_u[2] := Polys[loop].Vecs[2].x;
        cFaces[Loop].Lightmap.Vertex_v[2] := Polys[loop].Vecs[2].z;
      end
      else
      begin
        Flag := 3;
        cFaces[Loop].Lightmap.Vertex_u[0] := Polys[loop].Vecs[0].x;
        cFaces[Loop].Lightmap.Vertex_v[0] := Polys[loop].Vecs[0].y;
        cFaces[Loop].Lightmap.Vertex_u[1] := Polys[loop].Vecs[1].x;
        cFaces[Loop].Lightmap.Vertex_v[1] := Polys[loop].Vecs[1].y;
        cFaces[Loop].Lightmap.Vertex_u[2] := Polys[loop].Vecs[2].x;
        cFaces[Loop].Lightmap.Vertex_v[2] := Polys[loop].Vecs[2].y;
      end;
 
    end;
 
    // convert to 2D texture space
    uvMin_U := cFaces[Loop].Lightmap.Vertex_u[0];
    uvMin_V := cFaces[Loop].Lightmap.Vertex_v[0];
    uvMax_U := cFaces[Loop].Lightmap.Vertex_u[0];
    uvMax_V := cFaces[Loop].Lightmap.Vertex_v[0];
 
    for i := 0 to 2 do
    begin
      if (cFaces[Loop].Lightmap.Vertex_u[i] < uvMin_U ) then
        uvMin_U := cFaces[Loop].Lightmap.Vertex_u[i];
 
      if (cFaces[Loop].Lightmap.Vertex_v[i] < uvMin_V ) then
        uvMin_V := cFaces[Loop].Lightmap.Vertex_v[i];
 
      if (cFaces[Loop].Lightmap.Vertex_u[i] > uvMax_U ) then
        uvMax_U := cFaces[Loop].Lightmap.Vertex_u[i];
 
      if (cFaces[Loop].Lightmap.Vertex_v[i] > uvMax_V ) then
        uvMax_V := cFaces[Loop].Lightmap.Vertex_v[i];
    end;
 
    uvDelta_U := uvMax_U - uvMin_U;
    uvDelta_V := uvMax_V - uvMin_V;
 
    // Normieren
    for i := 0 to 2 do
    begin
      cFaces[Loop].Lightmap.Vertex_u[i] := cFaces[Loop].Lightmap.Vertex_u[i] - uvMin_U;
      cFaces[Loop].Lightmap.Vertex_v[i] := cFaces[Loop].Lightmap.Vertex_v[i] - uvMin_V;
      cFaces[Loop].Lightmap.Vertex_u[i] := cFaces[Loop].Lightmap.Vertex_u[i] / uvDelta_U;
      cFaces[Loop].Lightmap.Vertex_v[i] := cFaces[Loop].Lightmap.Vertex_v[i] / uvDelta_V;
    end;
 
    // calculate the world space position for each lumel
    Distance := - (Poly_Normal.x * PointOnPlane.x + Poly_Normal.y * PointOnPlane.y + Poly_Normal.z * PointOnPlane.z);
 
    case Flag of
 
      1: //YZ Plane
      begin
        X := - ( poly_normal.y * uvMin_U + poly_normal.z * uvMin_V + Distance ) / poly_normal.x;
        UVVector.x := X;
        UVVector.y := uvMin_U;
        UVVector.z := uvMin_V;
        X := - ( poly_normal.y * uvMax_U + poly_normal.z * uvMin_V + Distance ) / poly_normal.x;
        Vect1.x := X;
        Vect1.y := uvMax_U;
        Vect1.z := uvMin_V;
        X := - ( poly_normal.y * uvMin_U + poly_normal.z * uvMax_V + Distance ) / poly_normal.x;
        Vect2.x := X;
        Vect2.y := uvMin_U;
        Vect2.z := uvMax_V;
      end;
 
      2: //YZ Plane
      begin
        Y := - ( poly_normal.x * uvMin_U + poly_normal.z * uvMin_V + Distance ) / poly_normal.y;
        UVVector.x := uvMin_U;
        UVVector.y := Y;
        UVVector.z := uvMin_V;
        Y := - ( poly_normal.x * uvMax_U + poly_normal.z * uvMin_V + Distance ) / poly_normal.y;
        Vect1.x := uvMax_U;
        Vect1.y := Y;
        Vect1.z := uvMin_V;
        Y := - ( poly_normal.x * uvMin_U + poly_normal.z * uvMax_V + Distance ) / poly_normal.y;
        Vect2.x := uvMin_U;
        Vect2.y := Y;
        Vect2.z := uvMax_V;
      end;
 
      3: //XY Plane
      begin
        Z := - ( poly_normal.x * uvMin_U + poly_normal.y * uvMin_V + Distance ) / poly_normal.z;
        UVVector.x := uvMin_U;
        UVVector.y := uvMin_V;
        UVVector.z := Z;
        Z := - ( poly_normal.x * uvMax_U + poly_normal.y * uvMin_V + Distance ) / poly_normal.z;
        Vect1.x := uvMax_U;
        Vect1.y := uvMin_V;
        Vect1.z := Z;
        Z := - ( poly_normal.x * uvMin_U + poly_normal.y * uvMax_V + Distance ) / poly_normal.z;
        Vect2.x := uvMin_U;
        Vect2.y := uvMax_V;
        Vect2.z := Z;
      end;
 
    end;
 
    // Ecken ?
 
    edge1.x := Vect1.x - UVVector.x;
    edge1.y := Vect1.y - UVVector.y;
    edge1.z := Vect1.z - UVVector.z;
    edge2.x := Vect2.x - UVVector.x;
    edge2.y := Vect2.y - UVVector.y;
    edge2.z := Vect2.z - UVVector.z;
 
    for ix := 0 to WIDTH-1 do
    begin
      for iy := 0 to HEIGHT-1 do
      begin
 
        ufactor := (iX / WIDTH);
        vfactor := (iY / HEIGHT);
        newedge1.x := edge1.x * ufactor;
        newedge1.y := edge1.y * ufactor;
        newedge1.z := edge1.z * ufactor;
        newedge2.x := edge2.x * vfactor;
        newedge2.y := edge2.y * vfactor;
        newedge2.z := edge2.z * vfactor;
 
        lumels[iX][iY].x := UVVector.x + newedge2.x + newedge1.x;
        lumels[iX][iY].y := UVVector.y + newedge2.y + newedge1.y;
        lumels[iX][iY].z := UVVector.z + newedge2.z + newedge1.z;
 
        // Lichtstärke berechnen und RGB Werte
        combinedred := 0.0;
        combinedgreen := 0.0;
        combinedblue := 0.0;
        For i := 0 to High(cStaticLights) do
        begin
 
          // Kollionsdetection zwischen Lightposition, Plane und Normale
          if (r3d_ClassifyPoint(cStaticLights[i].Position, PointOnPlane, Poly_Normal) = 1) then
          begin
 
            lightvector.x := cStaticLights[i].Position.x - lumels[iX][iY].x;
            lightvector.y := cStaticLights[i].Position.y - lumels[iX][iY].y;
            lightvector.z := cStaticLights[i].Position.z - lumels[iX][iY].z;
            lightdistance := lightvector.Magnitude;
            lightvector.Normalize();
            cosAngle := r3d_DotProduct(Poly_Normal, lightvector);
 
            if (lightdistance < cStaticLights[i].Radius) then
            begin
              intensity := (cStaticLights[i].Brightness * cosAngle) / lightdistance;
              combinedred := combinedred + cStaticLights[i].Red * intensity;
              combinedgreen := combinedgreen + cStaticLights[i].Green * intensity;
              combinedblue := combinedblue + cStaticLights[i].Blue * intensity;
            end;
          end;
 
        end;
 
        if (combinedred > 255.0) then combinedred := 255.0;
        if (combinedgreen > 255.0) then combinedgreen := 255.0;
        if (combinedblue > 255.0) then combinedblue := 255.0;
        lumelcolor[iX][iY].R := Trunc(combinedred);
        lumelcolor[iX][iY].G := Trunc(combinedgreen);
        lumelcolor[iX][iY].B := Trunc(combinedblue);
 
      end;
    end;
 
    // Texture endlich erstellen;)
    Bmp := TBitmap.Create;
    Bmp.Width := WIDTH;
    Bmp.Height := HEIGHT;
    for iX := 0 to WIDTH-1 do
    begin
      For iY := 0 to HEIGHT-1 do
      begin
 
        lightmap[iX, iY].R := Trunc(lumelcolor[iX][iY].R);
        lightmap[iX, iY].G := Trunc(lumelcolor[iX][iY].G);
        lightmap[iX, iY].B := Trunc(lumelcolor[iX][iY].B);
        lightmap[iX, iY].A := 255;
 
        Bmp.Canvas.Pixels[iX, iY] := RGB(lightmap[iX, iY].R,
                                         lightmap[iX, iY].G,
                                         lightmap[iX, iY].B);
 
      end;
    end;
 
    // Lightmap als Bitmap speichern
    Bmp.SaveToFile('.&#092;textures&#092;lightmaps&#092;lm'+IntToStr(Loop)+'.bmp');
    Bmp.Free;
 
    // Lightmap als OGL Texture speichern
    cFaces[Loop].Lightmap.Texture.cData := lightmap;
    cFaces[Loop].Lightmap.Texture.BuildFromData(WIDTH, HEIGHT);
 
  end;
end;
 

Ich bin ehrlich, ich hab nich ganz gepeilt was da überhaupt passiert.
Deswegen no comments.

Mein testprog poste ich am montag, über Handy kann ich keine FTP verbindung herstellen.

matane,
Final

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Sa Mai 10, 2003 20:44

DGL Member

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

Screenshots in Attachment

matane,
Final

Nach oben

Seite 2 von 2

[ 20 Beiträge ]

Gehe zu Seite Vorherige 1, 2

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 4 Gäste

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.