ES31: Add PROGRAM_SEPARABLE to ProgramParameter and GetProgram

src/libANGLE/Context.cpp

@@ -2340,10 +2340,7 @@ void Context::getSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *param
 void Context::programParameteri(GLuint program, GLenum pname, GLint value)
 {
     gl::Program *programObject = getProgram(program);
-    ASSERT(programObject != nullptr);
-
-    ASSERT(pname == GL_PROGRAM_BINARY_RETRIEVABLE_HINT);
-    programObject->setBinaryRetrievableHint(value != GL_FALSE);
+    SetProgramParameteri(programObject, pname, value);
 }
 
 void Context::initRendererString()

src/libANGLE/Program.cpp

@@ -1095,6 +1095,21 @@ bool Program::getBinaryRetrievableHint() const
     return mState.mBinaryRetrieveableHint;
 }
 
+void Program::setSeparable(bool separable)
+{
+    // TODO(yunchao) : replace with dirty bits
+    if (mState.mSeparable != separable)
+    {
+        mProgram->setSeparable(separable);
+        mState.mSeparable = separable;
+    }
+}
+
+bool Program::isSeparable() const
+{
+    return mState.mSeparable;
+}
+
 void Program::release(const Context *context)
 {
     mRefCount--;

src/libANGLE/Program.h

@@ -257,6 +257,7 @@ class ProgramState final : angle::NonCopyable
     std::map<int, VariableLocation> mOutputLocations;
 
     bool mBinaryRetrieveableHint;
+    bool mSeparable;
 };
 
 class Program final : angle::NonCopyable, public LabeledObject
@@ -308,6 +309,9 @@ class Program final : angle::NonCopyable, public LabeledObject
     void setBinaryRetrievableHint(bool retrievable);
     bool getBinaryRetrievableHint() const;
 
+    void setSeparable(bool separable);
+    bool isSeparable() const;
+
     int getInfoLogLength() const;
     void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const;
     void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders) const;

src/libANGLE/queryutils.cpp

@@ -605,6 +605,9 @@ void QueryProgramiv(const Program *program, GLenum pname, GLint *params)
         case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
             *params = program->getBinaryRetrievableHint();
             break;
+        case GL_PROGRAM_SEPARABLE:
+            *params = program->isSeparable();
+            break;
         default:
             UNREACHABLE();
             break;
@@ -939,6 +942,24 @@ void SetFramebufferParameteri(Framebuffer *framebuffer, GLenum pname, GLint para
     }
 }
 
+void SetProgramParameteri(Program *program, GLenum pname, GLint value)
+{
+    ASSERT(program);
+
+    switch (pname)
+    {
+        case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
+            program->setBinaryRetrievableHint(value != GL_FALSE);
+            break;
+        case GL_PROGRAM_SEPARABLE:
+            program->setSeparable(value != GL_FALSE);
+            break;
+        default:
+            UNREACHABLE();
+            break;
+    }
+}
+
 GLuint QueryProgramResourceIndex(const Program *program,
                                  GLenum programInterface,
                                  const GLchar *name)

src/libANGLE/queryutils.h

@@ -107,6 +107,8 @@ void SetSamplerParameteriv(Sampler *sampler, GLenum pname, const GLint *params);
 
 void SetFramebufferParameteri(Framebuffer *framebuffer, GLenum pname, GLint param);
 
+void SetProgramParameteri(Program *program, GLenum pname, GLint value);
+
 GLuint QueryProgramResourceIndex(const Program *program,
                                  GLenum programInterface,
                                  const GLchar *name);

src/libANGLE/renderer/ProgramImpl.h

@@ -45,6 +45,7 @@ class ProgramImpl : angle::NonCopyable
                             gl::BinaryInputStream *stream)  = 0;
     virtual gl::Error save(gl::BinaryOutputStream *stream) = 0;
     virtual void setBinaryRetrievableHint(bool retrievable) = 0;
+    virtual void setSeparable(bool separable)               = 0;
 
     virtual LinkResult link(ContextImpl *contextImpl,
                             const gl::VaryingPacking &packing,

src/libANGLE/renderer/ProgramImpl_mock.h

@@ -26,6 +26,7 @@ class MockProgramImpl : public rx::ProgramImpl
     MOCK_METHOD3(load, LinkResult(const ContextImpl *, gl::InfoLog &, gl::BinaryInputStream *));
     MOCK_METHOD1(save, gl::Error(gl::BinaryOutputStream *));
     MOCK_METHOD1(setBinaryRetrievableHint, void(bool));
+    MOCK_METHOD1(setSeparable, void(bool));
 
     MOCK_METHOD3(link, LinkResult(ContextImpl *, const gl::VaryingPacking &, gl::InfoLog &));
     MOCK_METHOD2(validate, GLboolean(const gl::Caps &, gl::InfoLog *));

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -1128,6 +1128,10 @@ void ProgramD3D::setBinaryRetrievableHint(bool /* retrievable */)
 {
 }
 
+void ProgramD3D::setSeparable(bool /* separable */)
+{
+}
+
 gl::Error ProgramD3D::getPixelExecutableForFramebuffer(const gl::Framebuffer *fbo,
                                                        ShaderExecutableD3D **outExecutable)
 {

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -163,6 +163,7 @@ class ProgramD3D : public ProgramImpl
                     gl::BinaryInputStream *stream) override;
     gl::Error save(gl::BinaryOutputStream *stream) override;
     void setBinaryRetrievableHint(bool retrievable) override;
+    void setSeparable(bool separable) override;
 
     gl::Error getPixelExecutableForFramebuffer(const gl::Framebuffer *fbo,
                                                ShaderExecutableD3D **outExectuable);

src/libANGLE/renderer/gl/ProgramGL.cpp

@@ -111,6 +111,11 @@ void ProgramGL::setBinaryRetrievableHint(bool retrievable)
     }
 }
 
+void ProgramGL::setSeparable(bool separable)
+{
+    mFunctions->programParameteri(mProgramID, GL_PROGRAM_SEPARABLE, separable ? GL_TRUE : GL_FALSE);
+}
+
 LinkResult ProgramGL::link(ContextImpl *contextImpl,
                            const gl::VaryingPacking &packing,
                            gl::InfoLog &infoLog)

src/libANGLE/renderer/gl/ProgramGL.h

@@ -36,6 +36,7 @@ class ProgramGL : public ProgramImpl
                     gl::BinaryInputStream *stream) override;
     gl::Error save(gl::BinaryOutputStream *stream) override;
     void setBinaryRetrievableHint(bool retrievable) override;
+    void setSeparable(bool separable) override;
 
     LinkResult link(ContextImpl *contextImpl,
                     const gl::VaryingPacking &packing,

src/libANGLE/renderer/null/ProgramNULL.cpp

@@ -38,6 +38,10 @@ void ProgramNULL::setBinaryRetrievableHint(bool retrievable)
 {
 }
 
+void ProgramNULL::setSeparable(bool separable)
+{
+}
+
 LinkResult ProgramNULL::link(ContextImpl *contextImpl,
                              const gl::VaryingPacking &packing,
                              gl::InfoLog &infoLog)

src/libANGLE/renderer/null/ProgramNULL.h

@@ -26,6 +26,7 @@ class ProgramNULL : public ProgramImpl
                     gl::BinaryInputStream *stream) override;
     gl::Error save(gl::BinaryOutputStream *stream) override;
     void setBinaryRetrievableHint(bool retrievable) override;
+    void setSeparable(bool separable) override;
 
     LinkResult link(ContextImpl *contextImpl,
                     const gl::VaryingPacking &packing,

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -53,6 +53,11 @@ void ProgramVk::setBinaryRetrievableHint(bool retrievable)
     UNIMPLEMENTED();
 }
 
+void ProgramVk::setSeparable(bool separable)
+{
+    UNIMPLEMENTED();
+}
+
 LinkResult ProgramVk::link(ContextImpl *contextImpl,
                            const gl::VaryingPacking &packing,
                            gl::InfoLog &infoLog)

src/libANGLE/renderer/vulkan/ProgramVk.h

@@ -28,6 +28,7 @@ class ProgramVk : public ProgramImpl
                     gl::BinaryInputStream *stream) override;
     gl::Error save(gl::BinaryOutputStream *stream) override;
     void setBinaryRetrievableHint(bool retrievable) override;
+    void setSeparable(bool separable) override;
 
     LinkResult link(ContextImpl *contextImpl,
                     const gl::VaryingPacking &packing,

src/libANGLE/validationES.cpp

@@ -5191,6 +5191,14 @@ bool ValidateGetProgramiv(Context *context, GLuint program, GLenum pname, GLsize
             }
             break;
 
+        case GL_PROGRAM_SEPARABLE:
+            if (context->getClientVersion() < Version(3, 1))
+            {
+                context->handleError(Error(GL_INVALID_ENUM, "Querying requires at least ES 3.1."));
+                return false;
+            }
+            break;
+
         default:
             context->handleError(Error(GL_INVALID_ENUM, "Unknown parameter name."));
             return false;

src/libANGLE/validationES3.cpp

@@ -1309,8 +1309,8 @@ static bool ValidateBindBufferCommon(Context *context,
         {
             if (context->getClientVersion() < ES_3_1)
             {
-                context->handleError(
-                    Error(GL_INVALID_ENUM, "ATOMIC_COUNTER_BUFFER is not supported in GLES3."));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "ATOMIC_COUNTER_BUFFER is not supported before GLES 3.1"));
                 return false;
             }
             if (index >= caps.maxAtomicCounterBufferBindings)
@@ -1331,8 +1331,8 @@ static bool ValidateBindBufferCommon(Context *context,
         {
             if (context->getClientVersion() < ES_3_1)
             {
-                context->handleError(
-                    Error(GL_INVALID_ENUM, "ATOMIC_COUNTER_BUFFER is not supported in GLES3."));
+                context->handleError(Error(
+                    GL_INVALID_ENUM, "ATOMIC_COUNTER_BUFFER is not supported before GLES 3.1"));
                 return false;
             }
             break;
@@ -1421,6 +1421,22 @@ bool ValidateProgramParameteri(Context *context, GLuint program, GLenum pname, G
             }
             break;
 
+        case GL_PROGRAM_SEPARABLE:
+            if (context->getClientVersion() < ES_3_1)
+            {
+                context->handleError(
+                    Error(GL_INVALID_ENUM, "PROGRAM_SEPARABLE is not supported before GLES 3.1"));
+                return false;
+            }
+
+            if (value != GL_FALSE && value != GL_TRUE)
+            {
+                context->handleError(Error(
+                    GL_INVALID_VALUE, "Invalid value, expected GL_FALSE or GL_TRUE: %i", value));
+                return false;
+            }
+            break;
+
         default:
             context->handleError(Error(GL_INVALID_ENUM, "Invalid pname: 0x%X", pname));
             return false;

src/tests/angle_end2end_tests.gypi

@@ -65,6 +65,7 @@
             '<(angle_path)/src/tests/gl_tests/OcclusionQueriesTest.cpp',
             '<(angle_path)/src/tests/gl_tests/ProgramBinaryTest.cpp',
             '<(angle_path)/src/tests/gl_tests/ProgramInterfaceTest.cpp',
+            '<(angle_path)/src/tests/gl_tests/ProgramParameterTest.cpp',
             '<(angle_path)/src/tests/gl_tests/ReadPixelsTest.cpp',
             '<(angle_path)/src/tests/gl_tests/RendererTest.cpp',
             '<(angle_path)/src/tests/gl_tests/RobustClientMemoryTest.cpp',

src/tests/gl_tests/ProgramParameterTest.cpp

+//
+// Copyright 2017 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// ProgramParameterTest: validate parameters of ProgramParameter
+
+#include "test_utils/ANGLETest.h"
+
+using namespace angle;
+
+namespace
+{
+
+class ProgramParameterTest : public ANGLETest
+{
+  protected:
+    ProgramParameterTest()
+    {
+        setWindowWidth(64);
+        setWindowHeight(64);
+        setConfigRedBits(8);
+        setConfigGreenBits(8);
+        setConfigBlueBits(8);
+        setConfigAlphaBits(8);
+    }
+};
+
+class ProgramParameterTestES31 : public ProgramParameterTest
+{
+  protected:
+    ProgramParameterTestES31() : ProgramParameterTest() {}
+};
+
+// If es version < 3.1, PROGRAM_SEPARABLE is not supported.
+TEST_P(ProgramParameterTest, ValidatePname)
+{
+    GLuint program = glCreateProgram();
+    ASSERT_NE(program, 0u);
+
+    glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+    ASSERT_GL_NO_ERROR();
+
+    glProgramParameteri(program, GL_PROGRAM_SEPARABLE, GL_TRUE);
+    if (getClientMajorVersion() < 3 || getClientMinorVersion() < 1)
+    {
+        ASSERT_GL_ERROR(GL_INVALID_ENUM);
+    }
+    else
+    {
+        ASSERT_GL_NO_ERROR();
+    }
+
+    glDeleteProgram(program);
+}
+
+// Validate parameters for ProgramParameter when pname is PROGRAM_SEPARABLE.
+TEST_P(ProgramParameterTestES31, ValidateParameters)
+{
+    GLuint program = glCreateProgram();
+    ASSERT_NE(program, 0u);
+
+    glProgramParameteri(0, GL_PROGRAM_SEPARABLE, GL_TRUE);
+    ASSERT_GL_ERROR(GL_INVALID_VALUE);
+
+    glProgramParameteri(program, GL_PROGRAM_SEPARABLE, 2);
+    ASSERT_GL_ERROR(GL_INVALID_VALUE);
+
+    glDeleteProgram(program);
+}
+
+ANGLE_INSTANTIATE_TEST(ProgramParameterTest,
+                       ES3_OPENGL(),
+                       ES3_OPENGLES(),
+                       ES3_D3D11(),
+                       ES31_OPENGL(),
+                       ES31_OPENGLES(),
+                       ES31_D3D11());
+ANGLE_INSTANTIATE_TEST(ProgramParameterTestES31, ES31_OPENGL(), ES31_OPENGLES(), ES31_D3D11());
+}