Re-land "Implement EGL_experimental_present_path_angle"

extensions/EGL_experimental_present_path_angle.txt → extensions/EGL_ANGLE_experimental_present_path.txt

 Name
 
-    experimental_present_path_angle
+    ANGLE_experimental_present_path
 
 Name Strings
 
-    EGL_experimental_present_path_angle
+    EGL_ANGLE_experimental_present_path
 
 Contributors
 

include/EGL/eglext.h

@@ -522,6 +522,13 @@ EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSu
 #define EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE 0x0002
 #endif /* EGL_ANGLE_surface_orientation */
 
+#ifndef EGL_ANGLE_experimental_present_path
+#define EGL_ANGLE_experimental_present_path
+#define EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE 0x33A4
+#define EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE 0x33A9
+#define EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE 0x33AA
+#endif /* EGL_ANGLE_experimental_present_path */
+
 #ifndef EGL_ARM_pixmap_multisample_discard
 #define EGL_ARM_pixmap_multisample_discard 1
 #define EGL_DISCARD_SAMPLES_ARM           0x3286

src/compiler/translator/OutputHLSL.cpp

@@ -505,6 +505,13 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
                 out << "    float3 dx_DepthFront : packoffset(c2);\n";
             }
 
+            if (mUsesFragCoord)
+            {
+                // dx_ViewScale is only used in the fragment shader to correct
+                // the value for glFragCoord if necessary
+                out << "    float2 dx_ViewScale : packoffset(c3);\n";
+            }
+
             out << "};\n";
         }
         else
@@ -599,11 +606,13 @@ void OutputHLSL::header(TInfoSinkBase &out, const BuiltInFunctionEmulator *built
                 out << "    float3 dx_DepthRange : packoffset(c0);\n";
             }
 
-            // dx_ViewAdjust and dx_ViewCoords will only be used in Feature Level 9 shaders.
-            // However, we declare it for all shaders (including Feature Level 10+).
-            // The bytecode is the same whether we declare it or not, since D3DCompiler removes it if it's unused.
+            // dx_ViewAdjust and dx_ViewCoords will only be used in Feature Level 9
+            // shaders. However, we declare it for all shaders (including Feature Level 10+).
+            // The bytecode is the same whether we declare it or not, since D3DCompiler removes it
+            // if it's unused.
             out << "    float4 dx_ViewAdjust : packoffset(c1);\n";
             out << "    float2 dx_ViewCoords : packoffset(c2);\n";
+            out << "    float2 dx_ViewScale  : packoffset(c3);\n";
 
             out << "};\n"
                    "\n";

src/libANGLE/Caps.cpp

@@ -697,6 +697,7 @@ ClientExtensions::ClientExtensions()
       deviceCreation(false),
       deviceCreationD3D11(false),
       x11Visual(false),
+      experimentalPresentPath(false),
       clientGetAllProcAddresses(false)
 {
 }
@@ -716,6 +717,7 @@ std::vector<std::string> ClientExtensions::getStrings() const
     InsertExtensionString("EGL_ANGLE_device_creation",             deviceCreation,            &extensionStrings);
     InsertExtensionString("EGL_ANGLE_device_creation_d3d11",       deviceCreationD3D11,       &extensionStrings);
     InsertExtensionString("EGL_ANGLE_x11_visual",                  x11Visual,                 &extensionStrings);
+    InsertExtensionString("EGL_ANGLE_experimental_present_path",   experimentalPresentPath,   &extensionStrings);
     InsertExtensionString("EGL_KHR_client_get_all_proc_addresses", clientGetAllProcAddresses, &extensionStrings);
     // clang-format on
 

src/libANGLE/Caps.h

@@ -529,6 +529,9 @@ struct ClientExtensions
     // EGL_ANGLE_x11_visual
     bool x11Visual;
 
+    // EGL_ANGLE_experimental_present_path
+    bool experimentalPresentPath;
+
     // EGL_KHR_client_get_all_proc_addresses
     bool clientGetAllProcAddresses;
 };

src/libANGLE/Display.cpp

@@ -882,6 +882,7 @@ static ClientExtensions GenerateClientExtensions()
 #if defined(ANGLE_ENABLE_D3D11)
     extensions.deviceCreation      = true;
     extensions.deviceCreationD3D11 = true;
+    extensions.experimentalPresentPath = true;
 #endif
 
 #if defined(ANGLE_USE_X11)

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -412,6 +412,9 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
     const ShaderD3D *fragmentShader    = GetImplAs<ShaderD3D>(fragmentShaderGL);
     const int shaderModel              = mRenderer->getMajorShaderModel();
 
+    // usesViewScale() isn't supported in the D3D9 renderer
+    ASSERT(shaderModel >= 4 || !programMetadata.usesViewScale());
+
     bool useInstancedPointSpriteEmulation =
         programMetadata.usesPointSize() &&
         mRenderer->getWorkarounds().useInstancedPointSpriteEmulation;
@@ -464,18 +467,43 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
     // On D3D9 or D3D11 Feature Level 9, we need to emulate large viewports using dx_ViewAdjust.
     if (shaderModel >= 4 && mRenderer->getShaderModelSuffix() == "")
     {
-        vertexStream << "    output.dx_Position.x = gl_Position.x;\n"
-                     << "    output.dx_Position.y = -gl_Position.y;\n"
-                     << "    output.dx_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
+        vertexStream << "    output.dx_Position.x = gl_Position.x;\n";
+
+        if (programMetadata.usesViewScale())
+        {
+            // This code assumes that dx_ViewScale.y = -1.0f when rendering to texture, and +1.0f
+            // when rendering to the default framebuffer. No other values are valid.
+            vertexStream << "    output.dx_Position.y = dx_ViewScale.y * gl_Position.y;\n";
+        }
+        else
+        {
+            vertexStream << "    output.dx_Position.y = - gl_Position.y;\n";
+        }
+
+        vertexStream << "    output.dx_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
                      << "    output.dx_Position.w = gl_Position.w;\n";
     }
     else
     {
         vertexStream << "    output.dx_Position.x = gl_Position.x * dx_ViewAdjust.z + "
-                        "dx_ViewAdjust.x * gl_Position.w;\n"
-                     << "    output.dx_Position.y = -(gl_Position.y * dx_ViewAdjust.w + "
-                        "dx_ViewAdjust.y * gl_Position.w);\n"
-                     << "    output.dx_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
+                        "dx_ViewAdjust.x * gl_Position.w;\n";
+
+        // If usesViewScale() is true and we're using the D3D11 renderer via Feature Level 9_*,
+        // then we need to multiply the gl_Position.y by the viewScale.
+        // usesViewScale() isn't supported when using the D3D9 renderer.
+        if (programMetadata.usesViewScale() &&
+            (shaderModel >= 4 && mRenderer->getShaderModelSuffix() != ""))
+        {
+            vertexStream << "    output.dx_Position.y = dx_ViewScale.y * (gl_Position.y * "
+                            "dx_ViewAdjust.w + dx_ViewAdjust.y * gl_Position.w);\n";
+        }
+        else
+        {
+            vertexStream << "    output.dx_Position.y = -(gl_Position.y * dx_ViewAdjust.w + "
+                            "dx_ViewAdjust.y * gl_Position.w);\n";
+        }
+
+        vertexStream << "    output.dx_Position.z = (gl_Position.z + gl_Position.w) * 0.5;\n"
                      << "    output.dx_Position.w = gl_Position.w;\n";
     }
 
@@ -523,11 +551,26 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
     if (useInstancedPointSpriteEmulation)
     {
         vertexStream << "\n"
-                     << "    gl_PointSize = clamp(gl_PointSize, minPointSize, maxPointSize);\n"
-                     << "    output.dx_Position.xyz += float3(input.spriteVertexPos.x * "
-                        "gl_PointSize / (dx_ViewCoords.x*2), input.spriteVertexPos.y * "
-                        "gl_PointSize / (dx_ViewCoords.y*2), input.spriteVertexPos.z) * "
-                        "output.dx_Position.w;\n";
+                     << "    gl_PointSize = clamp(gl_PointSize, minPointSize, maxPointSize);\n";
+
+        vertexStream << "    output.dx_Position.x += (input.spriteVertexPos.x * gl_PointSize / "
+                        "(dx_ViewCoords.x*2)) * output.dx_Position.w;";
+
+        if (programMetadata.usesViewScale())
+        {
+            // Multiply by ViewScale to invert the rendering when appropriate
+            vertexStream << "    output.dx_Position.y += (-dx_ViewScale.y * "
+                            "input.spriteVertexPos.y * gl_PointSize / (dx_ViewCoords.y*2)) * "
+                            "output.dx_Position.w;";
+        }
+        else
+        {
+            vertexStream << "    output.dx_Position.y += (input.spriteVertexPos.y * gl_PointSize / "
+                            "(dx_ViewCoords.y*2)) * output.dx_Position.w;";
+        }
+
+        vertexStream
+            << "    output.dx_Position.z += input.spriteVertexPos.z * output.dx_Position.w;\n";
 
         if (programMetadata.usesPointCoord())
         {
@@ -606,6 +649,49 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
                            "dx_ViewCoords.w;\n";
         }
 
+        if (programMetadata.usesViewScale())
+        {
+            // For Feature Level 9_3 and below, we need to correct gl_FragCoord.y to account
+            // for dx_ViewScale. On Feature Level 10_0+, gl_FragCoord.y is calculated above using
+            // dx_ViewCoords and is always correct irrespective of dx_ViewScale's value.
+            // NOTE: usesViewScale() can only be true on D3D11 (i.e. Shader Model 4.0+).
+            if (shaderModel >= 4 && mRenderer->getShaderModelSuffix() == "")
+            {
+                // Some assumptions:
+                //  - dx_ViewScale.y = -1.0f when rendering to texture
+                //  - dx_ViewScale.y = +1.0f when rendering to the default framebuffer
+                //  - gl_FragCoord.y has been set correctly above.
+                //
+                // When rendering to the backbuffer, the code inverts gl_FragCoord's y coordinate.
+                // This involves subtracting the y coordinate from the height of the area being
+                // rendered to.
+                //
+                // First we calculate the height of the area being rendered to:
+                //    render_area_height = (2.0f / (1.0f - input.gl_FragCoord.y * rhw)) *
+                //    gl_FragCoord.y
+                //
+                // Note that when we're rendering to default FB, we want our output to be
+                // equivalent to:
+                //    "gl_FragCoord.y = render_area_height - gl_FragCoord.y"
+                //
+                // When we're rendering to a texture, we want our output to be equivalent to:
+                //    "gl_FragCoord.y = gl_FragCoord.y;"
+                //
+                // If we set scale_factor = ((1.0f + dx_ViewScale.y) / 2.0f), then notice that
+                //  - When rendering to default FB: scale_factor = 1.0f
+                //  - When rendering to texture:    scale_factor = 0.0f
+                //
+                // Therefore, we can get our desired output by setting:
+                //    "gl_FragCoord.y = scale_factor * render_area_height - dx_ViewScale.y *
+                //    gl_FragCoord.y"
+                //
+                // Simplifying, this becomes:
+                pixelStream
+                    << "    gl_FragCoord.y = (1.0f + dx_ViewScale.y) * gl_FragCoord.y /"
+                       "(1.0f - input.gl_FragCoord.y * rhw)  - dx_ViewScale.y * gl_FragCoord.y;\n";
+            }
+        }
+
         pixelStream << "    gl_FragCoord.z = (input.gl_FragCoord.z * rhw) * dx_DepthFront.x + "
                        "dx_DepthFront.y;\n"
                     << "    gl_FragCoord.w = rhw;\n";
@@ -749,6 +835,7 @@ std::string DynamicHLSL::generateGeometryShaderPreamble(const VaryingPacking &va
 std::string DynamicHLSL::generateGeometryShaderHLSL(gl::PrimitiveType primitiveType,
                                                     const gl::Data &data,
                                                     const gl::Program::Data &programData,
+                                                    const bool useViewScale,
                                                     const std::string &preambleString) const
 {
     ASSERT(mRenderer->getMajorShaderModel() >= 4);
@@ -799,8 +886,14 @@ std::string DynamicHLSL::generateGeometryShaderHLSL(gl::PrimitiveType primitiveT
     {
         shaderStream << "#define ANGLE_POINT_SPRITE_SHADER\n"
                         "\n"
-                        "uniform float4 dx_ViewCoords : register(c1);\n"
-                        "\n"
+                        "uniform float4 dx_ViewCoords : register(c1);\n";
+
+        if (useViewScale)
+        {
+            shaderStream << "uniform float2 dx_ViewScale : register(c3);\n";
+        }
+
+        shaderStream << "\n"
                         "static float2 pointSpriteCorners[] = \n"
                         "{\n"
                         "    float2( 0.5f, -0.5f),\n"
@@ -870,9 +963,20 @@ std::string DynamicHLSL::generateGeometryShaderHLSL(gl::PrimitiveType primitiveT
 
         for (int corner = 0; corner < 4; corner++)
         {
+            if (useViewScale)
+            {
+                shaderStream << "    \n"
+                                "    output.dx_Position = dx_Position + float4(1.0f, "
+                                "-dx_ViewScale.y, 1.0f, 1.0f)"
+                                "        * float4(pointSpriteCorners["
+                             << corner << "] * viewportScale * gl_PointSize, 0.0f, 0.0f);\n";
+            }
+            else
+            {
                 shaderStream << "\n"
                                 "    output.dx_Position = dx_Position + float4(pointSpriteCorners["
                              << corner << "] * viewportScale * gl_PointSize, 0.0f, 0.0f);\n";
+            }
 
             if (usesPointCoord)
             {

src/libANGLE/renderer/d3d/DynamicHLSL.h

@@ -74,6 +74,7 @@ class DynamicHLSL : angle::NonCopyable
     std::string generateGeometryShaderHLSL(gl::PrimitiveType primitiveType,
                                            const gl::Data &data,
                                            const gl::Program::Data &programData,
+                                           const bool useViewScale,
                                            const std::string &preambleString) const;
 
     void getPixelShaderOutputKey(const gl::Data &data,

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -401,11 +401,13 @@ D3DVarying::D3DVarying(const std::string &semanticNameIn,
 ProgramD3DMetadata::ProgramD3DMetadata(int rendererMajorShaderModel,
                                        const std::string &shaderModelSuffix,
                                        bool usesInstancedPointSpriteEmulation,
+                                       bool usesViewScale,
                                        const ShaderD3D *vertexShader,
                                        const ShaderD3D *fragmentShader)
     : mRendererMajorShaderModel(rendererMajorShaderModel),
       mShaderModelSuffix(shaderModelSuffix),
       mUsesInstancedPointSpriteEmulation(usesInstancedPointSpriteEmulation),
+      mUsesViewScale(usesViewScale),
       mVertexShader(vertexShader),
       mFragmentShader(fragmentShader)
 {
@@ -446,6 +448,11 @@ bool ProgramD3DMetadata::usesInsertedPointCoordValue() const
     return !usesPointSize() && usesPointCoord() && mRendererMajorShaderModel >= 4;
 }
 
+bool ProgramD3DMetadata::usesViewScale() const
+{
+    return mUsesViewScale;
+}
+
 bool ProgramD3DMetadata::addsPointCoordToVertexShader() const
 {
     // Instanced PointSprite emulation requires that gl_PointCoord is present in the vertex shader
@@ -1259,7 +1266,8 @@ gl::Error ProgramD3D::getGeometryExecutableForPrimitiveType(const gl::Data &data
     }
 
     std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(
-        geometryShaderType, data, mData, mGeometryShaderPreamble);
+        geometryShaderType, data, mData, mRenderer->presentPathFastEnabled(),
+        mGeometryShaderPreamble);
 
     gl::InfoLog tempInfoLog;
     gl::InfoLog *currentInfoLog = infoLog ? infoLog : &tempInfoLog;
@@ -1387,7 +1395,8 @@ LinkResult ProgramD3D::link(const gl::Data &data, gl::InfoLog &infoLog)
     }
 
     ProgramD3DMetadata metadata(mRenderer->getMajorShaderModel(), mRenderer->getShaderModelSuffix(),
-                                usesInstancedPointSpriteEmulation(), vertexShaderD3D,
+                                usesInstancedPointSpriteEmulation(),
+                                mRenderer->presentPathFastEnabled(), vertexShaderD3D,
                                 fragmentShaderD3D);
 
     varyingPacking.enableBuiltins(SHADER_VERTEX, metadata);

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -103,6 +103,7 @@ class ProgramD3DMetadata : angle::NonCopyable
     ProgramD3DMetadata(int rendererMajorShaderModel,
                        const std::string &shaderModelSuffix,
                        bool usesInstancedPointSpriteEmulation,
+                       bool usesViewScale,
                        const ShaderD3D *vertexShader,
                        const ShaderD3D *fragmentShader);
 
@@ -113,6 +114,7 @@ class ProgramD3DMetadata : angle::NonCopyable
     bool usesFragCoord() const;
     bool usesPointSize() const;
     bool usesInsertedPointCoordValue() const;
+    bool usesViewScale() const;
     bool addsPointCoordToVertexShader() const;
     bool usesTransformFeedbackGLPosition() const;
     bool usesSystemValuePointSize() const;
@@ -124,6 +126,7 @@ class ProgramD3DMetadata : angle::NonCopyable
     const int mRendererMajorShaderModel;
     const std::string mShaderModelSuffix;
     const bool mUsesInstancedPointSpriteEmulation;
+    const bool mUsesViewScale;
     const ShaderD3D *mVertexShader;
     const ShaderD3D *mFragmentShader;
 };

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -41,6 +41,7 @@ RendererD3D::RendererD3D(egl::Display *display)
     : mDisplay(display),
       mDeviceLost(false),
       mAnnotator(nullptr),
+      mPresentPathFastEnabled(false),
       mScratchMemoryBufferResetCounter(0),
       mWorkaroundsInitialized(false),
       mDisjoint(false)

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -251,6 +251,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     virtual egl::Error getEGLDevice(DeviceImpl **device) = 0;
 
+    bool presentPathFastEnabled() const { return mPresentPathFastEnabled; }
+
   protected:
     virtual bool getLUID(LUID *adapterLuid) const = 0;
     virtual gl::Error applyShadersImpl(const gl::Data &data, GLenum drawMode) = 0;
@@ -270,6 +272,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     std::vector<TranslatedAttribute> mTranslatedAttribCache;
 
+    bool mPresentPathFastEnabled;
+
   private:
     gl::Error genericDrawArrays(const gl::Data &data,
                                 GLenum mode,
@@ -329,20 +333,6 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     bool mDisjoint;
 };
 
-struct dx_VertexConstants
-{
-    float depthRange[4];
-    float viewAdjust[4];
-    float viewCoords[4];
-};
-
-struct dx_PixelConstants
-{
-    float depthRange[4];
-    float viewCoords[4];
-    float depthFront[4];
-};
-
 }
 
 #endif // LIBANGLE_RENDERER_D3D_RENDERERD3D_H_

src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp

@@ -93,7 +93,27 @@ gl::Error Framebuffer11::invalidateSwizzles() const
 gl::Error Framebuffer11::clear(const gl::Data &data, const ClearParameters &clearParams)
 {
     Clear11 *clearer = mRenderer->getClearer();
-    gl::Error error = clearer->clearFramebuffer(clearParams, mData);
+    gl::Error error(GL_NO_ERROR);
+
+    const gl::FramebufferAttachment *colorAttachment = mData.getFirstColorAttachment();
+    if (clearParams.scissorEnabled == true && colorAttachment != nullptr &&
+        UsePresentPathFast(mRenderer, colorAttachment))
+    {
+        // If the current framebuffer is using the default colorbuffer, and present path fast is
+        // active, and the scissor rect is enabled, then we should invert the scissor rect
+        // vertically
+        ClearParameters presentPathFastClearParams = clearParams;
+        gl::Extents framebufferSize                = colorAttachment->getSize();
+        presentPathFastClearParams.scissor.y       = framebufferSize.height -
+                                               presentPathFastClearParams.scissor.y -
+                                               presentPathFastClearParams.scissor.height;
+        error = clearer->clearFramebuffer(presentPathFastClearParams, mData);
+    }
+    else
+    {
+        error = clearer->clearFramebuffer(clearParams, mData);
+    }
+
     if (error.isError())
     {
         return error;
@@ -328,8 +348,27 @@ gl::Error Framebuffer11::blit(const gl::Rectangle &sourceArea, const gl::Rectang
                 }
                 ASSERT(drawRenderTarget);
 
-                error = mRenderer->blitRenderbufferRect(sourceArea, destArea, readRenderTarget, drawRenderTarget,
-                                                        filter, scissor, blitRenderTarget, false, false);
+                const bool invertColorSource   = UsePresentPathFast(mRenderer, readBuffer);
+                gl::Rectangle actualSourceArea = sourceArea;
+                if (invertColorSource)
+                {
+                    RenderTarget11 *readRenderTarget11 = GetAs<RenderTarget11>(readRenderTarget);
+                    actualSourceArea.y                 = readRenderTarget11->getHeight() - sourceArea.y;
+                    actualSourceArea.height            = -sourceArea.height;
+                }
+
+                const bool invertColorDest   = UsePresentPathFast(mRenderer, &drawBuffer);
+                gl::Rectangle actualDestArea = destArea;
+                if (invertColorDest)
+                {
+                    RenderTarget11 *drawRenderTarget11 = GetAs<RenderTarget11>(drawRenderTarget);
+                    actualDestArea.y                   = drawRenderTarget11->getHeight() - destArea.y;
+                    actualDestArea.height              = -destArea.height;
+                }
+
+                error = mRenderer->blitRenderbufferRect(actualSourceArea, actualDestArea,
+                                                        readRenderTarget, drawRenderTarget, filter,
+                                                        scissor, blitRenderTarget, false, false);
                 if (error.isError())
                 {
                     return error;

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -389,14 +389,14 @@ class Renderer11 : public RendererD3D
     uintptr_t mAppliedGeometryShader;
     uintptr_t mAppliedPixelShader;
 
-    dx_VertexConstants mAppliedVertexConstants;
+    dx_VertexConstants11 mAppliedVertexConstants;
     ID3D11Buffer *mDriverConstantBufferVS;
     ID3D11Buffer *mCurrentVertexConstantBuffer;
     unsigned int mCurrentConstantBufferVS[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
     GLintptr mCurrentConstantBufferVSOffset[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
     GLsizeiptr mCurrentConstantBufferVSSize[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
 
-    dx_PixelConstants mAppliedPixelConstants;
+    dx_PixelConstants11 mAppliedPixelConstants;
     ID3D11Buffer *mDriverConstantBufferPS;
     ID3D11Buffer *mCurrentPixelConstantBuffer;
     unsigned int mCurrentConstantBufferPS[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];

src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp

@@ -215,6 +215,23 @@ void StateManager11::setViewportBounds(const int width, const int height)
     }
 }
 
+void StateManager11::updatePresentPath(bool presentPathFastActive,
+                                       const gl::FramebufferAttachment *framebufferAttachment)
+{
+    const int colorBufferHeight =
+        framebufferAttachment ? framebufferAttachment->getSize().height : 0;
+
+    if ((mCurPresentPathFastEnabled != presentPathFastActive) ||
+        (presentPathFastActive && (colorBufferHeight != mCurPresentPathFastColorBufferHeight)))
+    {
+        mCurPresentPathFastEnabled           = presentPathFastActive;
+        mCurPresentPathFastColorBufferHeight = colorBufferHeight;
+        mViewportStateIsDirty                = true;  // Viewport may need to be vertically inverted
+        mScissorStateIsDirty                 = true;  // Scissor rect may need to be vertically inverted
+        mRasterizerStateIsDirty              = true;  // Cull Mode may need to be inverted
+    }
+}
+
 void StateManager11::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
 {
     if (!dirtyBits.any())
@@ -571,8 +588,34 @@ gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterSt
     }
 
     ID3D11RasterizerState *dxRasterState = nullptr;
-    gl::Error error = mRenderer->getStateCache().getRasterizerState(rasterState, mCurScissorEnabled,
+    gl::Error error(GL_NO_ERROR);
+
+    if (mCurPresentPathFastEnabled)
+    {
+        gl::RasterizerState modifiedRasterState = rasterState;
+
+        // If prseent path fast is active then we need invert the front face state.
+        // This ensures that both gl_FrontFacing is correct, and front/back culling
+        // is performed correctly.
+        if (modifiedRasterState.frontFace == GL_CCW)
+        {
+            modifiedRasterState.frontFace = GL_CW;
+        }
+        else
+        {
+            ASSERT(modifiedRasterState.frontFace == GL_CW);
+            modifiedRasterState.frontFace = GL_CCW;
+        }
+
+        error = mRenderer->getStateCache().getRasterizerState(modifiedRasterState,
+                                                              mCurScissorEnabled, &dxRasterState);
+    }
+    else
+    {
+        error = mRenderer->getStateCache().getRasterizerState(rasterState, mCurScissorEnabled,
                                                               &dxRasterState);
+    }
+
     if (error.isError())
     {
         return error;
@@ -591,13 +634,19 @@ void StateManager11::setScissorRectangle(const gl::Rectangle &scissor, bool enab
     if (!mScissorStateIsDirty)
         return;
 
+    int modifiedScissorY = scissor.y;
+    if (mCurPresentPathFastEnabled)
+    {
+        modifiedScissorY = mCurPresentPathFastColorBufferHeight - scissor.height - scissor.y;
+    }
+
     if (enabled)
     {
         D3D11_RECT rect;
         rect.left   = std::max(0, scissor.x);
-        rect.top    = std::max(0, scissor.y);
+        rect.top    = std::max(0, modifiedScissorY);
         rect.right  = scissor.x + std::max(0, scissor.width);
-        rect.bottom = scissor.y + std::max(0, scissor.height);
+        rect.bottom = modifiedScissorY + std::max(0, scissor.height);
 
         mRenderer->getDeviceContext()->RSSetScissorRects(1, &rect);
     }
@@ -639,7 +688,22 @@ void StateManager11::setViewport(const gl::Caps *caps,
 
     D3D11_VIEWPORT dxViewport;
     dxViewport.TopLeftX = static_cast<float>(dxViewportTopLeftX);
+
+    if (mCurPresentPathFastEnabled)
+    {
+        // When present path fast is active and we're rendering to framebuffer 0, we must invert
+        // the viewport in Y-axis.
+        // NOTE: We delay the inversion until right before the call to RSSetViewports, and leave
+        // dxViewportTopLeftY unchanged. This allows us to calculate viewAdjust below using the
+        // unaltered dxViewportTopLeftY value.
+        dxViewport.TopLeftY = static_cast<float>(mCurPresentPathFastColorBufferHeight -
+                                                 dxViewportTopLeftY - dxViewportHeight);
+    }
+    else
+    {
         dxViewport.TopLeftY = static_cast<float>(dxViewportTopLeftY);
+    }
+
     dxViewport.Width    = static_cast<float>(dxViewportWidth);
     dxViewport.Height   = static_cast<float>(dxViewportHeight);
     dxViewport.MinDepth = actualZNear;
@@ -688,6 +752,16 @@ void StateManager11::setViewport(const gl::Caps *caps,
     mPixelConstants.depthRange[1] = actualZFar;
     mPixelConstants.depthRange[2] = actualZFar - actualZNear;
 
+    mPixelConstants.viewScale[0] = 1.0f;
+    mPixelConstants.viewScale[1] = mCurPresentPathFastEnabled ? 1.0f : -1.0f;
+    mPixelConstants.viewScale[2] = 1.0f;
+    mPixelConstants.viewScale[3] = 1.0f;
+
+    mVertexConstants.viewScale[0] = mPixelConstants.viewScale[0];
+    mVertexConstants.viewScale[1] = mPixelConstants.viewScale[1];
+    mVertexConstants.viewScale[2] = mPixelConstants.viewScale[2];
+    mVertexConstants.viewScale[3] = mPixelConstants.viewScale[3];
+
     mViewportStateIsDirty = false;
 }
 

src/libANGLE/renderer/d3d/d3d11/StateManager11.h

@@ -24,6 +24,22 @@ namespace rx
 struct RenderTargetDesc;
 struct Renderer11DeviceCaps;
 
+struct dx_VertexConstants11
+{
+    float depthRange[4];
+    float viewAdjust[4];
+    float viewCoords[4];
+    float viewScale[4];
+};
+
+struct dx_PixelConstants11
+{
+    float depthRange[4];
+    float viewCoords[4];
+    float depthFront[4];
+    float viewScale[4];
+};
+
 class StateManager11 final : angle::NonCopyable
 {
   public:
@@ -46,8 +62,11 @@ class StateManager11 final : angle::NonCopyable
 
     void setViewport(const gl::Caps *caps, const gl::Rectangle &viewport, float zNear, float zFar);
 
-    const dx_VertexConstants &getVertexConstants() const { return mVertexConstants; }
-    const dx_PixelConstants &getPixelConstants() const { return mPixelConstants; }
+    void updatePresentPath(bool presentPathFastActive,
+                           const gl::FramebufferAttachment *framebufferAttachment);
+
+    const dx_VertexConstants11 &getVertexConstants() const { return mVertexConstants; }
+    const dx_PixelConstants11 &getPixelConstants() const { return mPixelConstants; }
 
     void updateStencilSizeIfChanged(bool depthStencilInitialized, unsigned int stencilSize);
 
@@ -90,7 +109,7 @@ class StateManager11 final : angle::NonCopyable
     Optional<bool> mCurDisableDepth;
     Optional<bool> mCurDisableStencil;
 
-    // Currenly applied rasterizer state
+    // Currently applied rasterizer state
     bool mRasterizerStateIsDirty;
     gl::RasterizerState mCurRasterState;
 
@@ -106,8 +125,8 @@ class StateManager11 final : angle::NonCopyable
     float mCurFar;
 
     // Things needed in viewport state
-    dx_VertexConstants mVertexConstants;
-    dx_PixelConstants mPixelConstants;
+    dx_VertexConstants11 mVertexConstants;
+    dx_PixelConstants11 mPixelConstants;
 
     // Render target variables
     gl::Extents mViewportBounds;

src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp

@@ -31,6 +31,17 @@
 namespace rx
 {
 
+namespace
+{
+bool NeedsOffscreenTexture(Renderer11 *renderer, NativeWindow nativeWindow, EGLint orientation)
+{
+    // We don't need an offscreen texture if either orientation = INVERT_Y,
+    // or present path fast is enabled and we're not rendering onto an offscreen surface.
+    return orientation != EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE &&
+           !(renderer->presentPathFastEnabled() && nativeWindow.getNativeWindow());
+}
+}  // anonymous namespace
+
 SwapChain11::SwapChain11(Renderer11 *renderer,
                          NativeWindow nativeWindow,
                          HANDLE shareHandle,
@@ -52,7 +63,7 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
       mBackBufferTexture(nullptr),
       mBackBufferRTView(nullptr),
       mBackBufferSRView(nullptr),
-      mNeedsOffscreenTexture(orientation != EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE),
+      mNeedsOffscreenTexture(NeedsOffscreenTexture(renderer, nativeWindow, orientation)),
       mOffscreenTexture(nullptr),
       mOffscreenRTView(nullptr),
       mOffscreenSRView(nullptr),
@@ -68,6 +79,8 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
       mColorRenderTarget(this, renderer, false),
       mDepthStencilRenderTarget(this, renderer, true)
 {
+    // Sanity check that if present path fast is active then we're using the default orientation
+    ASSERT(!mRenderer->presentPathFastEnabled() || orientation == 0);
 }
 
 SwapChain11::~SwapChain11()

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp

@@ -292,7 +292,7 @@ unsigned int GetReservedVertexUniformVectors(D3D_FEATURE_LEVEL featureLevel)
         case D3D_FEATURE_LEVEL_9_3:
         case D3D_FEATURE_LEVEL_9_2:
         case D3D_FEATURE_LEVEL_9_1:
-            return 2;  // dx_ViewAdjust and dx_ViewCoords
+            return 3;  // dx_ViewAdjust, dx_ViewCoords and dx_ViewScale
 
         default:
             UNREACHABLE();
@@ -313,7 +313,7 @@ unsigned int GetReservedFragmentUniformVectors(D3D_FEATURE_LEVEL featureLevel)
         case D3D_FEATURE_LEVEL_9_3:
         case D3D_FEATURE_LEVEL_9_2:
         case D3D_FEATURE_LEVEL_9_1:
-            return 2;
+            return 3;
 
         default:
             UNREACHABLE();
@@ -1668,4 +1668,16 @@ gl::ErrorOrResult<TextureHelper11> CreateStagingTexture(GLenum textureType,
     return TextureHelper11::MakeAndPossess3D(stagingTex);
 }
 
+bool UsePresentPathFast(const Renderer11 *renderer,
+                        const gl::FramebufferAttachment *framebufferAttachment)
+{
+    if (framebufferAttachment == nullptr)
+    {
+        return false;
+    }
+
+    return (framebufferAttachment->type() == GL_FRAMEBUFFER_DEFAULT &&
+            renderer->presentPathFastEnabled());
+}
+
 }  // namespace rx

src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h

@@ -25,6 +25,7 @@ class FramebufferAttachment;
 
 namespace rx
 {
+class Renderer11;
 class RenderTarget11;
 struct WorkaroundsD3D;
 struct Renderer11DeviceCaps;
@@ -377,6 +378,8 @@ gl::ErrorOrResult<TextureHelper11> CreateStagingTexture(GLenum textureType,
                                                         const gl::Extents &size,
                                                         ID3D11Device *device);
 
+bool UsePresentPathFast(const Renderer11 *renderer, const gl::FramebufferAttachment *colorbuffer);
+
 }  // namespace rx
 
 #endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_UTILS_H_

src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp

@@ -154,7 +154,8 @@ HRESULT CoreWindowNativeWindow::createSwapChain(ID3D11Device *device,
     swapChainDesc.Stereo = FALSE;
     swapChainDesc.SampleDesc.Count = 1;
     swapChainDesc.SampleDesc.Quality = 0;
-    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER;
+    swapChainDesc.BufferUsage =
+        DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER;
     swapChainDesc.BufferCount = 2;
     swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
     swapChainDesc.Scaling = DXGI_SCALING_STRETCH;

src/libANGLE/renderer/d3d/d3d11/winrt/SwapChainPanelNativeWindow.cpp

@@ -257,7 +257,8 @@ HRESULT SwapChainPanelNativeWindow::createSwapChain(ID3D11Device *device,
     swapChainDesc.Stereo = FALSE;
     swapChainDesc.SampleDesc.Count = 1;
     swapChainDesc.SampleDesc.Quality = 0;
-    swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER;
+    swapChainDesc.BufferUsage =
+        DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER;
     swapChainDesc.BufferCount = 2;
     swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
     swapChainDesc.Scaling = DXGI_SCALING_STRETCH;

src/libANGLE/renderer/d3d/d3d9/StateManager9.cpp

@@ -489,8 +489,8 @@ void StateManager9::setViewportState(const gl::Caps *caps,
     mCurIgnoreViewport = ignoreViewport;
 
     // Setting shader constants
-    dx_VertexConstants vc = {};
-    dx_PixelConstants pc  = {};
+    dx_VertexConstants9 vc = {};
+    dx_PixelConstants9 pc  = {};
 
     vc.viewAdjust[0] =
         static_cast<float>((actualViewport.width - static_cast<int>(dxViewport.Width)) +
@@ -520,13 +520,13 @@ void StateManager9::setViewportState(const gl::Caps *caps,
     pc.depthRange[1] = actualZFar;
     pc.depthRange[2] = actualZFar - actualZNear;
 
-    if (memcmp(&vc, &mVertexConstants, sizeof(dx_VertexConstants)) != 0)
+    if (memcmp(&vc, &mVertexConstants, sizeof(dx_VertexConstants9)) != 0)
     {
         mVertexConstants = vc;
         mDxUniformsDirty = true;
     }
 
-    if (memcmp(&pc, &mPixelConstants, sizeof(dx_PixelConstants)) != 0)
+    if (memcmp(&pc, &mPixelConstants, sizeof(dx_PixelConstants9)) != 0)
     {
         mPixelConstants  = pc;
         mDxUniformsDirty = true;
@@ -542,9 +542,9 @@ void StateManager9::setShaderConstants()
 
     IDirect3DDevice9 *device = mRenderer9->getDevice();
     device->SetVertexShaderConstantF(0, reinterpret_cast<float *>(&mVertexConstants),
-                                     sizeof(dx_VertexConstants) / sizeof(float[4]));
+                                     sizeof(dx_VertexConstants9) / sizeof(float[4]));
     device->SetPixelShaderConstantF(0, reinterpret_cast<float *>(&mPixelConstants),
-                                    sizeof(dx_PixelConstants) / sizeof(float[4]));
+                                    sizeof(dx_PixelConstants9) / sizeof(float[4]));
     mDxUniformsDirty = false;
 }
 

src/libANGLE/renderer/d3d/d3d9/StateManager9.h

@@ -19,6 +19,20 @@ namespace rx
 
 class Renderer9;
 
+struct dx_VertexConstants9
+{
+    float depthRange[4];
+    float viewAdjust[4];
+    float viewCoords[4];
+};
+
+struct dx_PixelConstants9
+{
+    float depthRange[4];
+    float viewCoords[4];
+    float depthFront[4];
+};
+
 class StateManager9 final : angle::NonCopyable
 {
   public:
@@ -175,8 +189,8 @@ class StateManager9 final : angle::NonCopyable
     float mCurDepthFront;
     bool mCurIgnoreViewport;
 
-    dx_VertexConstants mVertexConstants;
-    dx_PixelConstants mPixelConstants;
+    dx_VertexConstants9 mVertexConstants;
+    dx_PixelConstants9 mPixelConstants;
     bool mDxUniformsDirty;
 
     // FIXME: Unsupported by D3D9

src/libGLESv2/entry_points_egl_ext.cpp

@@ -163,6 +163,7 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
         bool minorVersionSpecified   = false;
         bool enableAutoTrimSpecified = false;
         bool deviceTypeSpecified     = false;
+        bool presentPathSpecified    = false;
 
         if (attrib_list)
         {
@@ -228,6 +229,29 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
                     enableAutoTrimSpecified = true;
                     break;
 
+                    case EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE:
+                        if (!clientExtensions.experimentalPresentPath)
+                        {
+                            SetGlobalError(
+                                Error(EGL_BAD_ATTRIBUTE,
+                                      "EGL_ANGLE_experimental_present_path extension not active"));
+                            return EGL_NO_DISPLAY;
+                        }
+
+                        switch (curAttrib[1])
+                        {
+                            case EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE:
+                            case EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE:
+                                break;
+                            default:
+                                SetGlobalError(
+                                    Error(EGL_BAD_ATTRIBUTE,
+                                          "Invalid value for EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE"));
+                                return EGL_NO_DISPLAY;
+                        }
+                        presentPathSpecified = true;
+                        break;
+
                     case EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE:
                         switch (curAttrib[1])
                         {
@@ -282,6 +306,14 @@ EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_disp
             return EGL_NO_DISPLAY;
         }
 
+        if (presentPathSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
+        {
+            SetGlobalError(Error(EGL_BAD_ATTRIBUTE,
+                                 "EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE requires a device type of "
+                                 "EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE."));
+            return EGL_NO_DISPLAY;
+        }
+
         if (deviceTypeSpecified && platformType != EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE &&
             platformType != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
         {

src/tests/angle_end2end_tests.gypi

@@ -83,6 +83,7 @@
             '<(angle_path)/src/tests/gl_tests/D3D11FormatTablesTest.cpp',
             '<(angle_path)/src/tests/gl_tests/D3D11InputLayoutCacheTest.cpp',
             '<(angle_path)/src/tests/egl_tests/EGLDeviceTest.cpp',
+            '<(angle_path)/src/tests/egl_tests/EGLPresentPathD3D11Test.cpp',
             # TODO(cwallez) for Linux, requires a portable implementation of threads
             '<(angle_path)/src/tests/egl_tests/EGLThreadTest.cpp',
         ],

src/tests/gl_tests/BlitFramebufferANGLETest.cpp

@@ -892,4 +892,7 @@ TEST_P(BlitFramebufferANGLETest, Errors)
 // default framebuffer is BGRA to enable the GL and GLES backends. (http://anglebug.com/1289)
 
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
-ANGLE_INSTANTIATE_TEST(BlitFramebufferANGLETest, ES2_D3D9(), ES2_D3D11());
+ANGLE_INSTANTIATE_TEST(BlitFramebufferANGLETest,
+                       ES2_D3D9(),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE));

src/tests/gl_tests/CopyTexImageTest.cpp

@@ -302,7 +302,8 @@ TEST_P(CopyTexImageTest, SubImageRGBToL)
 // tests should be run against.
 ANGLE_INSTANTIATE_TEST(CopyTexImageTest,
                        ES2_D3D9(),
-                       ES2_D3D11(),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE),
                        ES2_OPENGL(),
                        ES2_OPENGL(3, 3),
                        ES2_OPENGLES());

src/tests/gl_tests/MipmapTest.cpp

@@ -928,7 +928,8 @@ TEST_P(MipmapTestES3, MipmapsForTexture3D)
 // Note: we run these tests against 9_3 on WARP due to hardware driver issues on Win7
 ANGLE_INSTANTIATE_TEST(MipmapTest,
                        ES2_D3D9(),
-                       ES2_D3D11(),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE),
                        ES2_D3D11_FL9_3_WARP(),
                        ES2_OPENGL(),
                        ES3_OPENGL(),

src/tests/gl_tests/SimpleOperationTest.cpp

@@ -201,7 +201,8 @@ TEST_P(SimpleOperationTest, BufferSubData)
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 ANGLE_INSTANTIATE_TEST(SimpleOperationTest,
                        ES2_D3D9(),
-                       ES2_D3D11(),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE),
                        ES3_D3D11(),
                        ES2_OPENGL(),
                        ES3_OPENGL(),

src/tests/gl_tests/ViewportTest.cpp

@@ -263,7 +263,8 @@ TEST_P(ViewportTest, TripleWindowOffCenter)
 // D3D11 Feature Level 9 and D3D9 emulate large and negative viewports in the vertex shader. We should test both of these as well as D3D11 Feature Level 10_0+.
 ANGLE_INSTANTIATE_TEST(ViewportTest,
                        ES2_D3D9(),
-                       ES2_D3D11(),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE),
+                       ES2_D3D11(EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE),
                        ES2_D3D11_FL9_3(),
                        ES2_OPENGLES(),
                        ES3_OPENGLES());

src/tests/test_utils/angle_test_configs.cpp

@@ -113,6 +113,25 @@ std::ostream &operator<<(std::ostream& stream, const PlatformParameters &pp)
         break;
     }
 
+    switch (pp.eglParameters.presentPath)
+    {
+        case EGL_EXPERIMENTAL_PRESENT_PATH_COPY_ANGLE:
+            stream << "_PRESENT_PATH_COPY";
+            break;
+
+        case EGL_EXPERIMENTAL_PRESENT_PATH_FAST_ANGLE:
+            stream << "_PRESENT_PATH_FAST";
+            break;
+
+        case EGL_DONT_CARE:
+            // default
+            break;
+
+        default:
+            UNREACHABLE();
+            break;
+    }
+
     return stream;
 }
 
@@ -165,6 +184,12 @@ EGLPlatformParameters D3D11()
         EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE);
 }
 
+EGLPlatformParameters D3D11(EGLenum presentPath)
+{
+    return EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, EGL_DONT_CARE, EGL_DONT_CARE,
+                                 EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE, presentPath);
+}
+
 EGLPlatformParameters D3D11_FL11_1()
 {
     return EGLPlatformParameters(
@@ -360,6 +385,11 @@ PlatformParameters ES2_D3D11()
     return PlatformParameters(2, 0, egl_platform::D3D11());
 }
 
+PlatformParameters ES2_D3D11(EGLenum presentPath)
+{
+    return PlatformParameters(2, 0, egl_platform::D3D11(presentPath));
+}
+
 PlatformParameters ES2_D3D11_FL11_0()
 {
     return PlatformParameters(2, 0, egl_platform::D3D11_FL11_0());

src/tests/test_utils/angle_test_configs.h

@@ -52,6 +52,7 @@ EGLPlatformParameters D3D9_NULL();
 EGLPlatformParameters D3D9_REFERENCE();
 
 EGLPlatformParameters D3D11();
+EGLPlatformParameters D3D11(EGLenum presentPath);
 EGLPlatformParameters D3D11_FL11_1();
 EGLPlatformParameters D3D11_FL11_0();
 EGLPlatformParameters D3D11_FL10_1();
@@ -88,6 +89,7 @@ PlatformParameters ES2_D3D9();
 PlatformParameters ES2_D3D9_REFERENCE();
 
 PlatformParameters ES2_D3D11();
+PlatformParameters ES2_D3D11(EGLenum presentPath);
 PlatformParameters ES2_D3D11_FL11_0();
 PlatformParameters ES2_D3D11_FL10_1();
 PlatformParameters ES2_D3D11_FL10_0();

util/EGLWindow.cpp

@@ -16,7 +16,8 @@ EGLPlatformParameters::EGLPlatformParameters()
     : renderer(EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE),
       majorVersion(EGL_DONT_CARE),
       minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_DONT_CARE)
+      deviceType(EGL_DONT_CARE),
+      presentPath(EGL_DONT_CARE)
 {
 }
 
@@ -24,7 +25,8 @@ EGLPlatformParameters::EGLPlatformParameters(EGLint renderer)
     : renderer(renderer),
       majorVersion(EGL_DONT_CARE),
       minorVersion(EGL_DONT_CARE),
-      deviceType(EGL_DONT_CARE)
+      deviceType(EGL_DONT_CARE),
+      presentPath(EGL_DONT_CARE)
 {
     if (renderer == EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE ||
         renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
@@ -33,11 +35,28 @@ EGLPlatformParameters::EGLPlatformParameters(EGLint renderer)
     }
 }
 
-EGLPlatformParameters::EGLPlatformParameters(EGLint renderer, EGLint majorVersion, EGLint minorVersion, EGLint useWarp)
+EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
+                                             EGLint majorVersion,
+                                             EGLint minorVersion,
+                                             EGLint useWarp)
     : renderer(renderer),
       majorVersion(majorVersion),
       minorVersion(minorVersion),
-      deviceType(useWarp)
+      deviceType(useWarp),
+      presentPath(EGL_DONT_CARE)
+{
+}
+
+EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
+                                             EGLint majorVersion,
+                                             EGLint minorVersion,
+                                             EGLint useWarp,
+                                             EGLint presentPath)
+    : renderer(renderer),
+      majorVersion(majorVersion),
+      minorVersion(minorVersion),
+      deviceType(useWarp),
+      presentPath(presentPath)
 {
 }
 
@@ -58,15 +77,19 @@ bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
         return a.minorVersion < b.minorVersion;
     }
 
+    if (a.deviceType != b.deviceType)
+    {
         return a.deviceType < b.deviceType;
+    }
+
+    return a.presentPath < b.presentPath;
 }
 
 bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
 {
-    return (a.renderer == b.renderer) &&
-           (a.majorVersion == b.majorVersion) &&
-           (a.minorVersion == b.minorVersion) &&
-           (a.deviceType == b.deviceType);
+    return (a.renderer == b.renderer) && (a.majorVersion == b.majorVersion) &&
+           (a.minorVersion == b.minorVersion) && (a.deviceType == b.deviceType) &&
+           (a.presentPath == b.presentPath);
 }
 
 EGLWindow::EGLWindow(EGLint glesMajorVersion,
@@ -142,6 +165,20 @@ bool EGLWindow::initializeGL(OSWindow *osWindow)
         displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
         displayAttributes.push_back(mPlatform.deviceType);
     }
+
+    if (mPlatform.presentPath != EGL_DONT_CARE)
+    {
+        const char *extensionString =
+            static_cast<const char *>(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
+        if (strstr(extensionString, "EGL_ANGLE_experimental_present_path") == nullptr)
+        {
+            destroyGL();
+            return false;
+        }
+
+        displayAttributes.push_back(EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE);
+        displayAttributes.push_back(mPlatform.presentPath);
+    }
     displayAttributes.push_back(EGL_NONE);
 
     mDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,

util/EGLWindow.h

@@ -34,10 +34,16 @@ struct EGLPlatformParameters
     EGLint majorVersion;
     EGLint minorVersion;
     EGLint deviceType;
+    EGLint presentPath;
 
     EGLPlatformParameters();
     explicit EGLPlatformParameters(EGLint renderer);
     EGLPlatformParameters(EGLint renderer, EGLint majorVersion, EGLint minorVersion, EGLint deviceType);
+    EGLPlatformParameters(EGLint renderer,
+                          EGLint majorVersion,
+                          EGLint minorVersion,
+                          EGLint deviceType,
+                          EGLint presentPath);
 };
 
 bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b);