pyglet OpenGL disegno anti-aliasing

Question

Ho cercato in giro per un posto a linee di antialiasing in OpenGL, ma nessuno di loro sembra funzionare ... ecco qualche esempio di codice:

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() 

Può chiunque vedi cosa sto facendo di sbagliato?

Answer 1

Consentire a Pyglet di utilizzare un buffer di esempio aggiuntivo. Cambia la linea della finestra con questo:

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

Questo funziona per me.

Answer 2

È difficile dirlo con certezza. La prima cosa è probabilmente cambiare il tuo suggerimento da GL_DONT_CARE a GL_NICEST. Probabilmente non farà molta differenza con la maggior parte delle schede grafiche, ma potrebbe aiutare un po '.

A parte questo, è un po 'difficile da dire. Ecco un po 'di codice (in C++; sorry):

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(); 
} 

ed ecco cosa sto ottenendo come output da questo:

La differenza quando la linea-smoothing è attivato sembra abbastanza ovvio. La differenza tra GL_DONT_CARE e GL_NICEST è (al massimo) un lotto in meno.