C++: Usuwanie efektu Moire z biblioteki OpenGL

Question

Rysuję desenie, które mają szczegółowe piksele i często napotykają efekt Moire. Nie jestem dobry w cieniowaniu i nie jestem pewien, czy ten problem zostanie rozwiązany przez shadery. Nie znalazłem żadnego podstawowego, zrozumiałego i pełnego przykładu shaderów. Większość tutorialowych stron internetowych rozpoczyna program od środka, pomijając plik nagłówkowy!

To jest MWE mojego kodu. Czy możliwe jest złagodzenie lub usunięcie efektu Moire z niego?

#include <cmath> 
#include <vector> 

#ifdef __APPLE__ 
#include <GLUT/glut.h> 
#else 
#include <GL/glut.h> 
#endif 

const int w=640,h=480; 
float cam_angle=0.0f; 

void init() 
{ 
    GLfloat LightAmbient[] = { 0.2f, 0.2f, 0.2f, 1.0f }; 
    GLfloat LightDiffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f }; 
    GLfloat LightPosition[] = { 5.0f, 5.0f, -10.0f, 1.0f }; 

    glClearColor(0.0, 0.0, 0.0, 0.0); 
    glShadeModel(GL_SMOOTH); 
    glEnable(GL_DEPTH_TEST); 
    glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); 
    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse); 
    glLightfv(GL_LIGHT1, GL_POSITION, LightPosition); 
    glEnable(GL_LIGHT1); 
} 

void onDisplay() 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    gluPerspective (90, float(w)/float(h), 0.01, 10000); 
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 

    const double pi=3.1415926; 
    double cam_x=2.0*cos(pi/4.0)*cos(cam_angle);; 
    double cam_y=2.0*sin(pi/4.0)*cos(cam_angle);; 
    double cam_z=2.0*sin(cam_angle); 
    gluLookAt(cam_x, cam_y, cam_z, 0, 0, 0, 0, 0, 1); 

    struct Point3D 
    { 
     double x, y, z; 
     unsigned char r, g, b, a=255; 
    }; 

    for(double r=0.5;r<=1.0;r+=0.03) 
    { 
     std::vector<Point3D> points; 
     for(int i=0;i<1000;i++) 
     { 
      double theta=double(i)/1000.0*pi*2.0; 
      Point3D p; 
      p.x=r*sin(theta); 
      p.y=r*cos(theta); 
      p.z=r; 
      p.r=128; 
      p.g=200; 
      p.b=50; 
      points.push_back(p); 
     } 
    // draw 
     glPushMatrix(); 
     glColor3ub(255,255,255); 
     glEnableClientState(GL_VERTEX_ARRAY); 
     glEnableClientState(GL_COLOR_ARRAY); 
     glVertexPointer(3, GL_DOUBLE, sizeof(Point3D), &points[0].x); 
     glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Point3D), &points[0].r); 
     // glPointSize(3.0); 
     glLineWidth(2.0); 
     glDrawArrays(GL_LINE_STRIP, 0, int(points.size())); 
     glDisableClientState(GL_VERTEX_ARRAY); 
     glDisableClientState(GL_COLOR_ARRAY); 
     glPopMatrix(); 
    } 

    glFlush(); 
    glutSwapBuffers(); 
} 

void Timer(int /*value*/) 
{ 
    cam_angle+=0.01f; 
    glutPostRedisplay(); 
    // 100 milliseconds 
    glutTimerFunc(100, Timer, 0); 
} 

int main(int argc, char** argv) 
{ 
    glutInit(&argc, argv); 
    glutInitWindowSize (w, h); 
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE); 
    glutInitWindowPosition (100, 100); 
    glutCreateWindow ("my window"); 
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); 
    glEnable(GL_BLEND); 

    init(); 
    glutDisplayFunc(onDisplay); 
    Timer(0); 
    glutMainLoop(); 

    return 0; 
} 

Answer 1

Jeśli używasz Multisampling, wtedy wynik będzie znacznie poprawić:

glutSetOption(GLUT_MULTISAMPLE, 8); 
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE | GLUT_MULTISAMPLE); 

bez GLUT_MULTISAMPLE:

z GLUT_MULTISAMPLE:

Patrz również odpowiedź GLUT + OpenGL multisampling anti aliasing (MSAA)