[1.6.4] Flickering transparency using GL11.GL_BLEND

[lexwebb]

I have an odd issue when anything i render using GL11.GL_BLEND will become transparent and nontransparent depending on which way you look at it. An example can be seen in the video below. where the item in my hand will randomly switch states.

 

 

The whole structure next to is meant to be transparent to. And look like this. but at the time of recording it was refusing to render transparent at all.

 

 

Some sample render code:

 

@Override
public void renderInventoryBlock(Block block, int metadata, int modelID,
		RenderBlocks renderer) {

	GL11.glPushMatrix();

	GL11.glTranslatef(0.0f, 1.4f, 0.0f);

	ResourceLocation textures = (new ResourceLocation(ModInfo.ID.toLowerCase() + ":textures/blocks/ColliderPipeCornerTile.png")); 
	Minecraft.getMinecraft().renderEngine.bindTexture(textures);
                   
     	GL11.glPushMatrix();

        GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);

        this.model.renderFrame((Entity)null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
        
        GL11.glEnable(GL11.GL_BLEND);       
        this.model.renderPipe((Entity)null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
        GL11.glDisable(GL11.GL_BLEND);

        GL11.glPopMatrix();
        GL11.glPopMatrix();
}

[Draco18s]

Private video is private.

 

Anyway, try setting a color, GL11.glColor_f(1, 1, 1, 1)

[lexwebb]

Opps! Try now!

 

I've added the color and and another piece of code i found elsewhere. (See code below below) now it kinda works...

 

 

GL11.glEnable(GL11.GL_BLEND); 
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
        GL11.glColor4f(1, 1, 1, 1);
        this.model.renderPipe((Entity)null, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
        GL11.glDisable(GL11.GL_BLEND);

[lexwebb]

Bump !

[Draco18s]

Unfortunately I am not sure at this point.

[shadowmage4513]

I've always used the blend function of:

 

GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

 

I'm not an expert, and am not really sure of the difference between the two, but that is the function that has worked well for me in all of my code that deals with transparency.

[WorldsEnder]

Maybe I can enlighten a you a bit when it comes to blend functions.

How it works:

 

Before a face with an alpha value is rendered let there be already existing background on your screen. We'll call the screenplane which openGL paints on "destination pane" (normally you don't speak of a plane but of a framebuffer but you can think of it as a canvas).

 

What happens now is that openGL doesn't directly paint ontop of the already existing stuff. Instead think about taking a new canvas and paint you face on this one. Let's call it "source pane".

 

For the computer of course colors aren't colors. They are Integers and are represented in the "rgb"-colorscheme (red, green, blue). To add transparancy we need a forth number, the alpha-value. For every pixel on value is saved for red, green, blue and alpha (rgba). The effectiva range is [0...1] from "not there" to "all of it".

 

But now you have two different planes! How does this get merged into one? This is where the blending-function blends in. You call GL11.glBlendFunc(sScale, dScale). The function takes two arguments of the exact same "type" (openGL-constants of a specific type, for you they appear as ints but openGL interprets them). When you look at the documentation ( https://www.opengl.org/sdk/docs/man4/xhtml/glBlendFunc.xml ) you see that you can actually pass any of

                    GL_ZERO,

                    GL_ONE,

                    GL_SRC_COLOR,

                    GL_ONE_MINUS_SRC_COLOR,

                    GL_DST_COLOR,

                    GL_ONE_MINUS_DST_COLOR,

                    GL_SRC_ALPHA,

                    GL_ONE_MINUS_SRC_ALPHA,

                    GL_DST_ALPHA,

                    GL_ONE_MINUS_DST_ALPHA.

                    GL_CONSTANT_COLOR,

                    GL_ONE_MINUS_CONSTANT_COLOR,

                    GL_CONSTANT_ALPHA, and

                    GL_ONE_MINUS_CONSTANT_ALPHA

 

What now happens is that the colors on the destination plane are mulitplied by a factor related to the GL-constant you passed, the dScale. For GL_ONE this factor is 1. For GL_ONE_MINUS_SRC_ALPHA this factor is (1-alphaOnSourcePlane) etc.

This is done for the source-plane, too, but with the sScale parameter instead of dScale. Then the resulting source-values just get add ontop of the existing destination colors.

 

Here you can see why GL_ONE is a bit worse than GL_ONE_MINUS_SRC_ALPHA but doesn't look bad after all:

If you can reacall if you use GL_ONE the color after painting the plane would be something like dColor*1+sColor*sValue. This value will always be greater than before and the world "behind the glass/transparent whatever" would not get filtered any bit.

With GL_ONE_MINUS_SRC_ALPHA the equation is about dColor*(1-sValue)+sColor*sValue meaning that the dColor (existing color) gets reduced by a little bit as much as the material you draw is NOT transparent.

 

I hope this can help you figuring it out in your mind Keep up the modding, the pipes look awesome.