Add texture offset attributess for D3D texture pbuffer surfaces

extensions/EGL_ANGLE_d3d_texture_client_buffer.txt

@@ -22,7 +22,7 @@ Status
 
 Version
 
-    Version 5, Sep 6, 2019
+    Version 6, May 12, 2020
 
 Number
 
@@ -75,13 +75,17 @@ Additions to Chapter 2 of the EGL 1.2 Specification (EGL Operation)
     If <target> is EGL_D3D_TEXTURE_ANGLE, <dpy> must be a valid display, <ctx>
     must be EGL_NO_CONTEXT, <buffer> must be a pointer to a valid D3D11 texture
     object (cast into the type EGLClientBuffer), and attributes other than
-    EGL_TEXTURE_INTERNAL_FORMAT_ANGLE are ignored. The width and height of
-    the pbuffer are determined by the width and height of <buffer>."
+    EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, EGL_TEXTURE_OFFSET_X_ANGLE, or
+    EGL_TEXTURE_OFFSET_Y_ANGLE are ignored. The width and height of the pbuffer
+    are determined by the width and height of <buffer>.
 
     If EGL_TEXTURE_INTERNAL_FORMAT_ANGLE is specified, it is used to interpret
     <buffer> according to the provided internal format. See table
     egl.restrictions for acceptable texture object types and formats.
 
+    If EGL_TEXTURE_OFFSET_X_ANGLE or EGL_TEXTURE_OFFSET_Y_ANGLE are specified,
+    they are used to offset all rendering into the surface.
+
     If the EGL_ANGLE_device_d3d extension is present, the provided D3D11 texture
     object must have been created by the same D3D11 device queried from the
     display. If these requirements are not met, an EGL_BAD_PARAMETER error is
@@ -122,6 +126,9 @@ Additions to Chapter 3 of the EGL 1.2 Specification (EGL Functions and Errors)
 
                        EGL_TEXTURE_INTERNAL_FORMAT_ANGLE is not supported.
 
+                       EGL_TEXTURE_OFFSET_X_ANGLE and EGL_TEXTURE_OFFSET_Y_ANGLE
+                       are not supported.
+
     ID3D11Texture2D    Usage flags must be D3D11_USAGE_DEFAULT.
 
                        Format must be
@@ -191,8 +198,18 @@ Issues
     to GL_RGB. Images with an RGB format will ensure that the alpha channel of
     the texture is reset to 1.0 when it is used.
 
+    5. What operations do the texture offsets affect?
+
+    RESOLVED: The texture offsets specified by EGL_TEXTURE_OFFSET_X_ANGLE and
+    EGL_TEXTURE_OFFSET_Y_ANGLE affect only rendering into the surface.
+    Specifically these affect the internal D3D viewport and scissor rect states.
+    This is needed to apply the update offset returned by calling BeginDraw() on
+    IDCompositionSurface, and is needed for correct rendering in that case.
+
 Revision History
 
+    Version 6, 2020/05/12 - added support for specifying texture offsets.
+
     Version 5, 2019/09/06 - added support for creating EGLImage.
 
     Version 4, 2019/04/15 - added support for DXGI_FORMAT_R10G10B10A2_UNORM.

include/EGL/eglext_angle.h

@@ -25,6 +25,8 @@
 #ifndef EGL_ANGLE_d3d_texture_client_buffer
 #define EGL_ANGLE_d3d_texture_client_buffer 1
 #define EGL_D3D_TEXTURE_ANGLE             0x33A3
+#define EGL_TEXTURE_OFFSET_X_ANGLE        0x3490
+#define EGL_TEXTURE_OFFSET_Y_ANGLE        0x3491
 #endif /* EGL_ANGLE_d3d_texture_client_buffer */
 
 #ifndef EGL_ANGLE_software_display

src/libANGLE/Framebuffer.cpp

@@ -1727,6 +1727,15 @@ bool Framebuffer::hasValidDepthStencil() const
     return mState.getDepthStencilAttachment() != nullptr;
 }
 
+gl::Offset Framebuffer::getTextureOffset() const
+{
+    if (isDefault() && getFirstColorAttachment()->getSurface())
+    {
+        return getFirstColorAttachment()->getSurface()->getTextureOffset();
+    }
+    return gl::Offset();
+}
+
 void Framebuffer::setAttachment(const Context *context,
                                 GLenum type,
                                 GLenum binding,

src/libANGLE/Framebuffer.h

@@ -314,6 +314,11 @@ class Framebuffer final : public angle::ObserverInterface,
 
     bool hasValidDepthStencil() const;
 
+    // Returns the offset into the texture backing the default framebuffer's surface if any. Returns
+    // zero offset otherwise.  Offset is applied to scissor and viewport rects so that it applies to
+    // all rendering.
+    gl::Offset getTextureOffset() const;
+
     angle::Result discard(const Context *context, size_t count, const GLenum *attachments);
     angle::Result invalidate(const Context *context, size_t count, const GLenum *attachments);
     angle::Result invalidateSub(const Context *context,

src/libANGLE/Surface.cpp

@@ -119,6 +119,9 @@ Surface::Surface(EGLint surfaceType,
     }
 
     mOrientation = static_cast<EGLint>(attributes.get(EGL_SURFACE_ORIENTATION_ANGLE, 0));
+
+    mTextureOffset.x = static_cast<int>(mState.attributes.get(EGL_TEXTURE_OFFSET_X_ANGLE, 0));
+    mTextureOffset.y = static_cast<int>(mState.attributes.get(EGL_TEXTURE_OFFSET_Y_ANGLE, 0));
 }
 
 Surface::~Surface() {}

src/libANGLE/Surface.h

@@ -178,6 +178,11 @@ class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
                              const EGLint *timestamps,
                              EGLnsecsANDROID *values) const;
 
+    // Returns the offset into the texture backing the surface if specified via texture offset
+    // attributes (see EGL_ANGLE_d3d_texture_client_buffer extension). Returns zero offset
+    // otherwise.
+    const gl::Offset &getTextureOffset() const { return mTextureOffset; }
+
   protected:
     Surface(EGLint surfaceType,
             const egl::Config *config,
@@ -235,6 +240,8 @@ class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
     gl::Format mColorFormat;
     gl::Format mDSFormat;
 
+    gl::Offset mTextureOffset;
+
   private:
     Error destroyImpl(const Display *display);
 

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

@@ -14,6 +14,7 @@
 #include "common/utilities.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/Query.h"
+#include "libANGLE/Surface.h"
 #include "libANGLE/VertexArray.h"
 #include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/TextureD3D.h"
@@ -1404,19 +1405,28 @@ angle::Result StateManager11::syncRasterizerState(const gl::Context *context,
     return angle::Result::Continue;
 }
 
-void StateManager11::syncScissorRectangle(const gl::Rectangle &scissor, bool enabled)
+void StateManager11::syncScissorRectangle(const gl::Context *context)
 {
-    int modifiedScissorY = scissor.y;
+    const auto &glState          = context->getState();
+    gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
+    const gl::Rectangle &scissor = glState.getScissor();
+    const bool enabled           = glState.isScissorTestEnabled();
+
+    mCurScissorOffset = framebuffer->getTextureOffset();
+
+    int scissorX = scissor.x + mCurScissorOffset.x;
+    int scissorY = scissor.y + mCurScissorOffset.y;
+
     if (mCurPresentPathFastEnabled)
     {
-        modifiedScissorY = mCurPresentPathFastColorBufferHeight - scissor.height - scissor.y;
+        scissorY = mCurPresentPathFastColorBufferHeight - scissor.height - scissor.y;
     }
 
     if (enabled)
     {
         D3D11_RECT rect;
-        int x       = scissor.x;
-        int y       = modifiedScissorY;
+        int x       = scissorX;
+        int y       = scissorY;
         rect.left   = std::max(0, x);
         rect.top    = std::max(0, y);
         rect.right  = x + std::max(0, scissor.width);
@@ -1459,10 +1469,14 @@ void StateManager11::syncViewport(const gl::Context *context)
     int dxViewportWidth    = 0;
     int dxViewportHeight   = 0;
 
-    dxViewportTopLeftX = gl::clamp(viewport.x, dxMinViewportBoundsX, dxMaxViewportBoundsX);
-    dxViewportTopLeftY = gl::clamp(viewport.y, dxMinViewportBoundsY, dxMaxViewportBoundsY);
-    dxViewportWidth    = gl::clamp(viewport.width, 0, dxMaxViewportBoundsX - dxViewportTopLeftX);
-    dxViewportHeight   = gl::clamp(viewport.height, 0, dxMaxViewportBoundsY - dxViewportTopLeftY);
+    mCurViewportOffset = framebuffer->getTextureOffset();
+
+    dxViewportTopLeftX =
+        gl::clamp(viewport.x + mCurViewportOffset.x, dxMinViewportBoundsX, dxMaxViewportBoundsX);
+    dxViewportTopLeftY =
+        gl::clamp(viewport.y + mCurViewportOffset.y, dxMinViewportBoundsY, dxMaxViewportBoundsY);
+    dxViewportWidth  = gl::clamp(viewport.width, 0, dxMaxViewportBoundsX - dxViewportTopLeftX);
+    dxViewportHeight = gl::clamp(viewport.height, 0, dxMaxViewportBoundsY - dxViewportTopLeftY);
 
     D3D11_VIEWPORT dxViewport;
     dxViewport.TopLeftX = static_cast<float>(dxViewportTopLeftX);
@@ -1540,6 +1554,16 @@ void StateManager11::processFramebufferInvalidation(const gl::Context *context)
     gl::Framebuffer *fbo = context->getState().getDrawFramebuffer();
     ASSERT(fbo);
 
+    // Dirty scissor and viewport because surface texture offset might have changed.
+    if (mCurViewportOffset != fbo->getTextureOffset())
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_VIEWPORT_STATE);
+    }
+    if (mCurScissorOffset != fbo->getTextureOffset())
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_SCISSOR_STATE);
+    }
+
     // Disable the depth test/depth write if we are using a stencil-only attachment.
     // This is because ANGLE emulates stencil-only with D24S8 on D3D11 - we should neither read
     // nor write to the unused depth part of this emulated texture.
@@ -2269,7 +2293,7 @@ angle::Result StateManager11::updateState(const gl::Context *context,
                 syncViewport(context);
                 break;
             case DIRTY_BIT_SCISSOR_STATE:
-                syncScissorRectangle(glState.getScissor(), glState.isScissorTestEnabled());
+                syncScissorRectangle(context);
                 break;
             case DIRTY_BIT_RASTERIZER_STATE:
                 ANGLE_TRY(syncRasterizerState(context, mode));

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

@@ -323,7 +323,7 @@ class StateManager11 final : angle::NonCopyable
 
     angle::Result syncRasterizerState(const gl::Context *context, gl::PrimitiveMode mode);
 
-    void syncScissorRectangle(const gl::Rectangle &scissor, bool enabled);
+    void syncScissorRectangle(const gl::Context *context);
 
     void syncViewport(const gl::Context *context);
 
@@ -490,6 +490,10 @@ class StateManager11 final : angle::NonCopyable
     float mCurNear;
     float mCurFar;
 
+    // Currently applied offset to viewport and scissor
+    gl::Offset mCurViewportOffset;
+    gl::Offset mCurScissorOffset;
+
     // Things needed in viewport state
     ShaderConstants11 mShaderConstants;
 

src/libANGLE/validationEGL.cpp

@@ -1841,12 +1841,14 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display,
                     return EglBadAttribute() << "<buftype> doesn't support texture internal format";
                 }
                 break;
+
             case EGL_GL_COLORSPACE:
                 if (buftype != EGL_D3D_TEXTURE_ANGLE)
                 {
                     return EglBadAttribute() << "<buftype> doesn't support setting GL colorspace";
                 }
                 break;
+
             case EGL_IOSURFACE_USAGE_HINT_ANGLE:
                 if (value & ~(EGL_IOSURFACE_READ_HINT_ANGLE | EGL_IOSURFACE_WRITE_HINT_ANGLE))
                 {
@@ -1854,6 +1856,15 @@ Error ValidateCreatePbufferFromClientBuffer(Display *display,
                            << "IOSurface usage hint must only contain READ or WRITE";
                 }
                 break;
+
+            case EGL_TEXTURE_OFFSET_X_ANGLE:
+            case EGL_TEXTURE_OFFSET_Y_ANGLE:
+                if (buftype != EGL_D3D_TEXTURE_ANGLE)
+                {
+                    return EglBadAttribute() << "<buftype> doesn't support setting texture offset";
+                }
+                break;
+
             default:
                 return EglBadAttribute();
         }