Pyglet OpenGL dibujo suavizado

Question

He estado buscando en torno a la manera de líneas anti-alias en OpenGL, pero ninguno de ellos parece funcionar ... aquí es un código de ejemplo:

import pyglet                  
from pyglet.gl import *                

window = pyglet.window.Window(resizable=True)          

@window.event                  
def on_draw():                  
    window.clear()                 
    pyglet.gl.glColor4f(1.0,0,0,1.0)            
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)        
    glEnable (GL_BLEND)                
    glEnable (GL_LINE_SMOOTH);              
    glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE)          
    glLineWidth (3)                 
    pyglet.graphics.draw(2, pyglet.gl.GL_LINES,          
     ('v2i', (10, 15, 300, 305))             
    )                    

pyglet.app.run() 

Puede alguien veo lo que estoy haciendo mal?

Answer 1

Permitir que Pyglet utilice un búfer de muestra adicional podría ayudar. Cambie su línea de ventana a esto:

config = pyglet.gl.Config(sample_buffers=1, samples=4) 
window = pyglet.window.Window(config=config, resizable=True) 

Esto funciona para mí.

Answer 2

Es un poco difícil de decir con certeza. Lo primero es, probablemente, cambiar su sugerencia de GL_DONT_CARE a GL_NICEST. Probablemente no hará mucha diferencia con la mayoría de las tarjetas gráficas, pero podría ayudar un poco.

Aparte de eso, es un poco difícil de decir. Aquí hay un poco de código (en C++; lo siento):

void draw_line(float y_offset) { 
    glBegin(GL_LINES); 
     glColor3f(1.0f, 1.0f, 1.0f); 
     glVertex3f(-1.0f, 0.0f+y_offset, -1.0f); 
     glVertex3f(1.0f, 0.1f+y_offset, -1.0f); 
    glEnd(); 
} 

void draw() { 
    glClearColor(0.0f, 0.0f, 0.2f, 1.0f); 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 

    glFrustum(-1.2f, 1.2f, -0.2f, 0.2f, 0.8f, 5.0f); 

    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 

    glEnable(GL_DEPTH_TEST); 
    glEnable(GL_BLEND); 
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 

    glLineWidth(3.0f); 
    glDisable(GL_LINE_SMOOTH); 
    draw_line(0.0f); 
    glEnable(GL_LINE_SMOOTH); 
    glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE); 
    draw_line(-0.1f); 
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST); 
    draw_line(-0.2f); 

    glFlush(); 
} 

Y esto es lo que estoy haciendo como salida a partir de que:

La diferencia cuando la línea de alisado se enciende parece Bastante obvio. La diferencia entre GL_DONT_CARE y GL_NICEST es (como máximo) un lote menos.