Implement EXT_blend_minmax.

extensions/EXT_blend_minmax.txt

+Name
+
+    EXT_blend_minmax
+
+Name Strings
+
+    GL_EXT_blend_minmax
+
+Version
+
+    Last Modified Date: September 17, 2009
+    Version:            1.5
+
+Number
+
+    OpenGL Extension #37
+    OpenGL ES Extension #65
+
+Dependencies
+
+    There is an interaction with OpenGL ES.
+
+Overview
+
+    Blending capability is extended by respecifying the entire blend
+    equation.  While this document defines only two new equations, the
+    BlendEquationEXT procedure that it defines will be used by subsequent
+    extensions to define additional blending equations.
+
+    The two new equations defined by this extension produce the minimum
+    (or maximum) color components of the source and destination colors.
+    Taking the maximum is useful for applications such as maximum projection
+    in medical imaging.
+
+Issues
+
+    *   I've prefixed the ADD token with FUNC, to indicate that the blend
+        equation includes the parameters specified by BlendFunc.  (The min
+        and max equations don't.)  Is this necessary?  Is it too ugly?
+        Is there a better way to accomplish the same thing?
+    
+New Procedures and Functions
+
+    void BlendEquationEXT(enum mode);
+
+New Tokens
+
+    Accepted by the <mode> parameter of BlendEquationEXT:
+
+        FUNC_ADD_EXT                     0x8006
+        MIN_EXT                          0x8007
+        MAX_EXT                          0x8008
+
+    Accepted by the <pname> parameter of GetBooleanv, GetIntegerv,
+    GetFloatv, and GetDoublev:
+
+        BLEND_EQUATION_EXT               0x8009
+
+Additions to Chapter 2 of the GL Specification (OpenGL Operation)
+
+    None
+
+Additions to Chapter 3 of the GL Specification (Rasterization)
+
+    None
+
+Additions to Chapter 4 of the GL Specification (Per-Fragment Operations
+and the Framebuffer)
+
+    The GL Specification defines a single blending equation.  This
+    extension introduces a blend equation mode that is specified by calling
+    BlendEquationEXT with one of three enumerated values.  The default
+    value FUNC_ADD_EXT specifies that the blending equation defined in
+    the GL Specification be used.  This equation is
+
+        C' = (Cs * S) + (Cd * D)
+
+             /  1.0     C' > 1.0
+        C = (
+             \   C'     C' <= 1.0
+
+    where Cs and Cd are the source and destination colors, and S and D are
+    as specified by BlendFunc.
+
+    If BlendEquationEXT is called with <mode> set to MIN_EXT, the
+    blending equation becomes
+
+        C = min (Cs, Cd)
+
+    Finally, if BlendEquationEXT is called with <mode> set to MAX_EXT, the
+    blending equation becomes
+
+        C = max (Cs, Cd)
+
+    In all cases the blending equation is evaluated separately for each
+    color component.
+
+Additions to Chapter 5 of the GL Specification (Special Functions)
+
+    None
+
+Additions to Chapter 6 of the GL Specification (State and State Requests)
+
+    None
+
+Additions to the GLX Specification
+
+    None
+
+GLX Protocol
+
+    A new GL rendering command is added. The following command is sent to the 
+    server as part of a glXRender request:
+
+        BlendEquationEXT
+            2           8               rendering command length
+            2           4097            rendering command opcode
+            4           ENUM            mode
+
+Dependencies on OpenGL ES
+
+    If the GL is OpenGL ES, only the new MIN_EXT and MAX_EXT blend equations
+    are introduced by this extension.  BlendEquationOES, FUNC_ADD_OES, and
+    BLEND_EQUATION_OES are introduced by the OES_blend_subtract extension,
+    which is required for this extension to operate.  Alternatively,
+    OpenGL ES 2.0 is required, which introduces BlendEquation, FUNC_ADD, and
+    BLEND_EQUATION without the suffixes.
+
+    MIN_EXT and MAX_EXT should be added to Table 4.blendeq described in the
+    OES_blend_subtract extension specification, and Table 4.1 of the OpenGL
+    ES 2.0 specification.
+
+    Mentions of GetDoublev, Begin/End, and GLX in this extension specification
+    can be ignored for OpenGL ES.  Also, BlendEquationEXT and FUNC_ADD_EXT
+    instead have the OES suffix courtesy of OES_blend_subtract, or no suffix
+    courtesy of core OpenGL ES 2.0.
+
+Errors
+
+    INVALID_ENUM is generated by BlendEquationEXT if its single parameter
+    is not FUNC_ADD_EXT, MIN_EXT, or MAX_EXT.
+
+    INVALID_OPERATION is generated if BlendEquationEXT is executed between
+    the execution of Begin and the corresponding execution to End.
+
+New State
+
+    Get Value           Get Command     Type    Initial Value   Attribute
+    ---------           -----------     ----    -------------   ---------
+    BLEND_EQUATION_EXT  GetIntegerv     Z3      FUNC_ADD_EXT    color-buffer
+
+New Implementation Dependent State
+
+    None
+
+Revision History
+
+    Version 1.5, September 17, 2009 (Jon Leech) -
+        Merge into OpenGL Registry version of the extension and assign
+        OpenGL ES extension number.
+    Version 1.4, May 19, 2009 (Benj Lipchak) -
+        Adapted for OpenGL ES.
+    Version 1.3, May 31, 1995 -
+        Last SGI revision.

src/libGLESv2/Context.cpp

@@ -3710,6 +3710,7 @@ void Context::initExtensionString()
 
         mExtensionStringList.push_back("GL_EXT_texture_storage");
         mExtensionStringList.push_back("GL_EXT_frag_depth");
+        mExtensionStringList.push_back("GL_EXT_blend_minmax");
 
         // ANGLE-specific extensions
         if (supportsDepthTextures())

src/libGLESv2/libGLESv2.cpp

@@ -384,14 +384,8 @@ void __stdcall glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
           case GL_FUNC_ADD:
           case GL_FUNC_SUBTRACT:
           case GL_FUNC_REVERSE_SUBTRACT:
-            break;
-
           case GL_MIN:
           case GL_MAX:
-            if (context && context->getClientVersion() < 3)
-            {
-                return gl::error(GL_INVALID_ENUM);
-            }
             break;
 
           default:
@@ -403,14 +397,8 @@ void __stdcall glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
           case GL_FUNC_ADD:
           case GL_FUNC_SUBTRACT:
           case GL_FUNC_REVERSE_SUBTRACT:
-            break;
-
           case GL_MIN:
           case GL_MAX:
-            if (context && context->getClientVersion() < 3)
-            {
-                return gl::error(GL_INVALID_ENUM);
-            }
             break;
 
           default:

src/libGLESv2/renderer/d3d9/renderer9_utils.cpp

@@ -83,6 +83,8 @@ D3DBLENDOP ConvertBlendOp(GLenum blendOp)
       case GL_FUNC_ADD:              d3dBlendOp = D3DBLENDOP_ADD;         break;
       case GL_FUNC_SUBTRACT:         d3dBlendOp = D3DBLENDOP_SUBTRACT;    break;
       case GL_FUNC_REVERSE_SUBTRACT: d3dBlendOp = D3DBLENDOP_REVSUBTRACT; break;
+      case GL_MIN_EXT:               d3dBlendOp = D3DBLENDOP_MIN;         break;
+      case GL_MAX_EXT:               d3dBlendOp = D3DBLENDOP_MAX;         break;
       default: UNREACHABLE();
     }
 

tests/angle_tests/ANGLETest.h

@@ -19,10 +19,10 @@
 #include <EGL/eglext.h>
 #include <algorithm>
 
-#define EXPECT_GL_ERROR(err) EXPECT_EQ(glGetError(), (err))
+#define EXPECT_GL_ERROR(err) EXPECT_EQ((err), glGetError())
 #define EXPECT_GL_NO_ERROR() EXPECT_GL_ERROR(GL_NO_ERROR)
 
-#define ASSERT_GL_ERROR(err) EXPECT_EQ(glGetError(), (err))
+#define ASSERT_GL_ERROR(err) ASSERT_EQ((err), glGetError())
 #define ASSERT_GL_NO_ERROR() ASSERT_GL_ERROR(GL_NO_ERROR)
 
 #define EXPECT_PIXEL_EQ(x, y, r, g, b, a) \
@@ -30,10 +30,10 @@
     GLubyte pixel[4]; \
     glReadPixels((x), (y), 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixel); \
     EXPECT_GL_NO_ERROR(); \
-    EXPECT_EQ(pixel[0], (r)); \
-    EXPECT_EQ(pixel[1], (g)); \
-    EXPECT_EQ(pixel[2], (b)); \
-    EXPECT_EQ(pixel[3], (a)); \
+    EXPECT_EQ((r), pixel[0]); \
+    EXPECT_EQ((g), pixel[1]); \
+    EXPECT_EQ((b), pixel[2]); \
+    EXPECT_EQ((a), pixel[3]); \
 }
 
 #define SHADER_SOURCE(...) #__VA_ARGS__

tests/angle_tests/BlendMinMaxTest.cpp

+#include "ANGLETest.h"
+
+class BlendMinMaxTest : public ANGLETest
+{
+protected:
+    BlendMinMaxTest()
+    {
+        setWindowWidth(128);
+        setWindowHeight(128);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+        setConfigDepthBits(24);
+
+        mProgram = 0;
+        mColorLocation = -1;
+    }
+
+    struct Color
+    {
+        float values[4];
+    };
+
+    static GLubyte getExpected(bool blendMin, float curColor, GLubyte prevColor)
+    {
+        GLubyte curAsUbyte = (curColor * std::numeric_limits<GLubyte>::max()) + 0.5f;
+        return blendMin ? std::min<GLubyte>(curAsUbyte, prevColor) : std::max<GLubyte>(curAsUbyte, prevColor);
+    }
+
+    void runTest()
+    {
+        const size_t colorCount = 1024;
+        Color colors[colorCount];
+        for (size_t i = 0; i < colorCount; i++)
+        {
+            for (size_t j = 0; j < 4; j++)
+            {
+                colors[i].values[j] = (rand() % 255) / 255.0f;
+            }
+        }
+
+        GLubyte prevColor[4];
+        for (size_t i = 0; i < colorCount; i++)
+        {
+            const Color &color = colors[i];
+            glUseProgram(mProgram);
+            glUniform4f(mColorLocation, color.values[0], color.values[1], color.values[2], color.values[3]);
+
+            bool blendMin = (rand() % 2 == 0);
+            glBlendEquation(blendMin ? GL_MIN : GL_MAX);
+
+            drawQuad(mProgram, "aPosition", 0.5f);
+
+            if (i > 0)
+            {
+                EXPECT_PIXEL_EQ(0, 0,
+                                getExpected(blendMin, color.values[0], prevColor[0]),
+                                getExpected(blendMin, color.values[1], prevColor[1]),
+                                getExpected(blendMin, color.values[2], prevColor[2]),
+                                getExpected(blendMin, color.values[3], prevColor[3]));
+            }
+
+            glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, prevColor);
+        }
+    }
+
+    virtual void SetUp()
+    {
+        ANGLETest::SetUp();
+
+        const std::string testVertexShaderSource = SHADER_SOURCE
+        (
+            attribute highp vec4 aPosition;
+
+            void main(void)
+            {
+                gl_Position = aPosition;
+            }
+        );
+
+        const std::string testFragmentShaderSource = SHADER_SOURCE
+        (
+            uniform highp vec4 color;
+            void main(void)
+            {
+                gl_FragColor = color;
+            }
+        );
+
+        mProgram = compileProgram(testVertexShaderSource, testFragmentShaderSource);
+        if (mProgram == 0)
+        {
+            FAIL() << "shader compilation failed.";
+        }
+
+        mColorLocation = glGetUniformLocation(mProgram, "color");
+
+        glUseProgram(mProgram);
+
+        glClearColor(0, 0, 0, 0);
+        glClearDepthf(0.0);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        glEnable(GL_BLEND);
+        glDisable(GL_DEPTH_TEST);
+    }
+
+    void SetUpFramebuffer(GLenum colorFormat)
+    {
+        glGenFramebuffers(1, &mFramebuffer);
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, mFramebuffer);
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, mFramebuffer);
+
+        glGenRenderbuffers(1, &mColorRenderbuffer);
+        glBindRenderbuffer(GL_RENDERBUFFER, mColorRenderbuffer);
+        glRenderbufferStorage(GL_RENDERBUFFER, colorFormat, getWindowWidth(), getWindowHeight());
+        glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, mColorRenderbuffer);
+
+        ASSERT_GL_NO_ERROR();
+    }
+
+    virtual void TearDown()
+    {
+        glDeleteProgram(mProgram);
+        glDeleteFramebuffers(1, &mFramebuffer);
+        glDeleteRenderbuffers(1, &mColorRenderbuffer);
+
+        ANGLETest::TearDown();
+    }
+
+    GLuint mProgram;
+    GLint mColorLocation;
+
+    GLuint mFramebuffer;
+    GLuint mColorRenderbuffer;
+};
+
+TEST_F(BlendMinMaxTest, rgba8)
+{
+    SetUpFramebuffer(GL_RGBA8);
+    runTest();
+}
+
+TEST_F(BlendMinMaxTest, rgba32f)
+{
+    SetUpFramebuffer(GL_RGBA32F);
+    runTest();
+}
+
+TEST_F(BlendMinMaxTest, rgba16f)
+{
+    SetUpFramebuffer(GL_RGBA16F);
+    runTest();
+}