Ich arbeite an einer benutzerdefinierten Geometriebibliothek, die an Quartz Composer angepasst ist, und versuche, einige konkave Polygone in einem Plug-In zu zeichnen.

Ich habe die poly2tri-Bibliothek implementiert, damit der Benutzer wählen kann, ob er triangulieren möchte oder nicht. Sie ist jedoch nicht für das Rendern von Polygontransformationen pro Frame geeignet.

Ich bin ein Noob in OpenGL und habe viel gelesen und getestet, über Schablonenpuffer und ungerade / gerade Operationen, aber gerader Code, der für andere Leute zu funktionieren scheint, funktioniert für mich nicht.

Der Renderkontext ist ein CGLContextObj und ich arbeite an einem MacBook Pro Retina Display mit NVidia GEForce GT650. Ich habe gelesen, dass alle Konfigurationen keine Schablonenpuffer haben, aber es sieht manchmal so aus, als würde es funktionieren, wenn auch nicht so, wie ich es gerne hätte.

Ich habe mich gefragt, ob jemand mit der gleichen Konfiguration einen Code verwendet, der funktioniert und sich meinen Code ansehen kann. Insbesondere bin ich auch neugierig auf die Anzahl der angeforderten Durchgänge, entsprechend der Anzahl der Eckpunkte oder "Konvexitätsdefekte", denke ich ...

Ich habe meine Infos genommen von:

... aber immer noch nicht klar ...

Hier ist mein Code (einer davon, da ich so viele Konfigurationen getestet habe) und ein Bild des Ergebnisses. Eigentlich verwende ich, um das eigentliche Rendering in eine Methode zu schreiben, die für jedes Polygon aufgerufen wird, aber ich habe es umgeschrieben, um viel klarer zu sein:

BEARBEITEN

Tatsächlich habe ich verstanden, dass ich jedes Dreieck zeichnen muss, um den Bitwert im Schablonenpuffer zu invertieren. Also habe ich meinen Code folgendermaßen umgeschrieben:

CGLContextObj cgl_ctx = [context CGLContextObj];

CGLLockContext(cgl_ctx);

GLenum                          error;

if(cgl_ctx == NULL)
    return NO;


glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);



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

glDisable(GL_CULL_FACE);
glClear(GL_STENCIL_BUFFER_BIT);
glClearStencil(0);

glEnable(GL_STENCIL_TEST);

glStencilOp(GL_INVERT, GL_INVERT, GL_INVERT);
glStencilFunc(GL_ALWAYS, 1, 1);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

// glColor4d(1., 1., 1., 1.);        ----> does it make sense ?
glBegin(GL_TRIANGLE_FAN); {

    for (int i = 1; i < [vertices count] - 1; i++) {
        // Allways drawing the first vertex
        glVertex2d([[[vertices objectAtIndex:0] objectAtIndex:0] doubleValue], [[[vertices objectAtIndex:0] objectAtIndex:1] doubleValue]);

        // Then two others to make a triangle
        glVertex2d([[[vertices objectAtIndex:i] objectAtIndex:0] doubleValue], [[[vertices objectAtIndex:i] objectAtIndex:1] doubleValue]);
        glVertex2d([[[vertices objectAtIndex:i+1] objectAtIndex:0] doubleValue], [[[vertices objectAtIndex:i+1] objectAtIndex:1] doubleValue]);

    }

}
glEnd();


glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
glStencilFunc(GL_EQUAL, 1, 1);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

glColor4d(1., 0., 0., 0.5);
glBegin(GL_TRIANGLE_FAN); {
    for (id vertex in vertices) {
        glVertex2d([[vertex objectAtIndex:0] doubleValue], [[vertex objectAtIndex:1] doubleValue]);
    }
    glVertex2d([[[vertices objectAtIndex:0] objectAtIndex:0] doubleValue], [[[vertices objectAtIndex:0] objectAtIndex:1] doubleValue]);
}
glEnd();


glDisable (GL_STENCIL_TEST);




glDisable(GL_BLEND);


glPopClientAttrib();
glPopAttrib();



if((error = glGetError()))
    NSLog(@"OpenGL error %04X", error);

CGLUnlockContext(cgl_ctx);

return (error ? NO : YES);

Aber es geht immer noch nicht. Hier ist mein Ergebnis und der Link zum Originalbild und die Erklärung.

http://what-when-how.com/opengl-programming-guide/drawing-filled-concave-polygons-using-the-stencil-buffer-opengl-programming/

EDIT 2:

In der Tat ermöglicht der Kontext von Quartz Composerimplementiert keinen Schablonenpuffer. Es scheint unmöglich, direkt in OpenGL mit dem Schablonenpuffer zu rendern.