Fix draw mode validation of PPOs with geometry/tessellation

src/libANGLE/ProgramPipeline.cpp

@@ -323,6 +323,46 @@ void ProgramPipeline::updateImageBindings()
     }
 }
 
+void ProgramPipeline::updateExecutableGeometryProperties()
+{
+    Program *geometryProgram = getShaderProgram(gl::ShaderType::Geometry);
+
+    if (!geometryProgram)
+    {
+        return;
+    }
+
+    const ProgramExecutable &geometryExecutable = geometryProgram->getExecutable();
+    mState.mExecutable->mGeometryShaderInputPrimitiveType =
+        geometryExecutable.mGeometryShaderInputPrimitiveType;
+    mState.mExecutable->mGeometryShaderOutputPrimitiveType =
+        geometryExecutable.mGeometryShaderOutputPrimitiveType;
+    mState.mExecutable->mGeometryShaderInvocations = geometryExecutable.mGeometryShaderInvocations;
+    mState.mExecutable->mGeometryShaderMaxVertices = geometryExecutable.mGeometryShaderMaxVertices;
+}
+
+void ProgramPipeline::updateExecutableTessellationProperties()
+{
+    Program *tessControlProgram = getShaderProgram(gl::ShaderType::TessControl);
+    Program *tessEvalProgram    = getShaderProgram(gl::ShaderType::TessEvaluation);
+
+    if (tessControlProgram)
+    {
+        const ProgramExecutable &tessControlExecutable = tessControlProgram->getExecutable();
+        mState.mExecutable->mTessControlShaderVertices =
+            tessControlExecutable.mTessControlShaderVertices;
+    }
+
+    if (tessEvalProgram)
+    {
+        const ProgramExecutable &tessEvalExecutable = tessEvalProgram->getExecutable();
+        mState.mExecutable->mTessGenMode            = tessEvalExecutable.mTessGenMode;
+        mState.mExecutable->mTessGenSpacing         = tessEvalExecutable.mTessGenSpacing;
+        mState.mExecutable->mTessGenVertexOrder     = tessEvalExecutable.mTessGenVertexOrder;
+        mState.mExecutable->mTessGenPointMode       = tessEvalExecutable.mTessGenPointMode;
+    }
+}
+
 void ProgramPipeline::updateHasBooleans()
 {
     // Need to check all of the shader stages, not just linked, so we handle Compute correctly.
@@ -402,6 +442,12 @@ void ProgramPipeline::updateExecutable()
     updateShaderStorageBlocks();
     updateImageBindings();
 
+    // Geometry Shader ProgramExecutable properties
+    updateExecutableGeometryProperties();
+
+    // Tessellation Shaders ProgramExecutable properties
+    updateExecutableTessellationProperties();
+
     // All Shader ProgramExecutable properties
     mState.updateExecutableTextures();
 

src/libANGLE/ProgramPipeline.h

@@ -151,6 +151,8 @@ class ProgramPipeline final : public RefCountObject<ProgramPipelineID>,
     void updateTransformFeedbackMembers();
     void updateShaderStorageBlocks();
     void updateImageBindings();
+    void updateExecutableGeometryProperties();
+    void updateExecutableTessellationProperties();
     void updateHasBooleans();
     void updateExecutable();
 

src/libANGLE/validationES.cpp

@@ -3949,14 +3949,14 @@ void RecordDrawModeError(const Context *context, PrimitiveMode mode)
     // If we are running GLES1, there is no current program.
     if (context->getClientVersion() >= Version(2, 0))
     {
-        Program *program = context->getActiveLinkedProgram();
-        ASSERT(program);
+        const ProgramExecutable *executable = state.getProgramExecutable();
+        ASSERT(executable);
 
         // Do geometry shader specific validations
-        if (program->getExecutable().hasLinkedShaderStage(ShaderType::Geometry))
+        if (executable->hasLinkedShaderStage(ShaderType::Geometry))
         {
             if (!IsCompatibleDrawModeWithGeometryShader(
-                    mode, program->getGeometryShaderInputPrimitiveType()))
+                    mode, executable->getGeometryShaderInputPrimitiveType()))
             {
                 context->validationError(GL_INVALID_OPERATION,
                                          kIncompatibleDrawModeAgainstGeometryShader);
@@ -3964,16 +3964,14 @@ void RecordDrawModeError(const Context *context, PrimitiveMode mode)
             }
         }
 
-        if (program->getExecutable().hasLinkedTessellationShader() &&
-            mode != PrimitiveMode::Patches)
+        if (executable->hasLinkedTessellationShader() && mode != PrimitiveMode::Patches)
         {
             context->validationError(GL_INVALID_OPERATION,
                                      kIncompatibleDrawModeWithTessellationShader);
             return;
         }
 
-        if (!program->getExecutable().hasLinkedTessellationShader() &&
-            mode == PrimitiveMode::Patches)
+        if (!executable->hasLinkedTessellationShader() && mode == PrimitiveMode::Patches)
         {
             context->validationError(GL_INVALID_OPERATION,
                                      kIncompatibleDrawModeWithoutTessellationShader);