OpenGL Subtract Blend Functions?

#1 Edit #2: How about trying 0x800A for GL_FUNC_SUBTRACT_EXT and
0x800B for GL_FUNC_REVERSE_SUBTRACT_EXT?

Edit: oh.... just read the posts, these are not the droids you're looking for..

Are you looking for this:

SceneObject::setBlendMode(bool)//true=on false=off
SceneObject::setSrcBlendFactor(const char)
SceneObject::setDstBlendFactor(const char)

//source enums
/*
ZERO
ONE
DST_COLOR
ONE_MINUS_DST_COLOR
SRC_ALPHA
ONE_MINUS_SRC_ALPHA
DST_ALPHA
ONE_MINUS_DST_ALPHA
SRC_ALPHA_SATURATE
*/
//destination enums
/*
ZERO
ONE
SRC_COLOR
ONE_MINUS_SRC_COLOR
SRC_ALPHA
ONE_MINUS_SRC_ALPHA
DST_ALPHA
ONE_MINUS_DST_ALPHA
*/

More info is located within the sceneobject source.

#2 And, just to be a jerk I'll point out that these are not addresses, just values:

#define GL_FUNC_ADD             0x8006  
#define GL_FUNC_SUBTRACT            0x800A  
#define GL_FUNC_REVERSE_SUBTRACT        0x800B  
#define GL_BLEND_COLOR              0x8005

They're really just mnemonic devices so that when you call OpenGL functions you can use GL_FUNC_ADD instead of trying to remember what 0x8006 means. This might have been better implemented as an enumeration, but I guess there was some reason for this method instead.

Additionally, I don't think you're looking specifically for a "subtract" function, probably should be looking for a "blend" function that takes that GL_FUNC_SUBTRACT value as a parameter. At least it's not T3D so you don't have to dig through piles of shaders too!

#3 All exposed GL functions are simply the address of the function within the OpenGL.dll or library.

If you search through all files in the solution, you'll see that such variables are used throughout the code, mainly nestled into important rendering functions.

For instance, in Torque2D/graphics/ImageAsset.h :

inline const void bindImageTexture( void){ glBindTexture( GL_TEXTURE_2D, getImageTexture().getGLName() ); };

As long as you know the OpenGL call you wish to make, you'll "simply" have to dig around the code to see where that function makes sense.

I am by no means an OpenGL expert and the windows implementation can get quite confusing.

#4 Found this nifty little tool to test all OpenGL blending functions!
www.andersriggelsen.dk/glblendfunc.php

#5 Nice find Simon, I'll add that to the blending guide.

#6 Can't believe I never found this before.

Going back to the 'fog-of-war' problem, the method you have found (Mike) works well, until you add more sprites to different layers, as they all get modulated by the colors of items beneath(father away from) them!

The Substract functionality that Chase has been after really tickles me, I will definitely try to investigate this issue.

#7 practicing: That's the first place I started looking :P I had hoped some combination of layers and values would allow for the transparency effect I wanted, but it was not so.

Richard: Thanks for clearing that up for me. I have no experience working with dlls :/

Simon: That page looks really good as an example of what I've been looking for! For my own example in the other thread, I'm hoping to have the top two layers of my scene be darkness and the layer that creates the holes in the darkness to show what's underneath. And you are right, the problem with Mike's solution is that everything underneath gets affected. Hopefully you will have better luck than I have on figuring out what to do next.

Edit: A good example of what I mean in Simon's link:
foreground: ONE_MINUS_SOURCE_ALPHA
Background: Gl_SRC_ALPHA
Blend Equation: GL_FUNC_REVERSE_SUBTRACT

I'm not sure how that will work with more layers, but at the moment it seems like a good example.

#8 I don't have time to play with this further, but if source changing is being discussed - what about adding a blending layer bitmask that works similar to the collision layer bitmask where you can specify certain layers to blend with each other and any other layer gets ignored?

#9 I COMPLETELY second Mike's request.

#10 Not quite a request :) I am just throwing the idea out there. Another thing to check is what happens to objects, that you don't want to be affected, when you turn their blending mode off. Also remember that the blending factors are always controlled by the source (foreground) object.