DGL • Thema anzeigen - Vertexnormalen der Heightmap

Vertexnormalen der Heightmap

Moderator: DGL-Team

Seite 1 von 1

[ 6 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Seth

Betreff des Beitrags: Vertexnormalen der Heightmap

Verfasst: Mi Okt 24, 2007 21:29

DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710

hi,
ich nutze eine leicht abgewandelte Version des Heightmap Codes aus dem wiki, welchen ich als Klasse aufgearbeitet habe.
Nun möchte ich diesen Code so abwandeln, dass die Normale für jedes Vertex berechnet wird, da es bei der Beleuchtung recht schlimm aussieht

Außerdem denke ich, so ein paar Polygone einsparen zu können. Allerdings habe ich noch so meine Probleme damit, wie ich das anstellen soll. Am Ende der Heightmap-Erstellung habe ich ja alle Flächennormalen berechnet. jetzt könnte ich daraus natürlich die Vertex-Koordinaten berechnen, allerdings weiß ich nicht so recht, welche Flächen an mein Vertex angrenzen. Ich hab da zwar einige Ideen, die scheinen mir aber ein wenig zu kompliziert, am liebsten wäre es mir natürlich, wenn ich diese gleich im ersten Durchgang berechnen könnte.

Hier ist mein Code:

Code:

 
procedure THeightmap.GenerateHeightmap;
const
  VertPos: array[0..3] of array[0..1] of Byte = ((0,0),(0,1),(1,1),(1,0));
var
  Map: array of array of byte;
  Vertices : Array[0..3] of TVector3f;
  x, z, i: integer;
 
  procedure DrawTriangle(V1, V2, V3: Integer);
  var
    Normal: TVector3f;
  begin
    Normal := v3f_normalize(v3f_CrossProduct(v3f_sub(Vertices[V1], Vertices[V2]), v3f_sub(Vertices[V2], Vertices[V3])));
    glNormal3f(Normal.x, Normal.y, Normal.z);
    glBegin(GL_TRIANGLES);
      glTexCoord2f(Vertices[V1].x / FSize.x, Vertices[V1].z / FSize.z); glVertex3f(Vertices[V1].x, Vertices[V1].y, Vertices[V1].z);
      glTexCoord2f(Vertices[V2].x / FSize.x, Vertices[V2].z / FSize.z); glVertex3f(Vertices[V2].x, Vertices[V2].y, Vertices[V2].z);
      glTexCoord2f(Vertices[V3].x / FSize.x, Vertices[V3].z / FSize.z); glVertex3f(Vertices[V3].x, Vertices[V3].y, Vertices[V3].z);
    glEnd;
  end;
begin
  FDisplayList := glGenLists(1);
  glNewList(FDisplayList, GL_COMPILE);
  FTexture.Bind();
  setlength(Map, FMapResolution + 1, FMapResolution + 1);
  for X := 0 to FMapResolution do
    for Z := 0 to FMapResolution do
      Map[X, Z] := Trunc(FHeightmap.Canvas.Pixels[Trunc(X / FMapResolution * FHeightmap.Width),
                                                  Trunc(Z / FMapResolution * FHeightmap.Height)] / clWhite * 255);
  for X := 0 to FMapResolution - 1 do
    for Z := 0 to FMapResolution - 1 do
    begin
      for i := 0 to 3 do
      begin
        Vertices[i].x := (X + VertPos[i][0]) / FMapResolution * FSize.x;
        Vertices[i].z := (Z + VertPos[i][1]) / FMapResolution * FSize.z;
        Vertices[i].y := Map[X + VertPos[i][0], Z + VertPos[i][1]] / 255 * FSize.y;
      end;
      DrawTriangle(0, 1, 3);
      DrawTriangle(1, 2, 3)
    end;
  glEndList;
end;
 

in dem lässt sich auch noch einiges Optimieren, aber ich wollte zunächst einmal die Normalen einbauen.

vielen dank schonmal

mfg

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Do Okt 25, 2007 17:40

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

Genau das wartet bei mir auch noch auf eine Implementation...

Hatte mir überlegt aus der Heightmap eine Normalmap zu generieren und die auch an den Shader zu binden, da meine landschaft sowieso im shader entsteht.
Bzgl. des Algorythmus zur berechnung hatte ich mit überlegt:
(fast) jeder Pixel hat vier Nachbarn.
mit jeweils zweien lässt sich ein Dreieck bilden und die Normale berechnen.
alle normalen zusammen rechnen durch 4 teilen und normalisieren.
dann sollte das doch die normale des vertex ergeben oder?

keine ahnung obs geht, fiel mir gestern aufm klo ein

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Nach oben

Seth

Betreff des Beitrags:

Verfasst: Do Okt 25, 2007 18:29

DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710

Meine Idee war folgende:

Alle Vertices mit den zugehörigen Flächennormalen in ein Array speichern und bei jedem hinzuprüfen testen ob das Vertex schon im Array ist. bei diesem Fall wird die Flächennormale aufaddiert und durch zwei geteilt.
Beim zeichnen müsste man dann wieder das jeweilge Vertex suchen, da sich das sonst so nicht ohne weiteres zeichnen lässt, es sei denn man schreibt die vertices doppelt und kopiert die normalen von deren ersten instanzen aus dem array an die jeweilige stelle.

Ich habe auch das Problem, dass wenn ich die Kamera bewege einige Vertices fast komplett schwarz werden, die es vorher nicht waren. Ein ähnliches Problem hatte ich schonmal, ist das opengl licht wirklich so mies ?

mfg

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Fr Okt 26, 2007 15:22

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

So ich habs jetzt...sieht zumindest so aus wie im Nvidia Photoshop Plugin

teilweise noch etwas dirty...

Code:

 
type
  TVector : array[0..2] of single;
  TTriangle = array[0..2] of TVector;
 
function GetNeighbor(x,y:integer):TVector;
const
  VertPos: array[0..3] of array[0..2] of array[0..1] of smallint =
    (
     ((0,0), (1, 0), (0, 1)),
     ((0,0), (0,-1), (1, 0)),
     ((0,0), (-1,0), (0,-1)),
     ((0,0), (0, 1), (-1,0))
    );
  Scale: single = 5;
var
  Face, Vertex : integer;
  xx,yy : integer;
  n : array[0..3] of TVector;
  t : TTriangle;
  tmp : TVector;
begin
  tmp := MakeVector(0,0,0);
  for Face := 0 to 3 do begin
    for Vertex := 0 to 2 do begin
      xx := x + VertPos[Face][Vertex][0];
      yy := y + VertPos[Face][Vertex][1];
      if (xx < 0) then xx := 0;
      if (yy < 0) then yy := 0;
      if (xx > 255) then xx := 255;
      if (yy > 255) then yy := 255;
      t[Vertex][0] := xx;
      t[Vertex][1] := yy;
      t[Vertex][2] := GetHeight(xx, yy) * Scale / 256;
    end;
    n[Face] := GetNormal(t);
    //Normale addieren
    tmp := AddVectors(tmp, n[Face]);
  end;
  Normalize(tmp);
  //von Interval -1..0..1 auf 0..255 umrechnen
  tmp := AddVectors(tmp, MakeVector(1, 1, 1));
  tmp := ScaleVector(tmp, 128);
  //Clamp
  if (tmp[0] > 255) then tmp[0] := 255;
  if (tmp[1] > 255) then tmp[1] := 255;
  if (tmp[2] > 255) then tmp[2] := 255;
  result := tmp;
end;
 

man könnte jetzt noch verschiedene filter (3x3, 5x5, 7x7, etc) einbauen

Nach oben

Seth

Betreff des Beitrags:

Verfasst: Mo Okt 29, 2007 20:55

DGL Member

Registriert: Di Mai 24, 2005 16:43
Beiträge: 710

x und y sind die koordinaten auf der heightmap, oder die des vertex ? und das ergebnis ist der durchschnittsvektor aller umgebenden flächennormalen ? also praktisch die vertexnormale von x y ?

mfg

Nach oben

damadmax

Betreff des Beitrags:

Verfasst: Di Okt 30, 2007 12:56

DGL Member

Registriert: Sa Aug 18, 2007 18:47
Beiträge: 694
Wohnort: Köln
Programmiersprache: Java

Ja hast recht. Ist etwas verwirrend. Man sollte eigentlich x und z nehmen... :lol:

Das ist jetzt nur ein einfacher Abgleich mit den direkten Nachbarn (Links, Rechts, Oben, Unten).

Btw: habe jetzt meine Landschaft auch um die Normalmap erweitert. Sieht wirklich schick aus mittlerweile. Fehlt nur noch ne Shadowmap. Und der Shader wird auch langsam richtig voll.

Nach oben

Seite 1 von 1

[ 6 Beiträge ]

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.