ES31: Implement creation and attaching geometry shader on OpenGL

include/GLSLANG/ShaderLang.h

@@ -598,6 +598,11 @@ bool GetUniformBlockRegister(const ShHandle handle,
 // Note that the map contains also registers of samplers that have been extracted from structs.
 const std::map<std::string, unsigned int> *GetUniformRegisterMap(const ShHandle handle);
 
+GLenum GetGeometryShaderInputPrimitiveType(const ShHandle handle);
+GLenum GetGeometryShaderOutputPrimitiveType(const ShHandle handle);
+int GetGeometryShaderInvocations(const ShHandle handle);
+int GetGeometryShaderMaxVertices(const ShHandle handle);
+
 }  // namespace sh
 
 #endif // GLSLANG_SHADERLANG_H_

src/compiler/translator/ShaderLang.cpp

@@ -112,6 +112,35 @@ TranslatorHLSL *GetTranslatorHLSLFromHandle(ShHandle handle)
 }
 #endif  // ANGLE_ENABLE_HLSL
 
+GLenum GetGeometryShaderPrimitiveTypeEnum(sh::TLayoutPrimitiveType primitiveType)
+{
+    switch (primitiveType)
+    {
+        case EptPoints:
+            return GL_POINTS;
+        case EptLines:
+            return GL_LINES;
+        case EptLinesAdjacency:
+            return GL_LINES_ADJACENCY_EXT;
+        case EptTriangles:
+            return GL_TRIANGLES;
+        case EptTrianglesAdjacency:
+            return GL_TRIANGLES_ADJACENCY_EXT;
+
+        case EptLineStrip:
+            return GL_LINE_STRIP;
+        case EptTriangleStrip:
+            return GL_TRIANGLE_STRIP;
+
+        case EptUndefined:
+            return GL_INVALID_VALUE;
+
+        default:
+            UNREACHABLE();
+            return GL_INVALID_VALUE;
+    }
+}
+
 }  // anonymous namespace
 
 //
@@ -501,4 +530,48 @@ const std::map<std::string, unsigned int> *GetUniformRegisterMap(const ShHandle
 #endif  // ANGLE_ENABLE_HLSL
 }
 
+GLenum GetGeometryShaderInputPrimitiveType(const ShHandle handle)
+{
+    ASSERT(handle);
+
+    TShHandleBase *base = static_cast<TShHandleBase *>(handle);
+    TCompiler *compiler = base->getAsCompiler();
+    ASSERT(compiler);
+
+    return GetGeometryShaderPrimitiveTypeEnum(compiler->getGeometryShaderInputPrimitiveType());
+}
+
+GLenum GetGeometryShaderOutputPrimitiveType(const ShHandle handle)
+{
+    ASSERT(handle);
+
+    TShHandleBase *base = static_cast<TShHandleBase *>(handle);
+    TCompiler *compiler = base->getAsCompiler();
+    ASSERT(compiler);
+
+    return GetGeometryShaderPrimitiveTypeEnum(compiler->getGeometryShaderOutputPrimitiveType());
+}
+
+int GetGeometryShaderInvocations(const ShHandle handle)
+{
+    ASSERT(handle);
+
+    TShHandleBase *base = static_cast<TShHandleBase *>(handle);
+    TCompiler *compiler = base->getAsCompiler();
+    ASSERT(compiler);
+
+    return compiler->getGeometryShaderInvocations();
+}
+
+int GetGeometryShaderMaxVertices(const ShHandle handle)
+{
+    ASSERT(handle);
+
+    TShHandleBase *base = static_cast<TShHandleBase *>(handle);
+    TCompiler *compiler = base->getAsCompiler();
+    ASSERT(compiler);
+
+    return compiler->getGeometryShaderMaxVertices();
+}
+
 }  // namespace sh

src/libANGLE/Caps.cpp

@@ -223,7 +223,10 @@ Extensions::Extensions()
       clientArrays(false),
       robustResourceInitialization(false),
       programCacheControl(false),
-      textureRectangle(false)
+      textureRectangle(false),
+      geometryShader(false),
+      maxGeometryOutputVertices(0),
+      maxGeometryShaderInvocations(0)
 {
 }
 
@@ -691,6 +694,7 @@ const ExtensionInfoMap &GetExtensionInfoMap()
         map["GL_ANGLE_robust_resource_initialization"] = esOnlyExtension(&Extensions::robustResourceInitialization);
         map["GL_ANGLE_program_cache_control"] = esOnlyExtension(&Extensions::programCacheControl);
         map["GL_ANGLE_texture_rectangle"] = enableableExtension(&Extensions::textureRectangle);
+        map["GL_EXT_geometry_shader"] = enableableExtension(&Extensions::geometryShader);
         // clang-format on
 
         return map;
@@ -840,7 +844,6 @@ Caps::Caps()
 
       // Table 20.49
       maxSamples(0)
-
 {
     for (size_t i = 0; i < 3; ++i)
     {

src/libANGLE/Caps.h

@@ -368,6 +368,14 @@ struct Extensions
 
     // GL_ANGLE_texture_rectangle
     bool textureRectangle;
+
+    // GL_EXT_geometry_shader
+    bool geometryShader;
+    // GL_EXT_geometry_shader (May 31, 2016) Table 20.43gs: Implementation dependent geometry shader
+    // limits
+    // TODO(jiawei.shao@intel.com): add all implementation dependent geometry shader limits.
+    GLuint maxGeometryOutputVertices;
+    GLuint maxGeometryShaderInvocations;
 };
 
 struct ExtensionInfo

src/libANGLE/Compiler.cpp

@@ -50,7 +50,8 @@ Compiler::Compiler(rx::GLImplFactory *implFactory, const ContextState &state)
       mResources(),
       mFragmentCompiler(nullptr),
       mVertexCompiler(nullptr),
-      mComputeCompiler(nullptr)
+      mComputeCompiler(nullptr),
+      mGeometryCompiler(nullptr)
 {
     ASSERT(state.getClientMajorVersion() == 2 || state.getClientMajorVersion() == 3);
 
@@ -129,6 +130,12 @@ Compiler::Compiler(rx::GLImplFactory *implFactory, const ContextState &state)
     {
         mResources.MaxDrawBuffers = 1;
     }
+
+    // Geometry Shader constants
+    mResources.OES_geometry_shader = extensions.geometryShader;
+    // TODO(jiawei.shao@intel.com): initialize all implementation dependent geometry shader limits.
+    mResources.MaxGeometryOutputVertices    = extensions.maxGeometryOutputVertices;
+    mResources.MaxGeometryShaderInvocations = extensions.maxGeometryShaderInvocations;
 }
 
 Compiler::~Compiler()
@@ -183,6 +190,9 @@ ShHandle Compiler::getCompilerHandle(GLenum type)
         case GL_COMPUTE_SHADER:
             compiler = &mComputeCompiler;
             break;
+        case GL_GEOMETRY_SHADER_EXT:
+            compiler = &mGeometryCompiler;
+            break;
         default:
             UNREACHABLE();
             return nullptr;

src/libANGLE/Compiler.h

@@ -43,6 +43,7 @@ class Compiler final : public RefCountObjectNoID
     ShHandle mFragmentCompiler;
     ShHandle mVertexCompiler;
     ShHandle mComputeCompiler;
+    ShHandle mGeometryCompiler;
 };
 
 }  // namespace gl

src/libANGLE/Context.cpp

@@ -2535,6 +2535,12 @@ void Context::initCaps(const egl::DisplayExtensions &displayExtensions, bool rob
         mExtensions.maxViews              = 1u;
     }
 
+    if (getClientVersion() < ES_3_1)
+    {
+        // Disable ES3.1+ extensions
+        mExtensions.geometryShader = false;
+    }
+
     if (getClientVersion() > Version(2, 0))
     {
         // FIXME(geofflang): Don't support EXT_sRGB in non-ES2 contexts

src/libANGLE/Program.cpp

@@ -430,6 +430,7 @@ ProgramState::ProgramState()
       mAttachedFragmentShader(nullptr),
       mAttachedVertexShader(nullptr),
       mAttachedComputeShader(nullptr),
+      mAttachedGeometryShader(nullptr),
       mTransformFeedbackBufferMode(GL_INTERLEAVED_ATTRIBS),
       mMaxActiveAttribLocation(0),
       mSamplerUniformRange(0, 0),
@@ -443,7 +444,8 @@ ProgramState::ProgramState()
 
 ProgramState::~ProgramState()
 {
-    ASSERT(!mAttachedVertexShader && !mAttachedFragmentShader && !mAttachedComputeShader);
+    ASSERT(!mAttachedVertexShader && !mAttachedFragmentShader && !mAttachedComputeShader &&
+           !mAttachedGeometryShader);
 }
 
 const std::string &ProgramState::getLabel()
@@ -541,10 +543,16 @@ void Program::onDestroy(const Context *context)
         mState.mAttachedComputeShader = nullptr;
     }
 
+    if (mState.mAttachedGeometryShader != nullptr)
+    {
+        mState.mAttachedGeometryShader->release(context);
+        mState.mAttachedGeometryShader = nullptr;
+    }
+
     mProgram->destroy(context);
 
     ASSERT(!mState.mAttachedVertexShader && !mState.mAttachedFragmentShader &&
-           !mState.mAttachedComputeShader);
+           !mState.mAttachedComputeShader && !mState.mAttachedGeometryShader);
     SafeDelete(mProgram);
 
     delete this;
@@ -585,6 +593,13 @@ void Program::attachShader(Shader *shader)
             mState.mAttachedComputeShader->addRef();
             break;
         }
+        case GL_GEOMETRY_SHADER_EXT:
+        {
+            ASSERT(!mState.mAttachedGeometryShader);
+            mState.mAttachedGeometryShader = shader;
+            mState.mAttachedGeometryShader->addRef();
+            break;
+        }
         default:
             UNREACHABLE();
     }
@@ -615,6 +630,13 @@ void Program::detachShader(const Context *context, Shader *shader)
             mState.mAttachedComputeShader = nullptr;
             break;
         }
+        case GL_GEOMETRY_SHADER_EXT:
+        {
+            ASSERT(mState.mAttachedGeometryShader == shader);
+            shader->release(context);
+            mState.mAttachedGeometryShader = nullptr;
+            break;
+        }
         default:
             UNREACHABLE();
     }
@@ -623,7 +645,7 @@ void Program::detachShader(const Context *context, Shader *shader)
 int Program::getAttachedShadersCount() const
 {
     return (mState.mAttachedVertexShader ? 1 : 0) + (mState.mAttachedFragmentShader ? 1 : 0) +
-           (mState.mAttachedComputeShader ? 1 : 0);
+           (mState.mAttachedComputeShader ? 1 : 0) + (mState.mAttachedGeometryShader ? 1 : 0);
 }
 
 void Program::bindAttributeLocation(GLuint index, const char *name)
@@ -1119,6 +1141,15 @@ void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shade
         }
     }
 
+    if (mState.mAttachedGeometryShader)
+    {
+        if (total < maxCount)
+        {
+            shaders[total] = mState.mAttachedGeometryShader->getHandle();
+            total++;
+        }
+    }
+
     if (count)
     {
         *count = total;

src/libANGLE/Program.h

@@ -241,6 +241,7 @@ class ProgramState final : angle::NonCopyable
     Shader *getAttachedVertexShader() const { return mAttachedVertexShader; }
     Shader *getAttachedFragmentShader() const { return mAttachedFragmentShader; }
     Shader *getAttachedComputeShader() const { return mAttachedComputeShader; }
+    Shader *getAttachedGeometryShader() const { return mAttachedGeometryShader; }
     const std::vector<std::string> &getTransformFeedbackVaryingNames() const
     {
         return mTransformFeedbackVaryingNames;
@@ -316,6 +317,7 @@ class ProgramState final : angle::NonCopyable
     Shader *mAttachedFragmentShader;
     Shader *mAttachedVertexShader;
     Shader *mAttachedComputeShader;
+    Shader *mAttachedGeometryShader;
 
     std::vector<std::string> mTransformFeedbackVaryingNames;
     std::vector<TransformFeedbackVarying> mLinkedTransformFeedbackVaryings;
@@ -392,6 +394,7 @@ class Program final : angle::NonCopyable, public LabeledObject
     const Shader *getAttachedVertexShader() const { return mState.mAttachedVertexShader; }
     const Shader *getAttachedFragmentShader() const { return mState.mAttachedFragmentShader; }
     const Shader *getAttachedComputeShader() const { return mState.mAttachedComputeShader; }
+    const Shader *getAttachedGeometryShader() const { return mState.mAttachedGeometryShader; }
 
     void bindAttributeLocation(GLuint index, const char *name);
     void bindUniformLocation(GLuint index, const char *name);

src/libANGLE/ResourceManager.cpp

@@ -159,7 +159,8 @@ GLuint ShaderProgramManager::createShader(rx::GLImplFactory *factory,
                                           const gl::Limitations &rendererLimitations,
                                           GLenum type)
 {
-    ASSERT(type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER || type == GL_COMPUTE_SHADER);
+    ASSERT(type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER || type == GL_COMPUTE_SHADER ||
+           type == GL_GEOMETRY_SHADER_EXT);
     GLuint handle    = mHandleAllocator.allocate();
     mShaders.assign(handle, new Shader(this, factory, rendererLimitations, type, handle));
     return handle;

src/libANGLE/Shader.cpp

@@ -79,6 +79,10 @@ ShaderState::ShaderState(GLenum shaderType)
       mShaderType(shaderType),
       mShaderVersion(100),
       mNumViews(-1),
+      mGeometryShaderInputPrimitiveType(GL_INVALID_VALUE),
+      mGeometryShaderOutputPrimitiveType(GL_INVALID_VALUE),
+      mGeometryShaderInvocations(1),
+      mGeometryShaderMaxVertices(-1),
       mCompileStatus(CompileStatus::NOT_COMPILED)
 {
     mLocalSize.fill(-1);
@@ -276,6 +280,10 @@ void Shader::compile(const Context *context)
     mState.mActiveAttributes.clear();
     mState.mActiveOutputVariables.clear();
     mState.mNumViews = -1;
+    mState.mGeometryShaderInputPrimitiveType  = GL_INVALID_VALUE;
+    mState.mGeometryShaderOutputPrimitiveType = GL_INVALID_VALUE;
+    mState.mGeometryShaderInvocations         = 1;
+    mState.mGeometryShaderMaxVertices         = -1;
 
     mState.mCompileStatus = CompileStatus::COMPILE_REQUESTED;
     mBoundCompiler.set(context, context->getCompiler());
@@ -391,6 +399,19 @@ void Shader::resolveCompile(const Context *context)
                 GetActiveShaderVariables(sh::GetOutputVariables(compilerHandle));
             break;
         }
+        case GL_GEOMETRY_SHADER_EXT:
+        {
+            mState.mInputVaryings  = GetShaderVariables(sh::GetInputVaryings(compilerHandle));
+            mState.mOutputVaryings = GetShaderVariables(sh::GetOutputVaryings(compilerHandle));
+
+            mState.mGeometryShaderInputPrimitiveType =
+                sh::GetGeometryShaderInputPrimitiveType(compilerHandle);
+            mState.mGeometryShaderOutputPrimitiveType =
+                sh::GetGeometryShaderOutputPrimitiveType(compilerHandle);
+            mState.mGeometryShaderInvocations = sh::GetGeometryShaderInvocations(compilerHandle);
+            mState.mGeometryShaderMaxVertices = sh::GetGeometryShaderMaxVertices(compilerHandle);
+            break;
+        }
         default:
             UNREACHABLE();
     }

src/libANGLE/Shader.h

@@ -101,6 +101,12 @@ class ShaderState final : angle::NonCopyable
     // ANGLE_multiview.
     int mNumViews;
 
+    // Geometry Shader.
+    GLenum mGeometryShaderInputPrimitiveType;
+    GLenum mGeometryShaderOutputPrimitiveType;
+    int mGeometryShaderInvocations;
+    int mGeometryShaderMaxVertices;
+
     // Indicates if this shader has been successfully compiled
     CompileStatus mCompileStatus;
 };

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -1034,6 +1034,22 @@ void GenerateCaps(const FunctionsGL *functions,
         caps->maxRectangleTextureSize =
             QuerySingleGLInt(functions, GL_MAX_RECTANGLE_TEXTURE_SIZE_ANGLE);
     }
+
+    // We need at least OpenGL 4.3 to support all features and constants defined in
+    // GL_EXT_geometry_shader.
+    if (functions->isAtLeastGL(gl::Version(4, 3)) || functions->isAtLeastGLES(gl::Version(3, 2)) ||
+        functions->hasGLESExtension("GL_OES_geometry_shader") ||
+        functions->hasGLESExtension("GL_EXT_geometry_shader"))
+    {
+        extensions->geometryShader = true;
+
+        // TODO(jiawei.shao@intel.com): initialize all implementation dependent geometry shader
+        // limits.
+        extensions->maxGeometryOutputVertices =
+            QuerySingleGLInt(functions, GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT);
+        extensions->maxGeometryShaderInvocations =
+            QuerySingleGLInt(functions, GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT);
+    }
 }
 
 void GenerateWorkarounds(const FunctionsGL *functions, WorkaroundsGL *workarounds)

src/libANGLE/validationES2.cpp

@@ -4154,6 +4154,13 @@ bool ValidateCreateShader(Context *context, GLenum type)
             }
             break;
 
+        case GL_GEOMETRY_SHADER_EXT:
+            if (!context->getExtensions().geometryShader)
+            {
+                ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidShaderType);
+                return false;
+            }
+            break;
         default:
             ANGLE_VALIDATION_ERR(context, InvalidEnum(), InvalidShaderType);
             return false;
@@ -4344,6 +4351,15 @@ bool ValidateAttachShader(ValidationContext *context, GLuint program, GLuint sha
             }
             break;
         }
+        case GL_GEOMETRY_SHADER_EXT:
+        {
+            if (programObject->getAttachedGeometryShader())
+            {
+                ANGLE_VALIDATION_ERR(context, InvalidOperation(), ShaderAttachmentHasShader);
+                return false;
+            }
+            break;
+        }
         default:
             UNREACHABLE();
             break;
@@ -4967,6 +4983,11 @@ bool ValidateDetachShader(ValidationContext *context, GLuint program, GLuint sha
             attachedShader = programObject->getAttachedComputeShader();
             break;
         }
+        case GL_GEOMETRY_SHADER_EXT:
+        {
+            attachedShader = programObject->getAttachedGeometryShader();
+            break;
+        }
         default:
             UNREACHABLE();
             return false;

src/tests/angle_end2end_tests.gypi

@@ -45,6 +45,7 @@
             '<(angle_path)/src/tests/gl_tests/FramebufferMultiviewTest.cpp',
             '<(angle_path)/src/tests/gl_tests/FramebufferRenderMipmapTest.cpp',
             '<(angle_path)/src/tests/gl_tests/FramebufferTest.cpp',
+            '<(angle_path)/src/tests/gl_tests/GeometryShaderTest.cpp',
             '<(angle_path)/src/tests/gl_tests/GLSLTest.cpp',
             '<(angle_path)/src/tests/gl_tests/ImageTest.cpp',
             '<(angle_path)/src/tests/gl_tests/IncompleteTextureTest.cpp',

src/tests/gl_tests/GeometryShaderTest.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.
+//
+
+// GeometryShaderTest.cpp : Tests of the implementation of geometry shader
+
+#include "test_utils/ANGLETest.h"
+
+using namespace angle;
+
+namespace
+{
+
+class GeometryShaderTest : public ANGLETest
+{
+};
+
+class GeometryShaderTestES3 : public ANGLETest
+{
+};
+
+// Verify that Geometry Shader cannot be created in an OpenGL ES 3.0 context.
+TEST_P(GeometryShaderTestES3, CreateGeometryShaderInES3)
+{
+    EXPECT_TRUE(!extensionEnabled("GL_EXT_geometry_shader"));
+    GLuint geometryShader = glCreateShader(GL_GEOMETRY_SHADER_EXT);
+    EXPECT_EQ(0u, geometryShader);
+    EXPECT_GL_ERROR(GL_INVALID_ENUM);
+}
+
+// Verify that Geometry Shader can be created and attached to a program.
+TEST_P(GeometryShaderTest, CreateAndAttachGeometryShader)
+{
+    ANGLE_SKIP_TEST_IF(!extensionEnabled("GL_EXT_geometry_shader"));
+
+    const std::string &geometryShaderSource =
+        R"(#version 310 es
+        #extension GL_EXT_geometry_shader : require
+        layout (invocations = 3, triangles) in;
+        layout (triangle_strip, max_vertices = 3) out;
+        in vec4 texcoord[];
+        out vec4 o_texcoord;
+        void main()
+        {
+            int n;
+            for (n = 0; n < gl_in.length(); n++)
+            {
+                gl_Position = gl_in[n].gl_Position;
+                gl_Layer   = gl_InvocationID;
+                o_texcoord = texcoord[n];
+                EmitVertex();
+            }
+            EndPrimitive();
+        })";
+
+    GLuint geometryShader = CompileShader(GL_GEOMETRY_SHADER_EXT, geometryShaderSource);
+
+    EXPECT_NE(0u, geometryShader);
+
+    GLuint programID = glCreateProgram();
+    glAttachShader(programID, geometryShader);
+
+    glDetachShader(programID, geometryShader);
+    glDeleteShader(geometryShader);
+    glDeleteProgram(programID);
+
+    EXPECT_GL_NO_ERROR();
+}
+
+ANGLE_INSTANTIATE_TEST(GeometryShaderTestES3, ES3_OPENGL(), ES3_OPENGLES(), ES3_D3D11());
+ANGLE_INSTANTIATE_TEST(GeometryShaderTest, ES31_OPENGL(), ES31_OPENGLES(), ES31_D3D11());
+}