Borrar con pincel en GLPaint

Question

Como parte de la modificación del GLPaint, intento agregar la funcionalidad de borrado donde el usuario puede seleccionar un botón de borrador y borrar el área pintada solo como pintar.

Estoy intentando tener un enunciado condicional dentro del método "renderLineFromPoint:(CGPoint)start toPoint:(CGPoint)end" para poder verificar si el trazo es para pintar o borrar.

Para borrar No sé cómo utilizar los parámetros "start" y "end" para borrar. ¿Hay alguna llamada de método en OpenGL como glClear() que acepte estos dos parámetros y se borre?

Cualquier apuntador será de gran ayuda. Gracias.

Answer 1

A lo largo de la misma línea que Erase using brush in GLPaint, podría volver a utilizar el método

- (void)renderLineFromPoint:(CGPoint)start toPoint:(CGPoint)end 

por tener la condición:

if (isEraserBrushType) { 
    glBlendFunc(GL_ONE, GL_ZERO); 
    glColor4f(0, 0, 0, 0.0); 
} else { 
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); 
    [self setBrushColorWithRed:brushColourRed green:brushColourGreen blue:brushColourBlue]; 
} 

encima del código:

// Render the vertex array 
glVertexPointer(2, GL_FLOAT, 0, eraseBuffer); 
glDrawArrays(GL_POINTS, 0, vertexCount); 

Nota, que' Necesitaré implementar isEraserBrushType y almacenar brushColourRed, brushColourGreen y brushColourBl de alguna manera.

Answer 2

Creo que puedo resolver este problema, aunque no es muy bueno.

Puede crear una nueva copia de función de "renderLineFromPoint", así;

- (void) drawErase:(CGPoint)start toPoint:(CGPoint)end 
{ 
    static GLfloat*  eraseBuffer = NULL; 
    static NSUInteger eraseMax = 64; 

    NSUInteger   vertexCount = 0, 
    count, 
    i; 

    [EAGLContext setCurrentContext:context]; 
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, viewFramebuffer); 

    // Convert locations from Points to Pixels 
    CGFloat scale = 1.0;//self.contentScaleFactor; 
    start.x *= scale; 
    start.y *= scale; 
    end.x *= scale; 
    end.y *= scale; 

    // Allocate vertex array buffer 
    if(eraseBuffer == NULL) 
     eraseBuffer = malloc(eraseMax * 2 * sizeof(GLfloat)); 

    // Add points to the buffer so there are drawing points every X pixels  
    count = MAX(ceilf(sqrtf((end.x - start.x) * (end.x - start.x) + (end.y - start.y) * (end.y - start.y))/kBrushPixelStep), 1); 

    for(i = 0; i < count; ++i) { 
     if(vertexCount == eraseMax) { 
      eraseMax = 2 * eraseMax; 
      eraseBuffer = realloc(eraseBuffer, eraseMax * 2 * sizeof(GLfloat)); 
     } 

     eraseBuffer[2 * vertexCount + 0] = start.x + (end.x - start.x) * ((GLfloat)i/(GLfloat)count); 
     eraseBuffer[2 * vertexCount + 1] = start.y + (end.y - start.y) * ((GLfloat)i/(GLfloat)count); 
     vertexCount += 1; 
    } 
    //} 
    //glEnable(GL_BLEND); // 打开混合 
     //glDisable(GL_DEPTH_TEST); // 关闭深度测试 
     //glBlendFunc(GL_SRC_ALPHA, GL_ONE); // 基于源象素alpha通道值的半透明混合函数 

     //You need set the mixed-mode 
    glBlendFunc(GL_ONE, GL_ZERO); 
     //the erase brush color is transparent. 
    glColor4f(0, 0, 0, 0.0); 

    // Render the vertex array 
    glVertexPointer(2, GL_FLOAT, 0, eraseBuffer); 
    glDrawArrays(GL_POINTS, 0, vertexCount); 

    // Display the buffer 
    glBindRenderbufferOES(GL_RENDERBUFFER_OES, viewRenderbuffer); 
    [context presentRenderbuffer:GL_RENDERBUFFER_OES]; 

     // at last restore the mixed-mode 
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); 
} 

Mi inglés es pobre. ¿Puedes entender lo que dije? Espero que estos te puedan ayudar.

Answer 3

Otra idea, si supongamos tierra trasera de su punto de vista es negro puro sólo tiene que llamar [self setBrushColorWithRed:0.0 green:0.0 blue:0.0] y luego llamar renderPoint: ToPint: - Para ello se utilizará en negro (y el usuario puede pensar que en realidad está borrando

Answer 4

.

que intentó utilizar la respuesta aceptada, sin embargo, sería borrar en un patrón cuadrado, mientras que quería borrar usando mi propio pincel. en lugar de ello he utilizado una función de mezcla diferentes.

if (self.isErasing) { 
    glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA); 
    [self setBrushColorWithRed:0 green:0 blue:0]; 
} else { 
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); 
} 

la forma en que esto funciona es que el el color entrante (fuente) se multiplica por cero hasta c desaparecer por completo, lo que significa que en realidad no pintas nada nuevo. Luego, el color de destino se establece en (1 - Alfa fuente). Entonces, dondequiera que el cepillo tenga color, el destino tiene no color.