I'm joyous of GLGraphics library abilities, and I'm playing with it arroud free-hand painting. I use GLGraphicsOffScreen to store my painting and apply brush, than I image() the texture onto the screen before painting of GUI.

The problem is when I want to paint with alpha-blended brush into my offscreen. The texture of entire offscreen become transparent and do not cover the backgroud of the window.

For example:

Code:

import processing.opengl.*;
import codeanticode.glgraphics.*;
import codeanticode.protablet.*;

GLGraphicsOffScreen L1;

void setup()
{
size(1000, 600, GLConstants.GLGRAPHICS);  
L1 = new GLGraphicsOffScreen(this, width, height, true, 4);
  L1.beginDraw();
  L1.background(128,255);
  L1.noStroke();
  
  // simulate my painting with non-100% papacity of brush
  L1.fill(0,0,0,128);  
  L1.ellipse(100,100,50,50);
  
  L1.endDraw();

//make some strips to see the problem
 background(255,255);
 stroke(0);
 for(int i=0;i<width;i+=10){
  line(i,0,i,height);
 };

image(L1.getTexture(), 0, 0, width, height);
// Ops, theres a hole :(

}
 

How can I render my brush with alpha blending into offscreen, but not to change alpha-channel. I want 100%-opaque offscreen texture, and just alpha-blend something onto it (like Flow in photoshop).

it means alpha-channel of the painting should not be replaced by alpha-channel of brush (like ellipse in example) bud rather should build-up additively.

If I have 100%-transparent (alpha=0) offscreen texture at the beginning, I wan't each alpha-blended ellipse() to increase alpha by its the A in fill(R,G,B,A);

Naturaly I'd like to use as much of standard rendering tools of processing (like ellipse, line, quad ... ) as possible. I don't want to do any per-pixel operation if not necessary;

Yes, operations with Channel would be sure very usefull. Especially
Copy just specific chanel from one texture to other, or divide one texture into four textures for each channel do something and than put it together. It would be usefull for operations like "quick mask" in Photoshop or "color to alpha" in GIMP and many other similar things.
I thing, now it's possible using user defined GLSL filter, but with new function it would be more confortable.

However, it is not the solution of this problem, consider:
1]I want to build up my brush (like using airbrush) of black circle on my texture white backgroud RGBA=(1.0,1.0,1.0,1.0)
2]I do this by repetitive rendering of RGBA=(0.0,0.0,0.0,a) circle onto the screen, where "a" is opacity (Flow) value of brush
3]However it would not build up, but replace pixels of my texture by (0.0,0.0,0.0,a)
4]Now I set alpha-channel to 1.0. I get texture which is white somewhere RGBA=(1.0,1.0,1.0,1.0), where I did not paint at all, and black RGBA=(0.0,0.0,0.0,1.0) everywhere I did;
5]this is not what I want. I want to finish with texture  gradually shaded like RGBA=(1-k*a,1-k*a,1-k*a,1.0) where "k" is number of strokes I had painted over this pixel.

what I need is to render ellipses, lines and polygons in other render mode.

instead of replace(RGBA):
result.RGBA=brush.RGBA

I need alpha-blend(RGB):
result.RGB=backgroud.RGB*(1-brush.A)+brush.RGB*brush.A
result.A = backgroud.A + brush.A

however, is it samehow possible to set?

Ok, I think the solution is easier and involves properly implementing blending methods in both GLGraphicsOffscreen and GLGraphics.

The following sample code does in fact what you need:

Code:

// Enables blending in the offscreen surface using the BLEND mode.
L1.setBlendMode(BLEND);
L1.beginDraw();
...
L1.endDraw();

// We get the underlying GLGraphics renderer...
GLGraphics renderer = (GLGraphics)g;
//... in order to use its setBlendMode() method. 
// The BACKGROUND_ALPHA mode keeps the alpha
// from the background, it is implemented internally
// in OpenGL with the following code:
// gl.glBlendColor(0.0f, 0.0f, 0.0f, 1.0f);
// gl.glBlendFunc(GL.GL_ONE, GL.GL_CONSTANT_COLOR);
renderer.setBlendMode(BACKGROUND_ALPHA); 

image(L1.getTexture(), 0, 0);
 

BACKGROUND_ALPHA is just a possible name. All the blending modes to have in GLGraphics should come from examining the OpenGL  blending functions (glAlphaFunc, glBlendColor, glBlendEquation, glBlendEquationSeparate, glBlendFunc) and the blending constants already present in Processing (BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, DIFFERENCE, etc). I'm still not sure it is possible to reproduce all the blending modes in Processing using OpenGL...

Hi, I just added the GLGraphics.setBlendMode() and GLGraphicsOffscreen.setBlendMode() to the trunk. There is still no official release with these new features, but you can try them out with this pre-release package:

http://users.design.ucla.edu/~acolubri/processing/glgraphics/glgraphics-20091110.zip

The following sketch should have the correct behavior in terms of blending, when using the pre-release glgraphics:

Code:

import processing.opengl.*;
import codeanticode.glgraphics.*;

GLGraphicsOffScreen glg1;

void setup()
{
  size(640, 480, GLConstants.GLGRAPHICS);
    
  glg1 = new GLGraphicsOffScreen(this, width, height);

  glg1.beginDraw();
  glg1.background(255);  
  glg1.noStroke();
  glg1.endDraw();
}

void draw()
{
  background(0);
  
  // In the off-screen surface 1, we draw random ellipses.
  glg1.setBlendMode(BLEND);
  glg1.beginDraw();
    glg1.fill(0, 50);
    glg1.ellipse(mouseX, mouseY, 50, 50);
  glg1.endDraw();   

  stroke(255);
  for(int i = 0; i < width; i += 10) line(i, 0, i, height);
 
  GLGraphics renderer = (GLGraphics)g;
  renderer.setBlendMode(GLConstants.BACKGROUND_ALPHA);  
  image(glg1.getTexture(), 10, 10, width - 20, height - 20); 
}
 

The changes come from some testing I'm currently doing with the latest source. But my intention is to return the original behavior once this new version is finished.

Ok, one possible solution would be to constrain the filter to be applied to a rectangular region of the input texture. Say:

inputTex.filter(brushFilter, outputTex, brush.x, brush.y, brush.w, brush.h);

Would this take care of the non-locality issue you mention?

well, you could potentially use the float parameters of a filter to constrain the region where the filter is applied. However this will be highly inefficient, since it will involve rendering the whole input texture, and then having a conditional inside the pixel shader to process only those pixels inside the desired rect.

I think the efficient way of dealing with this problem would be to implement a new function along the lines of what I described in my previous message, so only the specified rectangular portion of the input texture gets rendered...

But here I have a question: is the input texture just the brush texture, or a larger texture with the brush already drawn in some specific area of it?

I see. This type of dynamic masking could be done using the stencil buffer. It requires some work though in order to implement properly. I added this to the feature tracker of glgraphics:

https://sourceforge.net/tracker/?func=detail&aid=2898381&group_id=225391&atid=10
64716

In a related not, I put online a newer version of the lib where the behavior of the offscreen renderer should not change in the final release:

http://users.design.ucla.edu/~acolubri/processing/glgraphics/glgraphics-20091116.zip