Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

Core Library Questions

onar3d

Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

in Core Library Questions • 29 days ago

Hi!

I'm pretty sure this is a bug, so I filed it as one ( https://github.com/processing/processing/issues/2083 ).

I couldn't find anything on here or in the bugs database that is the same.

But off the odd chance it isn't a bug, I thought I'd ask here, and if it turns out I've been wrong I'll delete the bug report.

I created this example from combining the OffscreenTest and LowLevelGL examples, but I've encountered this behavior in a lot of my own code as well.

This appears in the latest version (2.0.3), running on Windows 7 32bit.

Pressing the spacebar toggles between drawing directly, and first drawing into PGraphics and then displaying that.

The two should be identical but are not!

In the method drawDirectly, the output is as expected for all alpha values.
In drawImage, alpha == 1.0f looks fine, but set this to 0.5f, and drawing is almost invisible!

EDIT:

I tested this also in Processing 2.0.1 and 2.0.2 and got different behavior showing that this is most likely a bug stemming out of recent development.

In 2.0.1 the issue is the same as reported for 2.0.3.

For 2.0.2 however, the output of drawImage() is as expected, while drawDirectly() seems to ignore alpha altogether!

End EDIT.

Sketch code to reproduce:

import java.nio.*;
PGL pgl;
PGraphics pg;
PShader flatShader;
int vertLoc, colorLoc;
float[] vertices, colors;
FloatBuffer vertData, colorData;
boolean drawPGraphicsImage = true;
float alpha = 0.5f;

// Keys:
// 'a': toggles between alpha == 0.5f and alpha == 1.0f.
// spacebar: toggles between rendering directly, and into a PGraphics buffer.

// BUG DESCRIPTION:
// In drawDirectly, the appearance is as expected for all alpha values.
// In drawImage, alpha == 1.0f looks fine, but set this to 0.5f, and drawing is almost invisible!

void setup() {
size(800, 800, OPENGL);

pg = createGraphics(800, 800, OPENGL);

flatShader = loadShader("frag.glsl", "vert.glsl");

vertices = new float[12];
vertData = allocateDirectFloatBuffer(12);

colors = new float[12];
colorData = allocateDirectFloatBuffer(12);
}

void draw() {
updateGeometry();

background(0);

if(drawPGraphicsImage)
drawImage();
else
drawDirectly();
}

void keyPressed() {
if (key == ' ') {
drawPGraphicsImage = !drawPGraphicsImage;
}
else if (key == 'a') {
if(alpha == 0.5f)
alpha = 1.0f;
else
alpha = 0.5f;
}
}

// This works as expected
void drawDirectly() {
pgl = beginPGL();
flatShader.bind();

vertLoc = pgl.getAttribLocation(flatShader.glProgram, "vertex");
colorLoc = pgl.getAttribLocation(flatShader.glProgram, "color");

pgl.enableVertexAttribArray(vertLoc);
pgl.enableVertexAttribArray(colorLoc);

pgl.vertexAttribPointer(vertLoc, 4, PGL.FLOAT, false, 0, vertData);
pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 0, colorData);

pgl.drawArrays(PGL.TRIANGLES, 0, 3);

pgl.disableVertexAttribArray(vertLoc);
pgl.disableVertexAttribArray(colorLoc);

flatShader.unbind();

endPGL();
}

// This is most likey a bug!
void drawImage() {
pg.beginDraw();
pg.clear();

pgl = pg.beginPGL();
flatShader.bind();

vertLoc = pgl.getAttribLocation(flatShader.glProgram, "vertex");
colorLoc = pgl.getAttribLocation(flatShader.glProgram, "color");

pgl.enableVertexAttribArray(vertLoc);
pgl.enableVertexAttribArray(colorLoc);

pgl.vertexAttribPointer(vertLoc, 4, PGL.FLOAT, false, 0, vertData);
pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 0, colorData);

pgl.drawArrays(PGL.TRIANGLES, 0, 3);

pgl.disableVertexAttribArray(vertLoc);
pgl.disableVertexAttribArray(colorLoc);

flatShader.unbind();

pg.endPGL();

pg.endDraw();
image(pg, 0, 0, 800, 800);
}

void updateGeometry() {
// Vertex 1
vertices[0] = 0;
vertices[1] = 0;
vertices[2] = 0;
vertices[3] = 1;
colors[0] = 1;
colors[1] = 0;
colors[2] = 0;
colors[3] = alpha;

// Corner 2
vertices[4] = width/2;
vertices[5] = height;
vertices[6] = 0;
vertices[7] = 1;
colors[4] = 0;
colors[5] = 1;
colors[6] = 0;
colors[7] = alpha;

// Corner 3
vertices[8] = width;
vertices[9] = 0;
vertices[10] = 0;
vertices[11] = 1;
colors[8] = 0;
colors[9] = 0;
colors[10] = 1;
colors[11] = alpha;

vertData.rewind();
vertData.put(vertices);
vertData.position(0);

colorData.rewind();
colorData.put(colors);
colorData.position(0);

}

FloatBuffer allocateDirectFloatBuffer(int n) {
return ByteBuffer.allocateDirect(n * Float.SIZE/8).order(ByteOrder.nativeOrder()).asFloatBuffer();
}

Replies(5)

andres

Re: Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

29 days ago

If you set the blend mode as replace when drawing the offscreen pg buffer:

blendMode(REPLACE);
image(pg, 0, 0, 800, 800);
blendMode(BLEND);

then the two outputs are identical. This is discussed in this issue.

onar3d

Re: Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

29 days ago

Hi, thank you for the quick reply!

The bug report is closed, so I'll carry on here with my question, since REPLACE does not give me the output I need.

REPLACE treats the area of the buffer that I didn't draw into as opaque, unlike the default BLEND.

I remember in OpenGL this is dealt with by setting a particular set of source and destination blending settings ( glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) I think but I may be wrong...), but in Processing blending is set differently so I don't know how to get the result I'm after. I hope I can avoid mixing both straight Processing and OpenGL voodoo :)

Following is an example sketch of what I mean. By pressing the spacebar, you switch between drawing into PGraphics or directly. By pressing 'r' when showing the PGraphics output you see the undesired output from using REPLACE.

To sum up, what I want is that when you run the sketch, and press spacebar, the output is the exact same!

import java.nio.*;
PGL pgl;
PGraphics pg_1, pg_2;
PShader flatShader;
int vertLoc, colorLoc;
float[] vertices, colors;
FloatBuffer vertData, colorData;
int vertLoc2;
float[] vertices2;
FloatBuffer vertData2;
boolean drawPGraphicsImage = true;
boolean blend = true;
float alpha = 0.5f;
float angle;
float jitter;
// Keys:
// 'a': toggles between alpha == 0.5f and alpha == 1.0f.
// spacebar: toggles between rendering directly, and into a PGraphics buffer.
// blend: toggles between REPLACE and BLEND when drawing PGraphics
void setup() {
size(800, 800, OPENGL);
pg_1 = createGraphics(800, 800, OPENGL);
pg_2 = createGraphics(800, 800, OPENGL);
flatShader = loadShader("frag.glsl", "vert.glsl");
vertices = new float[12];
vertData = allocateDirectFloatBuffer(12);
colors = new float[12];
colorData = allocateDirectFloatBuffer(12);
vertices2 = new float[12];
vertData2 = allocateDirectFloatBuffer(12);
}
void draw() {
updateGeometry();
updateGeometry2();
background(0);
if(drawPGraphicsImage)
drawImage();
else
drawDirectly();
}
void keyPressed() {
if (key == ' ') {
drawPGraphicsImage = !drawPGraphicsImage;
}
else if (key == 'r') {
blend = !blend;
}
else if (key == 'a') {
if(alpha == 0.5f)
alpha = 1.0f;
else
alpha = 0.5f;
}
}
// This works as expected
void drawDirectly() {
pgl = beginPGL();
flatShader.bind();
vertLoc = pgl.getAttribLocation(flatShader.glProgram, "vertex");
colorLoc = pgl.getAttribLocation(flatShader.glProgram, "color");
pgl.enableVertexAttribArray(vertLoc);
pgl.enableVertexAttribArray(colorLoc);
pgl.vertexAttribPointer(vertLoc, 4, PGL.FLOAT, false, 0, vertData);
pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 0, colorData);
pgl.drawArrays(PGL.TRIANGLES, 0, 3);
pgl.disableVertexAttribArray(vertLoc);
pgl.disableVertexAttribArray(colorLoc);
flatShader.unbind();
endPGL();
pgl = beginPGL();
flatShader.bind();
vertLoc2 = pgl.getAttribLocation(flatShader.glProgram, "vertex");
colorLoc = pgl.getAttribLocation(flatShader.glProgram, "color");
pgl.enableVertexAttribArray(vertLoc2);
pgl.enableVertexAttribArray(colorLoc);
pgl.vertexAttribPointer(vertLoc2, 4, PGL.FLOAT, false, 0, vertData2);
pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 0, colorData);
pgl.drawArrays(PGL.TRIANGLES, 0, 3);
pgl.disableVertexAttribArray(vertLoc2);
pgl.disableVertexAttribArray(colorLoc);
flatShader.unbind();
endPGL();
}
// This is most likey a bug!
void drawImage() {
pg_1.beginDraw();
pg_1.clear();
pgl = pg_1.beginPGL();
flatShader.bind();
vertLoc = pgl.getAttribLocation(flatShader.glProgram, "vertex");
colorLoc = pgl.getAttribLocation(flatShader.glProgram, "color");
pgl.enableVertexAttribArray(vertLoc);
pgl.enableVertexAttribArray(colorLoc);
pgl.vertexAttribPointer(vertLoc, 4, PGL.FLOAT, false, 0, vertData);
pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 0, colorData);
pgl.drawArrays(PGL.TRIANGLES, 0, 3);
pgl.disableVertexAttribArray(vertLoc);
pgl.disableVertexAttribArray(colorLoc);
flatShader.unbind();
pg_1.endPGL();
pg_1.endDraw();
// pg_2:
pg_2.beginDraw();
pg_2.clear();
pgl = pg_2.beginPGL();
flatShader.bind();
vertLoc = pgl.getAttribLocation(flatShader.glProgram, "vertex");
colorLoc = pgl.getAttribLocation(flatShader.glProgram, "color");
pgl.enableVertexAttribArray(vertLoc);
pgl.enableVertexAttribArray(colorLoc);
pgl.vertexAttribPointer(vertLoc, 4, PGL.FLOAT, false, 0, vertData2);
pgl.vertexAttribPointer(colorLoc, 4, PGL.FLOAT, false, 0, colorData);
pgl.drawArrays(PGL.TRIANGLES, 0, 3);
pgl.disableVertexAttribArray(vertLoc);
pgl.disableVertexAttribArray(colorLoc);
flatShader.unbind();
pg_2.endPGL();
pg_2.endDraw();
// output pg_1 to screen
image(pg_1, 0, 0, 800, 800);
if(blend)
blendMode(BLEND);
else
blendMode(REPLACE);
// output rotated pg_2 to screen
image(pg_2, 0, 0, 800, 800);
blendMode(BLEND);
}
void updateGeometry() {
// Vertex 1
vertices[0] = 0;
vertices[1] = 0;
vertices[2] = 0;
vertices[3] = 1;
colors[0] = 1;
colors[1] = 0;
colors[2] = 0;
colors[3] = alpha;
// Corner 2
vertices[4] = width/2;
vertices[5] = height;
vertices[6] = 0;
vertices[7] = 1;
colors[4] = 0;
colors[5] = 1;
colors[6] = 0;
colors[7] = alpha;
// Corner 3
vertices[8] = width;
vertices[9] = 0;
vertices[10] = 0;
vertices[11] = 1;
colors[8] = 0;
colors[9] = 0;
colors[10] = 1;
colors[11] = alpha;
vertData.rewind();
vertData.put(vertices);
vertData.position(0);
colorData.rewind();
colorData.put(colors);
colorData.position(0);
}
void updateGeometry2() {
// Vertex 1
vertices2[0] = width;
vertices2[1] = height;
vertices2[2] = 0;
vertices2[3] = 1;
// Corner 2
vertices2[4] = 0;
vertices2[5] = height;
vertices2[6] = 0;
vertices2[7] = 1;
// Corner 3
vertices2[8] = width/2;
vertices2[9] = 0;
vertices2[10] = 0;
vertices2[11] = 1;
vertData2.rewind();
vertData2.put(vertices2);
vertData2.position(0);
}
FloatBuffer allocateDirectFloatBuffer(int n) {
return ByteBuffer.allocateDirect(n * Float.SIZE/8).order(ByteOrder.nativeOrder()).asFloatBuffer();
}

andres

Re: Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

29 days ago

blendMode(BLEND) (which is the default blending mode in P2D and P3D) just calls glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA). However, I think that a problem in your code is that the triangle pixels are being alpha-blended twice, first with the black background in the pg object and then with the main surface, and this leads to a fainter color.

If we follow the notation of the article on blending from the opengl wiki, the alpha value of the triangle pixels in the pg surfaces would be:

Oa = sa * Sa + da * Da

where sa = Sa = 0.5, da = 1 - 0.5, Da = 0, because the source and destination blending factors are the source alpha and one minus source alpha (the equation above) and source alpha is simply the alpha of the triangles. So you get:

Oa = 0.25

Is this correct?

onar3d

Re: Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

28 days ago

Hi, thank you for the quick and thorough reply!

From your response and from reading the link, I see what is going on now, and I see two options for getting what I'm after:

A: knowing from advance the number of times the drawing will be made, and calculate an initial alpha value to counter that, so that the final transparency is the desired one, in this case 0.5.

B: from reading the OpenGL wiki article, I found a mention of this:

It is often useful to perform premultiplied alpha blending. This means that texture values have multiplied the alpha with the texel before accessing it (or in the shader). So you don't want to multiply the source color by the source alpha, as this has already been done for you by the texture. So the setup for this is as follows:

glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
glBlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);

...which to me sounds like what I'm after. While I made some attempts to make use of these functions before drawing my images it didn't work, obviously(?) because Processing is doing a lot behind the scenes which prevents jumping back and forth between opengl calls and Processing calls.

The last thing that I might do, is fetch and read the relevant code of Processing 2.0.2, since it does something wrong, but closer to what I want for some reason, probably due to a bug in blendMode that has since been fixed in 2.0.3 :)

Also thank you for not telling me to STFU and RTFM but instead giving me a good reply when of course what I've been talking about is not a bug at all, your pedagogic attitude is what makes Processing's forum a good place to be at!

Best,
Onar3D

andres

Re: Drawing OpenGL into PGraphics with alpha 0.5f produces extremely faint output, more like 0.1f

28 days ago

The blending calculations that the renderer does behind the scenes are quite straightforward, if you look at the blendModeImpl() function in PGraphicsOpenGL all it does is basically to call glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA), so you should be able to define your own custom blending mode by using those other gl calls, maybe there is something else you need to do in the shader code? I can look at it in more detail later.

Top Reply