OpenGL: Shape-Antialiazing produziert Fragmente

Übersicht

Sonstiges

Smalltalk

	Fetze Betreff: OpenGL: Shape-Antialiazing produziert Fragmente	Sa, Sep 01, 2007 11:05 Antworten mit Zitat
Heyho, ich arbeite zwar mit C#, allerdings sind sämtliche verwendeten Grafikbefehle aus OpenGL - abgesehen von denen aus Glfw zum initialisieren desselben -, daher denke ich, dass ihr mir trotzdem helfen könnt. Zur Sache: Ich habe bei der Programmierung eines 2D-Grafik-Frameworks Probleme mit dem OpenGL-Eigenen ShapeAntialiazing, das sich für Punkte, Linien und Polygone einzeln aktivieren lässt. Das hier ist der (zusammengeschnittene, gekürzte) Code: Code: [AUSKLAPPEN] [EINKLAPPEN] Gl.glEnable(Gl.GL_POINT_SMOOTH); Gl.glEnable(Gl.GL_LINE_SMOOTH); Gl.glEnable(Gl.GL_POLYGON_SMOOTH); Als BlendMode verwende ich die aus BlitzMax bekannten Konfigurationen "LightBlend" und "AlphaBlend". Mein Code zum Setzen dieser: Code: [AUSKLAPPEN] [EINKLAPPEN] // AlphaBlend Gl.glEnable(Gl.GL_BLEND); Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA); Gl.glDisable(Gl.GL_ALPHA_TEST); Code: [AUSKLAPPEN] [EINKLAPPEN] // LightBlend Gl.glEnable(Gl.GL_BLEND); Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE); Gl.glDisable(Gl.GL_ALPHA_TEST); An sich funktioniert das ganze wunderbar - das Problem: An den Rändern einzelner Dreiecke sind deutliche Fragmente zu erkennen. Hier die Resultate in zweifacher Vergrößerung: LightBlend: AlphaBlend: Wo könnte der Fehler liegen? Wie kommen solche Fragmente zustande? An Grafikkarte oder Treiber liegt es wohl eher nicht, da das ganze zuvor irgendwann auch mal funktioniert hat, in einem weitaus einfacheren Testprogramm. Aufgrund der Masse an Änderungen, die ich seitdem ohne AntiAlias-Test vorgenommen habe und dem Mangel an Backups ist es mir jedoch nicht mehr möglich, herauszufinden, welche Änderung dieses Ogl-Verhalten verursacht hat. Technische Eckdaten: Windows XP SP2 Nvidia Geforce 6800 GT Depthbuffer aktiv 32 Bit Grafiktiefe 1280 x 1024, allerdings ist der Effekt auflösungsunabhängig Fensterodus / Vollbild hat ebenfalls keine Auswirkungen

Fetze

Betreff: OpenGL: Shape-Antialiazing produziert Fragmente

Sa, Sep 01, 2007 11:05
Antworten mit Zitat

Heyho,

ich arbeite zwar mit C#, allerdings sind sämtliche verwendeten Grafikbefehle aus OpenGL - abgesehen von denen aus Glfw zum initialisieren desselben -, daher denke ich, dass ihr mir trotzdem helfen könnt.

Zur Sache: Ich habe bei der Programmierung eines 2D-Grafik-Frameworks Probleme mit dem OpenGL-Eigenen ShapeAntialiazing, das sich für Punkte, Linien und Polygone einzeln aktivieren lässt.

Das hier ist der (zusammengeschnittene, gekürzte) Code:
Code: [AUSKLAPPEN]

Gl.glEnable(Gl.GL_POINT_SMOOTH);
Gl.glEnable(Gl.GL_LINE_SMOOTH);
Gl.glEnable(Gl.GL_POLYGON_SMOOTH);

Als BlendMode verwende ich die aus BlitzMax bekannten Konfigurationen "LightBlend" und "AlphaBlend". Mein Code zum Setzen dieser:
Code: [AUSKLAPPEN]

// AlphaBlend
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
Gl.glDisable(Gl.GL_ALPHA_TEST);

Code: [AUSKLAPPEN]

// LightBlend
Gl.glEnable(Gl.GL_BLEND);
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE);
Gl.glDisable(Gl.GL_ALPHA_TEST);

An sich funktioniert das ganze wunderbar - das Problem: An den Rändern einzelner Dreiecke sind deutliche Fragmente zu erkennen. Hier die Resultate in zweifacher Vergrößerung:

LightBlend:
user posted image

AlphaBlend:
user posted image

Wo könnte der Fehler liegen? Wie kommen solche Fragmente zustande? An Grafikkarte oder Treiber liegt es wohl eher nicht, da das ganze zuvor irgendwann auch mal funktioniert hat, in einem weitaus einfacheren Testprogramm. Aufgrund der Masse an Änderungen, die ich seitdem ohne AntiAlias-Test vorgenommen habe und dem Mangel an Backups ist es mir jedoch nicht mehr möglich, herauszufinden, welche Änderung dieses Ogl-Verhalten verursacht hat.

Technische Eckdaten:
Windows XP SP2
Nvidia Geforce 6800 GT
Depthbuffer aktiv
32 Bit Grafiktiefe
1280 x 1024, allerdings ist der Effekt auflösungsunabhängig
Fensterodus / Vollbild hat ebenfalls keine Auswirkungen

	Dreamora	Sa, Sep 01, 2007 11:46 Antworten mit Zitat
moved da falsches Forum.
Ihr findet die aktuellen Projekte unter Gayasoft und könnt mich unter @gayasoft auf Twitter erreichen.

Dreamora

Sa, Sep 01, 2007 11:46
Antworten mit Zitat

moved da falsches Forum.

Ihr findet die aktuellen Projekte unter Gayasoft und könnt mich unter @gayasoft auf Twitter erreichen.

	Vertex	Sa, Sep 01, 2007 15:28 Antworten mit Zitat
Wie wärs gleich mit Multisampling? Ansonsten habe ich so das Gefühl, das du Edges dafür definieren musst. So das nur die angegebenen Kanten dafür gesmoothed werden. mfg olli
vertex.dreamfall.at \| GitHub

Vertex

Sa, Sep 01, 2007 15:28
Antworten mit Zitat

Wie wärs gleich mit Multisampling?

Ansonsten habe ich so das Gefühl, das du Edges dafür definieren musst. So das nur die angegebenen Kanten dafür gesmoothed werden.

mfg olli

vertex.dreamfall.at | GitHub

	Fetze	Sa, Sep 01, 2007 16:28 Antworten mit Zitat
Nun, Multisampling fällt aus dem Grund weg, da ich das Tao Framework für .Net / C# verwende, worüber ich wiederum auf Glfw zugreife, das für mich plattformunabhängig ein Fenster samt RenderingContext und Co initialisiert. Das Problem daran: Für Multisampling brauche ich einen Multisamplingbuffer, den ich allerdings genau dort mitinitialisieren müsste; die Möglichkeit dafür existiert jedoch erst seit der allerneuesten Glfw-Version, welche es noch nicht ins Tao Framework geschafft hat. Ergo kann ich nicht aufs OpenGL-Eigene Multsampling zurückgreifen.. Wie definiere ich diese "Edges", von denen du sprachst? Kann ich die auch automatisch feststellen lassen? Sollte es dort Probleme geben, gäbe es vielleicht noch die Möglichkeit, die Szene in doppelter Größe auf eine Textur zu rendern und diese wiederum auf Bildschirm- / Viewport- / Scissors-größe zu skalieren und zu zeichnen.. was ist davon zu halten? Wie sähe das mit der Performance aus und welche möglichen Nachteile hätte es?

Fetze

Sa, Sep 01, 2007 16:28
Antworten mit Zitat

Nun, Multisampling fällt aus dem Grund weg, da ich das Tao Framework für .Net / C# verwende, worüber ich wiederum auf Glfw zugreife, das für mich plattformunabhängig ein Fenster samt RenderingContext und Co initialisiert. Das Problem daran: Für Multisampling brauche ich einen Multisamplingbuffer, den ich allerdings genau dort mitinitialisieren müsste; die Möglichkeit dafür existiert jedoch erst seit der allerneuesten Glfw-Version, welche es noch nicht ins Tao Framework geschafft hat.
Ergo kann ich nicht aufs OpenGL-Eigene Multsampling zurückgreifen..

Wie definiere ich diese "Edges", von denen du sprachst? Kann ich die auch automatisch feststellen lassen?

Sollte es dort Probleme geben, gäbe es vielleicht noch die Möglichkeit, die Szene in doppelter Größe auf eine Textur zu rendern und diese wiederum auf Bildschirm- / Viewport- / Scissors-größe zu skalieren und zu zeichnen.. was ist davon zu halten? Wie sähe das mit der Performance aus und welche möglichen Nachteile hätte es?

	Vertex	Sa, Sep 01, 2007 16:55 Antworten mit Zitat
Also ich kenns für Windows über wglChoosePixelFormatARB und den dazugehörigen Parametern WGL_SAMPLE_BUFFERS_ARB (=GL_TRUE) sowie WGL_SAMPLES_ARB(2x = 2, 4x = 4, 8x = 8, 16x = 16) Meinste nicht, dass di GLFW im Sourcecode so verändern kannst, dass du das ganze über wglChoosePixelFormatARB statts wglChoosePixelFormat machen kannst? Diese Edges definierst du über glEdgeFlag Multisampling über eine textur zu lösen ginge sicher auch. Dazu muss aber die Grafikkarte rechteckige texturen unterstützen(ist glaube erst ab OpenGL 2.0 möglich) mfg olli
vertex.dreamfall.at \| GitHub

Vertex

Sa, Sep 01, 2007 16:55
Antworten mit Zitat

Also ich kenns für Windows über wglChoosePixelFormatARB und den dazugehörigen Parametern WGL_SAMPLE_BUFFERS_ARB (=GL_TRUE) sowie WGL_SAMPLES_ARB(2x = 2, 4x = 4, 8x = 8, 16x = 16)

Meinste nicht, dass di GLFW im Sourcecode so verändern kannst, dass du das ganze über wglChoosePixelFormatARB statts wglChoosePixelFormat machen kannst?

Diese Edges definierst du über glEdgeFlag

Multisampling über eine textur zu lösen ginge sicher auch. Dazu muss aber die Grafikkarte rechteckige texturen unterstützen(ist glaube erst ab OpenGL 2.0 möglich)

mfg olli

vertex.dreamfall.at | GitHub

	Fetze	Sa, Sep 01, 2007 17:17 Antworten mit Zitat
Hm.. nungut, werde dann wohl über Fullscreen-AntiAliazing gehen müssen... Zitat: Das EdgeFlag wirkt sich nur aus, wenn GL_POLYGONE_MODE auf GL_POINT oder GL_LINE gesetzt ist. (siehe glPolygonMode) sagt die Wiki. :/ Außerdem ist mir aufgefallen, dass der Nutzer bei Polygonen dann selbst die Edgeflags setzen müsste, was ich niemandem inklusive mir zumuten will. Zitat: Also ich kenns für Windows über wglChoosePixelFormatARB und den dazugehörigen Parametern WGL_SAMPLE_BUFFERS_ARB (=GL_TRUE) sowie WGL_SAMPLES_ARB(2x = 2, 4x = 4, 8x = 8, 16x = 16) Meinste nicht, dass di GLFW im Sourcecode so verändern kannst, dass du das ganze über wglChoosePixelFormatARB statts wglChoosePixelFormat machen kannst? Nun, ich wähle nirgendwo ein Pixelformat, ich initialisiere nirgendwo irgendwas. Glfw übernimmt die gesamte Initialisierung, das ist der gesamte grafikbezogene Initcode meinerseits: Code: [AUSKLAPPEN] [EINKLAPPEN] #region Init graphics window int windowMode = isWindowed ? Glfw.GLFW_WINDOW : Glfw.GLFW_FULLSCREEN; int windowOpen = Glfw.glfwOpenWindow( gfxWidth, gfxHeight, redBits, greenBits, blueBits, alphaBits, 32, 0, windowMode); if (windowOpen == 0) { throw new ApplicationException("Can't initialize graphics window"); } #endregion Init graphics window (32 --> DepthBits, 0 --> StencilBits, windowMode --> Fullscreen / Window) Ich kann zwar einige Zusatzparameter festlegen - jedoch ist der MultisampleBuffer erst ab Glfw 2.6 dabei, während Tao bei Glfw 2.5 ist. Das Umschreiben und selbst-updaten habe ich auch bereits in Erwägung gezogen. Das Problem daran ist, dass ich keine Ahnung hab, wie ich das Tao Framework kompiliere.. ôo

Fetze

Sa, Sep 01, 2007 17:17
Antworten mit Zitat

Hm.. nungut, werde dann wohl über Fullscreen-AntiAliazing gehen müssen...

Zitat:

Das EdgeFlag wirkt sich nur aus, wenn GL_POLYGONE_MODE auf GL_POINT oder GL_LINE gesetzt ist. (siehe glPolygonMode)

sagt die Wiki. :/
Außerdem ist mir aufgefallen, dass der Nutzer bei Polygonen dann selbst die Edgeflags setzen müsste, was ich niemandem inklusive mir zumuten will.

Zitat:

Nun, ich wähle nirgendwo ein Pixelformat, ich initialisiere nirgendwo irgendwas. Glfw übernimmt die gesamte Initialisierung, das ist der gesamte grafikbezogene Initcode meinerseits:
Code: [AUSKLAPPEN]

#region Init graphics window
int windowMode = isWindowed ? Glfw.GLFW_WINDOW : Glfw.GLFW_FULLSCREEN;
int windowOpen =
Glfw.glfwOpenWindow( gfxWidth,
                  gfxHeight,
                  redBits,
                  greenBits,
                  blueBits,
                  alphaBits,
                  32,
                  0,
                  windowMode);
if (windowOpen == 0) { throw new ApplicationException("Can't initialize graphics window"); }
#endregion Init graphics window

(32 --> DepthBits, 0 --> StencilBits, windowMode --> Fullscreen / Window)

Ich kann zwar einige Zusatzparameter festlegen - jedoch ist der MultisampleBuffer erst ab Glfw 2.6 dabei, während Tao bei Glfw 2.5 ist.
Das Umschreiben und selbst-updaten habe ich auch bereits in Erwägung gezogen. Das Problem daran ist, dass ich keine Ahnung hab, wie ich das Tao Framework kompiliere.. ôo

	Vertex	Sa, Sep 01, 2007 19:11 Antworten mit Zitat
Ich habe hier ein Beispiel in BlitzMax, was aber nicht funktioniert Code: [AUSKLAPPEN] [EINKLAPPEN] SuperStrict Framework BRL.Blitz Import BRL.GLGraphics Const NUM_SIDES : Int = 6 Global Index : Int GLGraphics(640, 480, 0, 60, GRAPHICS_BACKBUFFER \| .. GRAPHICS_ALPHABUFFER \| .. GRAPHICS_DEPTHBUFFER) glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0.0, 640.0, 480.0, 0.0, -1.0, 1.0) glCullFace(GL_BACK) glEnable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE) glEnable(GL_POINT_SMOOTH) glEnable(GL_LINE_SMOOTH) glEnable(GL_POLYGON_SMOOTH) While Not KeyDown(KEY_ESCAPE) If KeyDown(KEY_W) Then glPolygonMode(GL_FRONT, GL_LINE) Else glPolygonMode(GL_FRONT, GL_FILL) EndIf glClear(GL_COLOR_BUFFER_BIT \| .. GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) glLoadIdentity() glBegin(GL_TRIANGLES) For Index = 0 To NUM_SIDES glColor3f(Float(Index)/Float(NUM_SIDES)0.5 + 0.5, .. Float(Index)/Float(NUM_SIDES)0.5 + 0.5, .. Float(Index)/Float(NUM_SIDES)0.5 + 0.5) glEdgeFlag(True) glVertex2f(Cos(360.0/Float(NUM_SIDES)Float(Index + 1))200.0 + 320.0, .. Sin(360.0/Float(NUM_SIDES)Float(Index + 1))200.0 + 240.0) glEdgeFlag(False) glVertex2f(Cos( 360.0/Float(NUM_SIDES)Float(Index))200.0 + 320.0, .. Sin(360.0/Float(NUM_SIDES)Float(Index))200.0 + 240.0) glEdgeFlag(False) glVertex2f(320.0, 240.0) Next glEnd() Flip() Wend GCCollect() End Wenn man die W Taste drückt, werden nur die Outlines des Polygons gernedert. Diese sind auch geglättet. Im gefüllten Modus jedoch ist kein Antialising aktiv - warum auch immer oO Achja, es gäbe da noch das Jittern. Ich würde dabei folgendes machen: Die Originalszene X, Y geht mit 2/6 in den Accum Y + 1 mit 1/6 Y - 1 mit 1/6 X + 1 mit 1/6 X - 1 mit 1/6 Das ist eine Mittelwertbildung mit doppeltem Gewicht auf den Originalpixel: Code:* [AUSKLAPPEN] [EINKLAPPEN] +---+---+---+ O(Oben) 1/6 \| \| O \| \| + U(Unten) 1/6 +---+---+---+ + L(Links) 1/6 \| L \| M \| R \| + R(Rechts) 1/6 +---+---+---+ + M(Mitte) 2/6 \| \| U \| \| --------------- +---+---+---+ 6/6 Vllt. mache ich dir mal ein Beispiel dazu. Damit kannst du übrigens auch Multisampling berechnen. Statts mit bspw. doppelter Auflösung zu rendern, renderst du die Szene in 4 verschied. Positionen jeweils um ein Fragment versetzt. mfg olli Edit: Hier das ganze über Jittering: Code: [AUSKLAPPEN] [EINKLAPPEN] SuperStrict Framework BRL.Blitz Import BRL.GLGraphics Const NUM_SIDES : Int = 6 Global Index : Int GLGraphics(640, 480, 0, 60, GRAPHICS_BACKBUFFER \| .. GRAPHICS_ACCUMBUFFER \| .. GRAPHICS_DEPTHBUFFER) glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0.0, 640.0, 480.0, 0.0, -1.0, 1.0) glEnable(GL_DEPTH) While Not KeyDown(KEY_ESCAPE) If KeyDown(KEY_W) Then glPolygonMode(GL_FRONT, GL_LINE) Else glPolygonMode(GL_FRONT, GL_FILL) EndIf glClear(GL_ACCUM_BUFFER_BIT) ' Szene in 5 Pässen rendern For Local Pass:Int = 0 To 4 glClear(GL_COLOR_BUFFER_BIT \| .. GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) glLoadIdentity() Select Pass Case 0 ; glTranslatef( 0.0, 1.0, 0.0) Case 1 ; glTranslatef( 0.0, -1.0, 0.0) Case 2 ; glTranslatef( 1.0, 0.0, 0.0) Case 3 ; glTranslatef(-1.0, 0.0, 0.0) Case 4 ; glTranslatef( 0.0, 0.0, 0.0) End Select RenderPolygon() Select Pass Case 0 ; glAccum(GL_ACCUM, 1.0/6.0) Case 1 ; glAccum(GL_ACCUM, 1.0/6.0) Case 2 ; glAccum(GL_ACCUM, 1.0/6.0) Case 3 ; glAccum(GL_ACCUM, 1.0/6.0) Case 4 ; glAccum(GL_ACCUM, 2.0/6.0) End Select Next glAccum(GL_RETURN, 1.0) Flip() Wend Function RenderPolygon() glBegin(GL_TRIANGLES) For Index = 0 To NUM_SIDES glColor3f(Float(Index)/Float(NUM_SIDES)0.5 + 0.5, .. Float(Index)/Float(NUM_SIDES)0.5 + 0.5, .. Float(Index)/Float(NUM_SIDES)0.5 + 0.5) glVertex2f(Cos(360.0/Float(NUM_SIDES)Float(Index + 1))200.0 + 320.0, .. Sin(360.0/Float(NUM_SIDES)Float(Index + 1))200.0 + 240.0) glVertex2f(Cos( 360.0/Float(NUM_SIDES)Float(Index))200.0 + 320.0, .. Sin(360.0/Float(NUM_SIDES)Float(Index))*200.0 + 240.0) glVertex2f(320.0, 240.0) Next glEnd() End Function GCCollect() End Über glPushMatrix und glPopMatrix brauchst du dir nicht einmal Gedanken über die Matrixverwaltung zu machen. mfg olli
vertex.dreamfall.at \| GitHub

Vertex

Sa, Sep 01, 2007 19:11
Antworten mit Zitat

Ich habe hier ein Beispiel in BlitzMax, was aber nicht funktioniert Razz

Code: [AUSKLAPPEN]

SuperStrict

Framework BRL.Blitz
Import BRL.GLGraphics

Const NUM_SIDES : Int = 6

Global Index : Int

GLGraphics(640, 480, 0, 60, GRAPHICS_BACKBUFFER | ..
GRAPHICS_ALPHABUFFER | ..
GRAPHICS_DEPTHBUFFER)

glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0.0, 640.0, 480.0, 0.0, -1.0, 1.0)

glCullFace(GL_BACK)
glEnable(GL_CULL_FACE)

glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE)

glEnable(GL_POINT_SMOOTH)
glEnable(GL_LINE_SMOOTH)
glEnable(GL_POLYGON_SMOOTH)

While Not KeyDown(KEY_ESCAPE)
If KeyDown(KEY_W) Then
   glPolygonMode(GL_FRONT, GL_LINE)
Else
   glPolygonMode(GL_FRONT, GL_FILL)
EndIf

glClear(GL_COLOR_BUFFER_BIT | ..
   GL_DEPTH_BUFFER_BIT)

glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glBegin(GL_TRIANGLES)
   For Index = 0 To NUM_SIDES
      glColor3f(Float(Index)/Float(NUM_SIDES)*0.5 + 0.5, ..
         Float(Index)/Float(NUM_SIDES)*0.5 + 0.5, ..
         Float(Index)/Float(NUM_SIDES)*0.5 + 0.5)

      glEdgeFlag(True)
      glVertex2f(Cos(360.0/Float(NUM_SIDES)*Float(Index + 1))*200.0 + 320.0, ..
         Sin(360.0/Float(NUM_SIDES)*Float(Index + 1))*200.0 + 240.0)

      glEdgeFlag(False)
      glVertex2f(Cos( 360.0/Float(NUM_SIDES)*Float(Index))*200.0 + 320.0, ..
         Sin(360.0/Float(NUM_SIDES)*Float(Index))*200.0 + 240.0)

      glEdgeFlag(False)
      glVertex2f(320.0, 240.0)
   Next
glEnd()

Flip()
Wend

GCCollect()
End

Wenn man die W Taste drückt, werden nur die Outlines des Polygons gernedert. Diese sind auch geglättet. Im gefüllten Modus jedoch ist kein Antialising aktiv - warum auch immer oO

Achja, es gäbe da noch das Jittern. Ich würde dabei folgendes machen:
Die Originalszene X, Y geht mit 2/6 in den Accum
Y + 1 mit 1/6
Y - 1 mit 1/6
X + 1 mit 1/6
X - 1 mit 1/6

Das ist eine Mittelwertbildung mit doppeltem Gewicht auf den Originalpixel:
Code: [AUSKLAPPEN]

+---+---+---+ O(Oben) 1/6
| | O | | + U(Unten) 1/6
+---+---+---+ + L(Links) 1/6
| L | M | R | + R(Rechts) 1/6
+---+---+---+ + M(Mitte) 2/6
| | U | | ---------------
+---+---+---+ 6/6

Vllt. mache ich dir mal ein Beispiel dazu. Damit kannst du übrigens auch Multisampling berechnen. Statts mit bspw. doppelter Auflösung zu rendern, renderst du die Szene in 4 verschied. Positionen jeweils um ein Fragment versetzt.

mfg olli

Edit:
Hier das ganze über Jittering:
Code: [AUSKLAPPEN]

SuperStrict

Framework BRL.Blitz
Import BRL.GLGraphics

Const NUM_SIDES : Int = 6

Global Index : Int

GLGraphics(640, 480, 0, 60, GRAPHICS_BACKBUFFER | ..
GRAPHICS_ACCUMBUFFER | ..
GRAPHICS_DEPTHBUFFER)

glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0.0, 640.0, 480.0, 0.0, -1.0, 1.0)

glEnable(GL_DEPTH)

While Not KeyDown(KEY_ESCAPE)
If KeyDown(KEY_W) Then
   glPolygonMode(GL_FRONT, GL_LINE)
Else
   glPolygonMode(GL_FRONT, GL_FILL)
EndIf

glClear(GL_ACCUM_BUFFER_BIT)

' Szene in 5 Pässen rendern
For Local Pass:Int = 0 To 4
   glClear(GL_COLOR_BUFFER_BIT | ..
      GL_DEPTH_BUFFER_BIT)

   glMatrixMode(GL_MODELVIEW)
   glLoadIdentity()
   Select Pass
      Case 0 ; glTranslatef( 0.0, 1.0, 0.0)
      Case 1 ; glTranslatef( 0.0, -1.0, 0.0)
      Case 2 ; glTranslatef( 1.0, 0.0, 0.0)
      Case 3 ; glTranslatef(-1.0, 0.0, 0.0)
      Case 4 ; glTranslatef( 0.0, 0.0, 0.0)
   End Select
   RenderPolygon()
   Select Pass
      Case 0 ; glAccum(GL_ACCUM, 1.0/6.0)
      Case 1 ; glAccum(GL_ACCUM, 1.0/6.0)
      Case 2 ; glAccum(GL_ACCUM, 1.0/6.0)
      Case 3 ; glAccum(GL_ACCUM, 1.0/6.0)
      Case 4 ; glAccum(GL_ACCUM, 2.0/6.0)
   End Select
Next
glAccum(GL_RETURN, 1.0)

Flip()
Wend

Function RenderPolygon()
glBegin(GL_TRIANGLES)
   For Index = 0 To NUM_SIDES
      glColor3f(Float(Index)/Float(NUM_SIDES)*0.5 + 0.5, ..
         Float(Index)/Float(NUM_SIDES)*0.5 + 0.5, ..
         Float(Index)/Float(NUM_SIDES)*0.5 + 0.5)

      glVertex2f(Cos(360.0/Float(NUM_SIDES)*Float(Index + 1))*200.0 + 320.0, ..
         Sin(360.0/Float(NUM_SIDES)*Float(Index + 1))*200.0 + 240.0)

      glVertex2f(Cos( 360.0/Float(NUM_SIDES)*Float(Index))*200.0 + 320.0, ..
         Sin(360.0/Float(NUM_SIDES)*Float(Index))*200.0 + 240.0)

      glVertex2f(320.0, 240.0)
   Next
glEnd()
End Function

GCCollect()
End

Über glPushMatrix und glPopMatrix brauchst du dir nicht einmal Gedanken über die Matrixverwaltung zu machen.

mfg olli

vertex.dreamfall.at | GitHub

	Fetze	So, Sep 02, 2007 0:32 Antworten mit Zitat
Uff.. aber die Szene insgesamt 5 Mal rendern? Also quasi fünf mal so viel Grafikkartenlast? Und zudem: Den Accumbuffer dafür verwenden? Den wollte ich mir für Lichteffekte offen halten.. ôo Außerdem wirft Jittering generell das Problem auf: Auch die Texturen werden entsprechend "geblurred", was dem Konzept der pixelgenauen Grafik, das ich verfolge, entgegen arbeitet. Jittering fällt dann also doch eher weg.. dann muss ich wohl doch auf Multisampling zurückgreifen.. bzw. wohl oder übel abwarten, bis das Tao-Framework geupdated wird Trotzdem danke für Erklärung und Beispiele!

Fetze

So, Sep 02, 2007 0:32
Antworten mit Zitat

Uff.. aber die Szene insgesamt 5 Mal rendern? Also quasi fünf mal so viel Grafikkartenlast? Und zudem: Den Accumbuffer dafür verwenden? Den wollte ich mir für Lichteffekte offen halten.. ôo

Außerdem wirft Jittering generell das Problem auf: Auch die Texturen werden entsprechend "geblurred", was dem Konzept der pixelgenauen Grafik, das ich verfolge, entgegen arbeitet. Jittering fällt dann also doch eher weg.. dann muss ich wohl doch auf Multisampling zurückgreifen.. bzw. wohl oder übel abwarten, bis das Tao-Framework geupdated wird Confused

Trotzdem danke für Erklärung und Beispiele!

	Vertex	So, Sep 02, 2007 11:19 Antworten mit Zitat
Beim Multisampling wird die Szene ebenfalls mehrfach gerendert, es entfallen bloß die zusätzlichen Transformationen weg. Jetzt weiß ich gar nicht, ob ich mich hier mit Supersampling und Multisampling vertan habe. Eines der beiden filtert erst wenn die Tiefenunterschiede bei den einbezogenen Samples einen gewissen Schwellenwert überschreiten. So wird bevoorzugt nur die Außenkanten einem Antialiasing unterzogen. Bei dem anderen Verfahren dürfte auch die Textur mit geblurred werden. Schau dir dazu einfach mal den Artikel an, den ich mir jetzt auch mal reinziehen werde: http://www.3dcenter.org/artike.../index.php Und zu Tao: /source/src/Tao.Gflw/Gflw.cs ab Zeile 937 Code: [AUSKLAPPEN] [EINKLAPPEN] #region glfwGetWindowParam Tokens #region GLFW_OPENED /// <summary> /// <see cref="Gl.GL_TRUE" /> if window is opened, else <see cref="Gl.GL_FALSE" />. /// </summary> // #define GLFW_OPENED 0x00020001 public const int GLFW_OPENED = 0x00020001; #endregion GLFW_OPENED #region GLFW_ACTIVE /// <summary> /// <see cref="Gl.GL_TRUE" /> if window has focus, else <see cref="Gl.GL_FALSE" />. /// </summary> // #define GLFW_ACTIVE 0x00020002 public const int GLFW_ACTIVE = 0x00020002; #endregion GLFW_ACTIVE #region GLFW_ICONIFIED /// <summary> /// <see cref="Gl.GL_TRUE" /> if window is iconified, else <see cref="Gl.GL_FALSE" />. /// </summary> // #define GLFW_ICONIFIED 0x00020003 public const int GLFW_ICONIFIED = 0x00020003; #endregion GLFW_ICONIFIED #region GLFW_ACCELERATED /// <summary> /// <see cref="Gl.GL_TRUE" /> if window is hardware accelerated, else /// <see cref="Gl.GL_FALSE" />. /// </summary> // #define GLFW_ACCELERATED 0x00020004 public const int GLFW_ACCELERATED = 0x00020004; #endregion GLFW_ACCELERATED #region GLFW_RED_BITS /// <summary> /// Number of bits for the red color component. /// </summary> // #define GLFW_RED_BITS 0x00020005 public const int GLFW_RED_BITS = 0x00020005; #endregion GLFW_RED_BITS #region GLFW_GREEN_BITS /// <summary> /// Number of bits for the green color component. /// </summary> // #define GLFW_GREEN_BITS 0x00020006 public const int GLFW_GREEN_BITS = 0x00020006; #endregion GLFW_GREEN_BITS #region GLFW_BLUE_BITS /// <summary> /// Number of bits for the blue color component. /// </summary> // #define GLFW_BLUE_BITS 0x00020007 public const int GLFW_BLUE_BITS = 0x00020007; #endregion GLFW_BLUE_BITS #region GLFW_ALPHA_BITS /// <summary> /// Number of bits for the alpha buffer. /// </summary> // #define GLFW_ALPHA_BITS 0x00020008 public const int GLFW_ALPHA_BITS = 0x00020008; #endregion GLFW_ALPHA_BITS #region GLFW_DEPTH_BITS /// <summary> /// Number of bits for the depth buffer. /// </summary> // #define GLFW_DEPTH_BITS 0x00020009 public const int GLFW_DEPTH_BITS = 0x00020009; #endregion GLFW_DEPTH_BITS #region GLFW_STENCIL_BITS /// <summary> /// Number of bits for the stencil buffer. /// </summary> // #define GLFW_STENCIL_BITS 0x0002000A public const int GLFW_STENCIL_BITS = 0x0002000A; #endregion GLFW_STENCIL_BITS #endregion glfwGetWindowParam Tokens #region glfwGetWindowParam/glfwOpenWindowHint Tokens #region GLFW_REFRESH_RATE /// <summary> /// Vertical monitor refresh rate in Hz (only used for fullscreen windows). Zero /// means system default. /// </summary> // #define GLFW_REFRESH_RATE 0x0002000B public const int GLFW_REFRESH_RATE = 0x0002000B; #endregion GLFW_REFRESH_RATE #region GLFW_ACCUM_RED_BITS /// <summary> /// Number of bits for the red channel of the accumulator buffer. /// </summary> // #define GLFW_ACCUM_RED_BITS 0x0002000C public const int GLFW_ACCUM_RED_BITS = 0x0002000C; #endregion GLFW_ACCUM_RED_BITS #region GLFW_ACCUM_GREEN_BITS /// <summary> /// Number of bits for the green channel of the accumulator buffer. /// </summary> // #define GLFW_ACCUM_GREEN_BITS 0x0002000D public const int GLFW_ACCUM_GREEN_BITS = 0x0002000D; #endregion GLFW_ACCUM_GREEN_BITS #region GLFW_ACCUM_BLUE_BITS /// <summary> /// Number of bits for the blue channel of the accumulator buffer. /// </summary> // #define GLFW_ACCUM_BLUE_BITS 0x0002000E public const int GLFW_ACCUM_BLUE_BITS = 0x0002000E; #endregion GLFW_ACCUM_BLUE_BITS #region GLFW_ACCUM_ALPHA_BITS /// <summary> /// Number of bits for the alpha channel of the accumulator buffer. /// </summary> // #define GLFW_ACCUM_ALPHA_BITS 0x0002000F public const int GLFW_ACCUM_ALPHA_BITS = 0x0002000F; #endregion GLFW_ACCUM_ALPHA_BITS #region GLFW_AUX_BUFFERS /// <summary> /// Number of auxiliary buffers. /// </summary> // #define GLFW_AUX_BUFFERS 0x00020010 public const int GLFW_AUX_BUFFERS = 0x00020010; #endregion GLFW_AUX_BUFFERS #region GLFW_STEREO /// <summary> /// Specify if stereo rendering should be supported (can be <see cref="Gl.GL_TRUE" /> /// or <see cref="Gl.GL_FALSE" />). /// </summary> // #define GLFW_STEREO 0x00020011 public const int GLFW_STEREO = 0x00020011; #endregion GLFW_STEREO #region GLFW_WINDOW_NO_RESIZE /// <summary> /// Specify if window cannot be resized (can be <see cref="Gl.GL_TRUE" /> /// or <see cref="Gl.GL_FALSE" />). /// </summary> // #define GLFW_WINDOW_NO_RESIZE 0x00020012 public const int GLFW_WINDOW_NO_RESIZE = 0x00020012; #endregion GLFW_WINDOW_NO_RESIZE #region GLFW_FSAA_SAMPLES /// <summary> /// Number of multisampling buffer samples. Zero indicated multisampling /// is disabled. /// </summary> // #define GLFW_FSAA_SAMPLES 0x00020013 public const int GLFW_FSAA_SAMPLES = 0x00020013; #endregion GLFW_FSAA_SAMPLES #endregion glfwGetWindowParam/glfwOpenWindowHint Tokens Ein Versuch ist es ja Wert mfg olli[/code]
vertex.dreamfall.at \| GitHub

Vertex

So, Sep 02, 2007 11:19
Antworten mit Zitat

Beim Multisampling wird die Szene ebenfalls mehrfach gerendert, es entfallen bloß die zusätzlichen Transformationen weg.

Jetzt weiß ich gar nicht, ob ich mich hier mit Supersampling und Multisampling vertan habe. Eines der beiden filtert erst wenn die Tiefenunterschiede bei den einbezogenen Samples einen gewissen Schwellenwert überschreiten. So wird bevoorzugt nur die Außenkanten einem Antialiasing unterzogen. Bei dem anderen Verfahren dürfte auch die Textur mit geblurred werden.

Schau dir dazu einfach mal den Artikel an, den ich mir jetzt auch mal reinziehen werde:
http://www.3dcenter.org/artike.../index.php

Und zu Tao:
/source/src/Tao.Gflw/Gflw.cs ab Zeile 937

Code: [AUSKLAPPEN]

#region glfwGetWindowParam Tokens
#region GLFW_OPENED
/// <summary>
/// <see cref="Gl.GL_TRUE" /> if window is opened, else <see cref="Gl.GL_FALSE" />.
/// </summary>
// #define GLFW_OPENED 0x00020001
public const int GLFW_OPENED = 0x00020001;
#endregion GLFW_OPENED

#region GLFW_ACTIVE
/// <summary>
/// <see cref="Gl.GL_TRUE" /> if window has focus, else <see cref="Gl.GL_FALSE" />.
/// </summary>
// #define GLFW_ACTIVE 0x00020002
public const int GLFW_ACTIVE = 0x00020002;
#endregion GLFW_ACTIVE

#region GLFW_ICONIFIED
/// <summary>
/// <see cref="Gl.GL_TRUE" /> if window is iconified, else <see cref="Gl.GL_FALSE" />.
/// </summary>
// #define GLFW_ICONIFIED 0x00020003
public const int GLFW_ICONIFIED = 0x00020003;
#endregion GLFW_ICONIFIED

#region GLFW_ACCELERATED
/// <summary>
/// <see cref="Gl.GL_TRUE" /> if window is hardware accelerated, else
/// <see cref="Gl.GL_FALSE" />.
/// </summary>
// #define GLFW_ACCELERATED 0x00020004
public const int GLFW_ACCELERATED = 0x00020004;
#endregion GLFW_ACCELERATED

#region GLFW_RED_BITS
/// <summary>
/// Number of bits for the red color component.
/// </summary>
// #define GLFW_RED_BITS 0x00020005
public const int GLFW_RED_BITS = 0x00020005;
#endregion GLFW_RED_BITS

#region GLFW_GREEN_BITS
/// <summary>
/// Number of bits for the green color component.
/// </summary>
// #define GLFW_GREEN_BITS 0x00020006
public const int GLFW_GREEN_BITS = 0x00020006;
#endregion GLFW_GREEN_BITS

#region GLFW_BLUE_BITS
/// <summary>
/// Number of bits for the blue color component.
/// </summary>
// #define GLFW_BLUE_BITS 0x00020007
public const int GLFW_BLUE_BITS = 0x00020007;
#endregion GLFW_BLUE_BITS

#region GLFW_ALPHA_BITS
/// <summary>
/// Number of bits for the alpha buffer.
/// </summary>
// #define GLFW_ALPHA_BITS 0x00020008
public const int GLFW_ALPHA_BITS = 0x00020008;
#endregion GLFW_ALPHA_BITS

#region GLFW_DEPTH_BITS
/// <summary>
/// Number of bits for the depth buffer.
/// </summary>
// #define GLFW_DEPTH_BITS 0x00020009
public const int GLFW_DEPTH_BITS = 0x00020009;
#endregion GLFW_DEPTH_BITS

#region GLFW_STENCIL_BITS
/// <summary>
/// Number of bits for the stencil buffer.
/// </summary>
// #define GLFW_STENCIL_BITS 0x0002000A
public const int GLFW_STENCIL_BITS = 0x0002000A;
#endregion GLFW_STENCIL_BITS
#endregion glfwGetWindowParam Tokens

#region glfwGetWindowParam/glfwOpenWindowHint Tokens
#region GLFW_REFRESH_RATE
/// <summary>
/// Vertical monitor refresh rate in Hz (only used for fullscreen windows). Zero
/// means system default.
/// </summary>
// #define GLFW_REFRESH_RATE 0x0002000B
public const int GLFW_REFRESH_RATE = 0x0002000B;
#endregion GLFW_REFRESH_RATE

#region GLFW_ACCUM_RED_BITS
/// <summary>
/// Number of bits for the red channel of the accumulator buffer.
/// </summary>
// #define GLFW_ACCUM_RED_BITS 0x0002000C
public const int GLFW_ACCUM_RED_BITS = 0x0002000C;
#endregion GLFW_ACCUM_RED_BITS

#region GLFW_ACCUM_GREEN_BITS
/// <summary>
/// Number of bits for the green channel of the accumulator buffer.
/// </summary>
// #define GLFW_ACCUM_GREEN_BITS 0x0002000D
public const int GLFW_ACCUM_GREEN_BITS = 0x0002000D;
#endregion GLFW_ACCUM_GREEN_BITS

#region GLFW_ACCUM_BLUE_BITS
/// <summary>
/// Number of bits for the blue channel of the accumulator buffer.
/// </summary>
// #define GLFW_ACCUM_BLUE_BITS 0x0002000E
public const int GLFW_ACCUM_BLUE_BITS = 0x0002000E;
#endregion GLFW_ACCUM_BLUE_BITS

#region GLFW_ACCUM_ALPHA_BITS
/// <summary>
/// Number of bits for the alpha channel of the accumulator buffer.
/// </summary>
// #define GLFW_ACCUM_ALPHA_BITS 0x0002000F
public const int GLFW_ACCUM_ALPHA_BITS = 0x0002000F;
#endregion GLFW_ACCUM_ALPHA_BITS

#region GLFW_AUX_BUFFERS
/// <summary>
/// Number of auxiliary buffers.
/// </summary>
// #define GLFW_AUX_BUFFERS 0x00020010
public const int GLFW_AUX_BUFFERS = 0x00020010;
#endregion GLFW_AUX_BUFFERS

#region GLFW_STEREO
/// <summary>
/// Specify if stereo rendering should be supported (can be <see cref="Gl.GL_TRUE" />
/// or <see cref="Gl.GL_FALSE" />).
/// </summary>
// #define GLFW_STEREO 0x00020011
public const int GLFW_STEREO = 0x00020011;
#endregion GLFW_STEREO

#region GLFW_WINDOW_NO_RESIZE
/// <summary>
/// Specify if window cannot be resized (can be <see cref="Gl.GL_TRUE" />
/// or <see cref="Gl.GL_FALSE" />).
/// </summary>
// #define GLFW_WINDOW_NO_RESIZE 0x00020012
public const int GLFW_WINDOW_NO_RESIZE = 0x00020012;
#endregion GLFW_WINDOW_NO_RESIZE

#region GLFW_FSAA_SAMPLES
/// <summary>
/// Number of multisampling buffer samples. Zero indicated multisampling
/// is disabled.
/// </summary>
// #define GLFW_FSAA_SAMPLES 0x00020013
public const int GLFW_FSAA_SAMPLES = 0x00020013;
#endregion GLFW_FSAA_SAMPLES
#endregion glfwGetWindowParam/glfwOpenWindowHint Tokens

Ein Versuch ist es ja Wert Smile

mfg olli[/code]

vertex.dreamfall.at | GitHub

	Fetze	So, Sep 02, 2007 13:20 Antworten mit Zitat
Meine Güte, gibt es viele Antialiazing-Varianten oO Gibt es eine Möglichkeit, bei OpenGL zwischen den verschiedenen "Versionen" zu wählen oder müsste man die sich selber coden, wenn man mit der Standardmethode nicht zufrieden ist? (Laut Wikipedia war Multisampling die Methode mit der Tiefenberücksichtigung - und Supersampling die ohne Rücksicht auf Verluste.) Anyway - danke für den Code, ich werde ihn gleich ausprobieren, sobald ich meine Arbeiten an den Texturen abgeschlossen hab ..vielleicht nutze ich die Gelegenheit und portiere Glfw (Ich habe gerade herausgefunden, wie ich das ganze kompiliere) Glfw direkt komplett auf 2.6.1, sind noch einige andere neue Features dabei.

Fetze

So, Sep 02, 2007 13:20
Antworten mit Zitat

Meine Güte, gibt es viele Antialiazing-Varianten oO
Gibt es eine Möglichkeit, bei OpenGL zwischen den verschiedenen "Versionen" zu wählen oder müsste man die sich selber coden, wenn man mit der Standardmethode nicht zufrieden ist?

(Laut Wikipedia war Multisampling die Methode mit der Tiefenberücksichtigung - und Supersampling die ohne Rücksicht auf Verluste.)

Anyway - danke für den Code, ich werde ihn gleich ausprobieren, sobald ich meine Arbeiten an den Texturen abgeschlossen hab Smile

..vielleicht nutze ich die Gelegenheit und portiere Glfw (Ich habe gerade herausgefunden, wie ich das ganze kompiliere) Glfw direkt komplett auf 2.6.1, sind noch einige andere neue Features dabei.

	Fetze	Di, Sep 04, 2007 19:03 Antworten mit Zitat
So, habs mal ausprobiert - allerdings kriege ich FSAA trotzdem noch nicht zum Laufen,während die ebenfalls von dir neu hinzugefügte (und auch erst ab Glfw 2.6 implementierte) GLFW-Konstante NO_RESIZE wunderbar funktioniert. Entweder ist also der Konstantenwert für FSAA_SAMPLES falsch oder ich verwende die OpenGL-Befehle nicht richtig. Hier mein gekürzter und zusammengeschnittener Code: Code: [AUSKLAPPEN] [EINKLAPPEN] Glfw.glfwOpenWindowHint(Glfw.GLFW_WINDOW_NO_RESIZE, Gl.GL_TRUE); Glfw.glfwOpenWindowHint(Glfw.GLFW_FSAA_SAMPLES, 4); int windowMode = isWindowed ? Glfw.GLFW_WINDOW : Glfw.GLFW_FULLSCREEN; int windowOpen = Glfw.glfwOpenWindow( gfxWidth, gfxHeight, redBits, greenBits, blueBits, alphaBits, 32, 0, windowMode); Gl.glSampleCoverage(1.0f, Gl.GL_FALSE); Gl.glEnable(Gl.GL_MULTISAMPLE); // Kram zeichnen Gl.glDisable(Gl.GL_MULTISAMPLE); Gibts für FSAA / MULTISAMPLE noch weitere Vorraussetzungen? Muss ich irgendwas anderes zusätzlich aktivieren? Ich bin noch nicht ganz firm mit all den OpenGL-Enables und Disables..

Fetze

Di, Sep 04, 2007 19:03
Antworten mit Zitat

So, habs mal ausprobiert - allerdings kriege ich FSAA trotzdem noch nicht zum Laufen,während die ebenfalls von dir neu hinzugefügte (und auch erst ab Glfw 2.6 implementierte) GLFW-Konstante NO_RESIZE wunderbar funktioniert. Entweder ist also der Konstantenwert für FSAA_SAMPLES falsch oder ich verwende die OpenGL-Befehle nicht richtig. Hier mein gekürzter und zusammengeschnittener Code:

Code: [AUSKLAPPEN]

Glfw.glfwOpenWindowHint(Glfw.GLFW_WINDOW_NO_RESIZE, Gl.GL_TRUE);
Glfw.glfwOpenWindowHint(Glfw.GLFW_FSAA_SAMPLES, 4);
int windowMode = isWindowed ? Glfw.GLFW_WINDOW : Glfw.GLFW_FULLSCREEN;
int windowOpen =
Glfw.glfwOpenWindow( gfxWidth,
               gfxHeight,
               redBits,
               greenBits,
               blueBits,
               alphaBits,
               32,
               0,
               windowMode);
Gl.glSampleCoverage(1.0f, Gl.GL_FALSE);
Gl.glEnable(Gl.GL_MULTISAMPLE);
// Kram zeichnen
Gl.glDisable(Gl.GL_MULTISAMPLE);

Gibts für FSAA / MULTISAMPLE noch weitere Vorraussetzungen? Muss ich irgendwas anderes zusätzlich aktivieren? Ich bin noch nicht ganz firm mit all den OpenGL-Enables und Disables..

	Fetze	Do, Sep 06, 2007 11:50 Antworten mit Zitat
So, nachdem ich die neueste GLFW-Version installiert hab, kriege ich wenigstens eine Reaktion - auch wenn diese ist, dass kein Fenster initialisiert werden kann, wenn ich mehr als 0 Sample Buffers angebe. Ob Fullscreen oder Fenstermodus macht keinen Unterschied, 32 Bit (8888) Farb- und 32 Bit Depthbuffer bei 0 Bit Stencilbuffer und das alles in einer Auflösung von 1280 mal 1024. Könnte es an meinem Rechner liegen oder mache ich irgendwas grundsätzlich falsch? Muss ich OpenGL vorher spezielle Samplebuffer-parameter übergeben?

Fetze

Do, Sep 06, 2007 11:50
Antworten mit Zitat

So, nachdem ich die neueste GLFW-Version installiert hab, kriege ich wenigstens eine Reaktion - auch wenn diese ist, dass kein Fenster initialisiert werden kann, wenn ich mehr als 0 Sample Buffers angebe. Ob Fullscreen oder Fenstermodus macht keinen Unterschied, 32 Bit (8888) Farb- und 32 Bit Depthbuffer bei 0 Bit Stencilbuffer und das alles in einer Auflösung von 1280 mal 1024.

Könnte es an meinem Rechner liegen oder mache ich irgendwas grundsätzlich falsch? Muss ich OpenGL vorher spezielle Samplebuffer-parameter übergeben?

	Dreamora	Do, Sep 06, 2007 13:16 Antworten mit Zitat
Was hast du für ne Hardware?
Ihr findet die aktuellen Projekte unter Gayasoft und könnt mich unter @gayasoft auf Twitter erreichen.

Dreamora

Do, Sep 06, 2007 13:16
Antworten mit Zitat

Was hast du für ne Hardware?

Ihr findet die aktuellen Projekte unter Gayasoft und könnt mich unter @gayasoft auf Twitter erreichen.

	Fetze Betreff: Re: OpenGL: Shape-Antialiazing produziert Fragmente	Do, Sep 06, 2007 13:27 Antworten mit Zitat
Fetze hat Folgendes geschrieben: Technische Eckdaten: Windows XP SP2 Nvidia Geforce 6800 GT Depthbuffer aktiv 32 Bit Grafiktiefe 1280 x 1024, allerdings ist der Effekt auflösungsunabhängig Fensterodus / Vollbild hat ebenfalls keine Auswirkungen Siehe oben Denke, der Rest an Hardware ist weniger relevant.

Fetze

Betreff: Re: OpenGL: Shape-Antialiazing produziert Fragmente

Do, Sep 06, 2007 13:27
Antworten mit Zitat

Fetze hat Folgendes geschrieben:

Technische Eckdaten:
Windows XP SP2
Nvidia Geforce 6800 GT
Depthbuffer aktiv
32 Bit Grafiktiefe
1280 x 1024, allerdings ist der Effekt auflösungsunabhängig
Fensterodus / Vollbild hat ebenfalls keine Auswirkungen

Siehe oben Wink

Denke, der Rest an Hardware ist weniger relevant.

Übersicht

Sonstiges

Smalltalk

Nach Oben

BlitzBasic Portal

OpenGL: Shape-Antialiazing produziert Fragmente

Betreff: OpenGL: Shape-Antialiazing produziert Fragmente

Betreff: Re: OpenGL: Shape-Antialiazing produziert Fragmente