Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Fr Jul 18, 2025 05:06

Foren-Übersicht » Programmierung » OpenGL 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 7 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
crt
 Betreff des Beitrags: Normalen für jedes Vertex berechnen
BeitragVerfasst: Sa Aug 30, 2003 14:58 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jun 25, 2003 12:44
Beiträge: 29
Hi!
Wie kann ich die Normale für jedes Vertex einzeln berechnen? Also nicht für jedes Dreieck.
Nach oben
 Profil  
Mit Zitat antworten  
LarsMiddendorf
 Betreff des Beitrags:
BeitragVerfasst: Sa Aug 30, 2003 15:35 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Man kann den Durchschnitt der Normalen aller Flächen bilden, die diesen Punkte als eine Ecke haben. Dann bekommt man weiche Übergänge in der Beleuchtung zwischen den Flächen. Das sieht aber nur gut aus, wenn sich die Normalen der angrenzenden Flächen nicht zu sehr unterscheiden. Bei einem Würfel z.B. ist es sinnvoller für die Vertex Normalen die Flächennormalen zu nehmen.
Hinweis: Durch die Berechnung kann es sein, das die Normale nacher nicht mehr die Länge 1 hat und nochmal normalisiert werden muß.


Zuletzt geändert von LarsMiddendorf am Sa Aug 30, 2003 15:38, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
Sascha Willems
 Betreff des Beitrags:
BeitragVerfasst: Sa Aug 30, 2003 15:36 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++
Bin mir zwar nich ganz sicher, obs so 100%ig korrekt ist, aber es dürfte folgendermaßen funktionieren :
Du suchst alle Dreiecke die sich dieses Vertex teilen, berechnest dann die Normale für jedes dieser Dreiecke unter interpolierst dann zwischen diesen Normalen, und schon hast du die Normale für dieses Vertex.
Wenn dein Vertex also z.B. nur von einem Dreieck genutzt wird, dann entspricht die Vertexnormale der Dreiecksnormale.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)
Nach oben
 Profil  
Mit Zitat antworten  
crt
 Betreff des Beitrags:
BeitragVerfasst: Sa Aug 30, 2003 15:36 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jun 25, 2003 12:44
Beiträge: 29
Ich werd das mal mit dem Durschnitt machen.
Das brauch ich für ein generiertes Terrain.
Nach oben
 Profil  
Mit Zitat antworten  
crt
 Betreff des Beitrags:
BeitragVerfasst: Sa Aug 30, 2003 16:26 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jun 25, 2003 12:44
Beiträge: 29
Ich hab den code jetzt geschrieben, der ist aber wohl nicht so ganz richtig, wie ihr im Anhang sehen könnt.
Die Vertexdaten des Terrains hab ich als Quads in einem Array gespeichert.
Ich hab jetzt ne Schleife geproggt, die für jedes Vertex folgendes macht:
Zuerst wird geschaut, wie oft der Vertex im Array vorkommt.
Das Ergebnis ist die anzahl der Quads.
Dann werden die Normalen der Quads zusammengezählt und durch die anzahl der quads geteilt.
Das ist dann die Normale des Vertexes.

Der Code:
Code:
  1. procedure FindQuads(index:longint);
  2. var i,c:longint;
  3. begin
  4.   c := 0;
  5.   for i := 0 to High(EditHighmapDlg.VertexArray) do
  6.   begin
  7.       if (EditHighmapDlg.VertexArray[i][0] = EditHighmapDlg.VertexArray[index][0])
  8.       and (EditHighmapDlg.VertexArray[i][1] = EditHighmapDlg.VertexArray[index][1])
  9.       and (EditHighmapDlg.VertexArray[i][2] = EditHighmapDlg.VertexArray[index][2]) then
  10.         c := c + 1;
  11.   end;
  12.   SetLength(num_v,c);
  13.   c := 0;
  14.   for i := 0 to High(EditHighmapDlg.VertexArray) do
  15.   begin
  16.     if i <> index then
  17.       if (EditHighmapDlg.VertexArray[i][0] = EditHighmapDlg.VertexArray[index][0])
  18.       and (EditHighmapDlg.VertexArray[i][1] = EditHighmapDlg.VertexArray[index][1])
  19.       and (EditHighmapDlg.VertexArray[i][2] = EditHighmapDlg.VertexArray[index][2]) then
  20.       begin
  21.         num_v[c] := i;
  22.         inc(c);
  23.       end;
  24.   end;
  25. end;
  26. ...
  27.            SetLength(norms,(High(EditHighmapDlg.VertexArray) div 4));
  28.            for i := 0 to (High(EditHighmapDlg.VertexArray) div 4) do
  29.            begin
  30.              norm := FindNormal(newmesh.groups[0].vertices[i*4].x,
  31.                                 newmesh.groups[0].vertices[i*4].y,
  32.                                 newmesh.groups[0].vertices[i*4].z,
  33.                                 newmesh.groups[0].vertices[i*4+1].x,
  34.                                 newmesh.groups[0].vertices[i*4+1].y,
  35.                                 newmesh.groups[0].vertices[i*4+1].z,
  36.                                 newmesh.groups[0].vertices[i*4+2].x,
  37.                                 newmesh.groups[0].vertices[i*4+2].y,
  38.                                 newmesh.groups[0].vertices[i*4+2].z);
  39.              norms[i][0] := norm[1];
  40.              norms[i][1] := norm[2];
  41.              norms[i][2] := norm[3];
  42.            end;
  43.            apos := 0;
  44.            for i := 0 to High(EditHighmapDlg.VertexArray) do
  45.            begin
  46.              if i mod 4 = 0 then inc(apos);
  47.              FindQuads(i);
  48.              if length(num_v) = 1 then
  49.              begin
  50.                newmesh.groups[0].vertices[i].nx := norms[apos][0];
  51.                newmesh.groups[0].vertices[i].ny := norms[apos][1];
  52.                newmesh.groups[0].vertices[i].nz := norms[apos][2];
  53.              end
  54.              else
  55.              begin
  56.                norm[1] := 0;
  57.                norm[2] := 0;
  58.                norm[3] := 0;
  59.                for j := 0 to length(num_v)-1 do
  60.                begin
  61.                  temp := FindNormal(newmesh.groups[0].vertices[num_v[j]].x,
  62.                                     newmesh.groups[0].vertices[num_v[j]].y,
  63.                                     newmesh.groups[0].vertices[num_v[j]].z,
  64.                                     newmesh.groups[0].vertices[num_v[j]+1].x,
  65.                                     newmesh.groups[0].vertices[num_v[j]+1].y,
  66.                                     newmesh.groups[0].vertices[num_v[j]+1].z,
  67.                                     newmesh.groups[0].vertices[num_v[j]+2].x,
  68.                                     newmesh.groups[0].vertices[num_v[j]+2].y,
  69.                                     newmesh.groups[0].vertices[num_v[j]+2].z);
  70.                  norm[1] := norm[1] + temp[1];
  71.                  norm[2] := norm[2] + temp[2];
  72.                  norm[3] := norm[3] + temp[3];
  73.                end;
  74.                norm[1] := norm[1] / length(num_v);
  75.                norm[2] := norm[2] / length(num_v);
  76.                norm[3] := norm[3] / length(num_v);
  77.                newmesh.groups[0].vertices[i].nx := norm[1];
  78.                newmesh.groups[0].vertices[i].ny := norm[2];
  79.                newmesh.groups[0].vertices[i].nz := norm[3];
  80.              end;
  81.              Application.ProcessMessages;
  82.            end;


Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

Nach oben
 Profil  
Mit Zitat antworten  
Sascha Willems
 Betreff des Beitrags:
BeitragVerfasst: Sa Aug 30, 2003 16:46 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++
Für den Fall dass du das nicht machst : Lars hat in seinem Posting gesagt (was auch Sinn mach), das deine so errechnete Normale mit großer Wahrscheinlichkeit gar keine Normale (also größer 1) mehr ist.
Deshalb musst du dein Endergebnis nochmal normalisieren.Wenn das nichts bringt, lass dir doch ganz einfach mal per GL_LINE die Vertexnormalen anzeigen, und schon kannst du wenigstens ungefähr anhand der Bildschirmausgabe sagen ob und was nicht stimmt.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)
Nach oben
 Profil  
Mit Zitat antworten  
crt
 Betreff des Beitrags:
BeitragVerfasst: So Aug 31, 2003 09:48 
Offline
DGL Member
Benutzeravatar

Registriert: Mi Jun 25, 2003 12:44
Beiträge: 29
Ich hab den Fehler gefunden:
Dadurch, dass ich wirklich für jedes Vertex die Normale einzeln berechnet hab, gab es, wenn ein Vertex mit den selben Werten nochmal berechnet wurde, abweichungen beim Berechnen.
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 7 Beiträge ] 
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 21 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.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.007s | 14 Queries | GZIP : On ]