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

Aktuelle Zeit: Fr Jul 18, 2025 16:55

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



Ein neues Thema erstellen Auf das Thema antworten  [ 13 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: Displaylist und Silhoutte
BeitragVerfasst: Mi Apr 12, 2006 13:24 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
Hallo,

Ich bin inzwischen soweit, dass ich in mein Programm Konturen einlesen kann. Mittels dieser Konturen erzeuge ich Displaylisten. Funktioniert auch recht gut, bis ich in den sw-Modus wechsel. Ich weiß nicht, wie ich die Silhoutte zeichnen soll.

Bislang habe ich die Formen immer Weiß als Fläche gezeichnet. Dann noch einmal die Kanten, die ich benötige in schwarz hinterher gezeichnet. Hierbei habe ich mittels Augpunkt und den Flächenvektoren entschiden, welche Kante gezeichnet werden muss. Da ich aber nun vorher die Displaylists erstelle kenne ich den Augpunkt nicht und kann die Silhouttekanten nicht vorher berechnen. Hat jemant eine Idee???

Gruß Bomberbb


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


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mo Apr 24, 2006 19:16 
Offline
DGL Member

Registriert: So Feb 19, 2006 23:46
Beiträge: 55
Eine einfache Möglichkeit, Sillhouetten zu zeichnen, ist den Tiefentest auf GL_LEQUAL einzustellen, das Face Culling auf Front Face Culling umzustellen, GL_LINE als PolygonMode einzustellen und das Objekt zu zeichnen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Apr 25, 2006 08:27 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
das hab ich glaub ich noch nicht ganz verstanden...
wie würde dass denn im Quelltext aussehen???


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Apr 25, 2006 09:22 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
Habe mal ein bissel probiert, wie ich mir das denke.

Code:
  1.  
  2.   glDepthFunc(GL_LEQUAL);
  3.   glEnable(GL_CULL_FACE);
  4.   glCullFace(Gl_FRONT);
  5.   glPolygonMode(GL_FRONT, GL_LINE);
  6.   glBegin(GL_QUADS);
  7.   ..
  8.   glEnd;
  9.  


Nun sehe ich von der Form nur noch die Rückseite als Linien, Muss ich nun das ganze noch mal als Flächen davor zeichnen???
ober war das anders gemeint, dass es eine Einstellung gibt, mit der ich nicht zweimal, sondern nur einmal zeichnen muss???


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Apr 25, 2006 13:34 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Das problem bei dieser Methode ist, dass man nicht sicher sein kann, dass die Vorderen polygone zuerst in den Tiefenpuffer geschrieben werden. Deshalb kanns wie beschrieben passieren, dass man dann einfach nur die Rückseite sieht.

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Apr 25, 2006 16:20 
Offline
DGL Member

Registriert: So Feb 19, 2006 23:46
Beiträge: 55
Stimmt, man muss zuerst mit richtigem Face Culling der Flächen zeichnen, hatte ich vergessen zu erwähnen. Mit der Methode geht es soweit ich weiß nicht ohne alles zwei mal zu zeichnen.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Mai 30, 2006 12:21 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
Das klappt nun eigendlich alles so, wie es soll. (Mit zweimal zeichnen) Allerdings schimmern ab einer gewissen Entfernung die hinteren Linien durch die Flächen....
Habe gesehen, dass sich das bei entsprechendem Farclipping ändert, aber dann scheint es bei anderen Entfernungen durch.
Was kann ich da machen???


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Mai 30, 2006 12:26 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Flimmern die Linien?
Das kommt durch die Auflösung des Tiefenpuffers. Wenn du statt 16 mal 24 oder 32bit verwendest, kannst du den effekt weit nach hinten rausschieben. Eine Erkärung findest du unter ZFighting im Wiki.

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Di Mai 30, 2006 12:59 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
Nein, es flimmert nicht. Habe aber festgestellt, dass es nicht die Hinterkanten des Objekts sind, sondern die Kanten von Objekten, die sich noch dahinter befinden.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Einbild sagt mehr als tausend Worte
BeitragVerfasst: Mi Mai 31, 2006 10:02 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
Ich habe das Problem als Bild angehangen. Ich habe mit der Methode zwei Zylinder ineinandergezeichnet. Einmal mit Radius 10 und einmal mit 9.5. Wenn ich nah ran zoome ist alles ok. Wenn ich weiter weg gehe scheint der innere Zylinder durch. Vor allem gibt es hier die Probleme wie man sieht im Randbereich....

Die Auflösung meines Tiefenpuffers beträgt 32 bit.

Ich habe nun schon einiges probiert auch mit zFar/zNear, Polygonoffset... aber es wird nicht besser.


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


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 31, 2006 10:14 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
Und nochwas, die Elemente, die durchscheinen sind nur Linien. Wenn ich den inneren Zylinder komplett in schwarz und mit GL_FILL zeiche scheint nichts durch!!!


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 31, 2006 14:08 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Und wenn du denn äußeren einfärbst scheint dann immer noch was durch? Ich frag mich gerade ob die Linien nicht vielleicht überreste vom außenzylinder sein könnten. In jedem Fall ist es unschön.

Könntest du deinen Silhoutte-Zeichen-Code mal hier posten. Einerseits isses sicherlich interessant zu sehen wie du's gemacht hast, andererseits sieht man vielleicht doch noch ein Fehlerchen.

_________________
Blog: kevin-fleischer.de und fbaingermany.com


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Mi Mai 31, 2006 15:46 
Offline
DGL Member

Registriert: Di Sep 28, 2004 15:46
Beiträge: 54
So, ich habe die Zeichenprocedure mal zusammengefasst. Die ist im Orginal noch um einiges umfangreicher, da man z.B. zwischen SW und Texturdarstellung umschalten kann. Aber ich denke hier ist das wichtigste drin.

Zur groben Erklärung:
OGLZylinder berechnet die Daten des Zylinders und schreibt diese in ein selbstdefiniertes Array. OGLrund beeinflusst hierbei , ob dieser Zylinder nach her als Zylinder mit Silhouette orde als Vieleck mit allen kanten gezeichnet wird.

Das eigendliche Zeichnen läuft dann wie folgt ab:
1: Zeichnen der Flächen in Weiß um nicht sichtbare Hinterkanten zu verdecken.
2: Zeichnen der Kanten in schwarz, die auf jeden Fall sichtbar sind.
3: Zeichnen der Kanten die zur Silhouette gehören
mit:

glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glCullFace(Gl_BACK);
glPolygonMode(GL_Front, GL_Line);
glcolor3f(0, 0, 0);
gllinewidth(2 * OGLLinienStaerke);

Code:
  1.  
  2. procedure ZeichenTest;
  3.   var
  4.     i, ElementNR              : integer;
  5.     tess                      : PGLUTesselator;
  6.     Linieloc                  : tLinieDef;
  7.   begin
  8.     // Hier berechnen der Zylinder und schreiben in Elemente 3D
  9.     // procedure OGLZylinder(x, y, z, radiusU, RadiusO, H : Real;Aufl : Byte;Texturunten, Texturoben : Single);
  10.     OGLrund := true;
  11.     Oglzylinder(0, 0, -10, 20, 20, 20, 20, 0, 1);
  12.  
  13.     OGLrund := false;
  14.     Oglzylinder(0, 0, -20, 19.5, 19.5, 40, 20, 0, 1);
  15.  
  16.     //aktiviert Polygon_offset für Flächen
  17.     glEnable(GL_POLYGON_OFFSET_FILL);
  18.     //aktiviert Polygon_offset für Kanten/Linien
  19.     glEnable(GL_POLYGON_OFFSET_LINE);
  20.     //Setzt die Werte für Polygon offset
  21.     glPolygonOffset(1, 1);
  22.  
  23.     gllinewidth(OGLLinienStaerke);
  24.  
  25.     //um
  26.     glDisable(GL_TEXTURE_2D);
  27.     glDisable(GL_LIGHTING);
  28.     glDisable(GL_LIGHT0);
  29.     glEnable(GL_COLOR);
  30.     {Polygon_offset versetzt die Objetkte leicht nach hinten, damit Kanten und
  31.     Flächen, die an der gleichen Position liegen beide zu sehen sind}
  32.  
  33.     //Zeigt nur die VORDERFLÄCHEN der RECHTECKE
  34.     //Gl_Fill bewirkt das Flächen gezeichnet werden.
  35.     glPolygonMode(GL_Front_and_back, GL_FILL);
  36.  
  37.     //alternativ dazu GL_FRONT_AND_BACK zeichnet auch die Flächen die in den
  38.     //Körper zeigen
  39.  
  40.     //================================================
  41.     //Zeichnen der der Vollflächen
  42.     //================================================
  43.  
  44.     tess := gluNewTess;
  45.  
  46.     {Definnieren der Callbacks. Callbacks werden während der Tessalation aufgerufen und führen die Proceduren aus, die als
  47.     letzter Parameter übergeben wird.}
  48.     gluTessCallback(tess, GLU_TESS_BEGIN, @glBegin);
  49.     gluTessCallback(tess, GLU_TESS_VERTEX, @tessVertex);
  50.     gluTessCallback(tess, GLU_TESS_END, @glEnd);
  51.     gluTessCallback(tess, GLU_TESS_ERROR, @tcberror);
  52.     //gluTessCallback(tess, GLU_TESS_COMBINE, @tessCombine);
  53.  
  54.     // set properties
  55.     gluTessProperty(Tess, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE);
  56.     glPolygonMode(GL_Front_and_back, GL_FILL);
  57.     //If not KeineFarben then
  58.     glMatrixMode(GL_MODELVIEW);
  59.  
  60.     for ElementNr := 0 to high(Element3d) do
  61.     begin
  62.       //================================================
  63.       //Die Flächen werden Weiß gezeichnet
  64.       //================================================
  65.       GlColor3f(1, 1, 1);
  66.  
  67.       glbegin(gl_quads); //bei gl_quad_strip passt der Schattenübergang nicht!!!
  68.       //-----Seitenzeichnen-----
  69.       for i := 1 to high(Element3d[ElementNR].linie) do
  70.       begin
  71.         LinieLoc := Element3d[ElementNR].linie[i - 1];
  72.  
  73.         glNormal3f(LinieLoc.Oben.Seite.Vektor[0], LinieLoc.Oben.Seite.Vektor[1],
  74.           LinieLoc.Oben.Seite.Vektor[2]);
  75.         gltexcoord2f(LinieLoc.Oben.Seite.U, LinieLoc.Oben.Seite.V);
  76.         glvertex3f(LinieLoc.oben.Pkt[0], LinieLoc.oben.Pkt[1], LinieLoc.oben.Pkt[2]);
  77.  
  78.         gltexcoord2f(LinieLoc.Unten.Seite.U, LinieLoc.Unten.Seite.V);
  79.         glvertex3f(LinieLoc.unten.Pkt[0], LinieLoc.unten.Pkt[1], LinieLoc.unten.Pkt[2]);
  80.  
  81.         LinieLoc := Element3d[ElementNR].linie[i];
  82.  
  83.         if Element3D[ElementNr].Rund then
  84.           glNormal3f(LinieLoc.Oben.Seite.Vektor[0], LinieLoc.Oben.Seite.Vektor[1],
  85.             LinieLoc.Oben.Seite.Vektor[2]);
  86.  
  87.         gltexcoord2f(LinieLoc.Unten.Seite.U, LinieLoc.Unten.Seite.V);
  88.         glvertex3f(LinieLoc.unten.Pkt[0], LinieLoc.unten.Pkt[1], LinieLoc.unten.Pkt[2]);
  89.  
  90.         gltexcoord2f(LinieLoc.Oben.Seite.U, LinieLoc.Oben.Seite.V);
  91.         glvertex3f(LinieLoc.oben.Pkt[0], LinieLoc.oben.Pkt[1], LinieLoc.oben.Pkt[2]);
  92.       end;
  93.       glend;
  94.  
  95.       //-----DeckelZeichnen-----
  96.       gluTessBeginPolygon(tess, nil);
  97.       gluTessBeginContour(tess);
  98.       for i := 0 to high(Element3d[ElementNR].Linie) do
  99.         gluTessVertex(tess, Element3d[ElementNR].linie[i].oben.Pkt, @Element3d[ElementNR].linie[i].oben);
  100.  
  101.       gluTessEndContour(tess);
  102.       gluEndPolygon(tess);
  103.       //-----Ende DeckelZeichnen-----
  104.  
  105.         //-----Boden zeichnen-----
  106.       glNormal3f(0, -1, 0);
  107.       gluTessBeginPolygon(tess, nil);
  108.       gluTessBeginContour(tess);
  109.       for i := 0 to high(Element3d[ElementNR].Linie) do
  110.         gluTessVertex(tess, Element3d[ElementNR].linie[i].unten.Pkt, @Element3d[ElementNR].linie[i].unten);
  111.       gluTessEndContour(tess);
  112.       gluEndPolygon(tess);
  113.       //-----Ende Boden zeichnen-----
  114.  
  115.       gllinewidth(OGLLinienStaerke);
  116.       glcolor3f(0, 0, 0);
  117.  
  118.  
  119.       //================================================
  120.       //Nun werden die Kanten schwarz nachgezeichnet
  121.       //================================================
  122.       glbegin(gl_lines);
  123.       for i := 1 to high(Element3d[ElementNR].linie) do
  124.       begin //Aussenkanten von Boden und Deckel
  125.         glvertex3f(Element3d[ElementNR].linie[i - 1].unten.Pkt[0], Element3d[ElementNR].linie[i -
  126.           1].unten.Pkt[1],
  127.             Element3d[ElementNR].linie[i - 1].unten.Pkt[2]);
  128.         glvertex3f(Element3d[ElementNR].linie[i].unten.Pkt[0], Element3d[ElementNR].linie[i].unten.Pkt[1],
  129.           Element3d[ElementNR].linie[i].unten.Pkt[2]);
  130.  
  131.         glvertex3f(Element3d[ElementNR].linie[i - 1].oben.Pkt[0], Element3d[ElementNR].linie[i - 1].oben.Pkt[1],
  132.           Element3d[ElementNR].linie[i - 1].oben.Pkt[2]);
  133.         glvertex3f(Element3d[ElementNR].linie[i].oben.Pkt[0], Element3d[ElementNR].linie[i].oben.Pkt[1],
  134.           Element3d[ElementNR].linie[i].oben.Pkt[2]);
  135.       end;  //Aussenkanten von Boden und Deckel
  136.       glEnd;
  137.  
  138.       //================================================
  139.       //Seitenkanten Zeichnen  / der eigendlich interessante Teil für das Zeichnen der Siluette
  140.       //================================================
  141.       glDepthFunc(GL_LEQUAL);
  142.       glEnable(GL_CULL_FACE);
  143.       glCullFace(Gl_BACK);
  144.       glPolygonMode(GL_Front, GL_Line);
  145.       glcolor3f(0, 0, 0);
  146.       gllinewidth(2 * OGLLinienStaerke);
  147.  
  148.       glBegin(GL_QUAD_STRIP);
  149.       if Element3D[ElementNr].Rund then
  150.         for i := 0 to high(Element3d[ElementNR].linie) do
  151.         begin
  152.           glvertex3f(Element3d[ElementNR].linie[i].unten.Pkt[0], Element3d[ElementNR].linie[i].unten.Pkt[1],
  153.             Element3d[ElementNR].linie[i].unten.Pkt[2]);
  154.           glvertex3f(Element3d[ElementNR].linie[i].oben.Pkt[0], Element3d[ElementNR].linie[i].oben.Pkt[1],
  155.             Element3d[ElementNR].linie[i].oben.Pkt[2]);
  156.         end;
  157.       glEnd;
  158.  
  159.       glDisable(GL_CULL_FACE);
  160.       glPolygonMode(GL_Front_And_Back, GL_FILL);
  161.       gllinewidth(OGLLinienStaerke);
  162.  
  163.     end;
  164.     gluDeleteTess(tess); //Beendet die Tessalation
  165.   end;


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 13 Beiträge ] 
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 3 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:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.011s | 15 Queries | GZIP : On ]