1 files changed, 135 insertions, 28 deletions

diff --git a/src/3rdparty/angle/src/libANGLE/Surface.h b/src/3rdparty/angle/src/libANGLE/Surface.h
index e110f5da7b..b3188ff909 100644
--- a/src/3rdparty/angle/src/libANGLE/Surface.h
+++ b/src/3rdparty/angle/src/libANGLE/Surface.h
@@ -14,9 +14,11 @@
 #include <EGL/egl.h>
 
 #include "common/angleutils.h"
+#include "libANGLE/AttributeMap.h"
 #include "libANGLE/Error.h"
 #include "libANGLE/FramebufferAttachment.h"
 #include "libANGLE/RefCountObject.h"
+#include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/SurfaceImpl.h"
 
 namespace gl
@@ -25,33 +27,55 @@ class Framebuffer;
 class Texture;
 }
 
+namespace rx
+{
+class EGLImplFactory;
+}
+
 namespace egl
 {
-class AttributeMap;
 class Display;
 struct Config;
 
-class Surface final : public gl::FramebufferAttachmentObject
+struct SurfaceState final : private angle::NonCopyable
 {
-  public:
-    Surface(rx::SurfaceImpl *impl, EGLint surfaceType, const egl::Config *config, const AttributeMap &attributes);
+    SurfaceState(const egl::Config *configIn, const AttributeMap &attributesIn);
+
+    gl::Framebuffer *defaultFramebuffer;
+    const egl::Config *config;
+    AttributeMap attributes;
+};
 
-    rx::SurfaceImpl *getImplementation() { return mImplementation; }
-    const rx::SurfaceImpl *getImplementation() const { return mImplementation; }
+class Surface : public gl::FramebufferAttachmentObject
+{
+  public:
+    rx::SurfaceImpl *getImplementation() const { return mImplementation; }
 
     EGLint getType() const;
 
-    Error swap();
-    Error postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height);
+    Error initialize(const Display *display);
+    Error swap(const gl::Context *context);
+    Error swapWithDamage(const gl::Context *context, EGLint *rects, EGLint n_rects);
+    Error postSubBuffer(const gl::Context *context,
+                        EGLint x,
+                        EGLint y,
+                        EGLint width,
+                        EGLint height);
     Error querySurfacePointerANGLE(EGLint attribute, void **value);
-    Error bindTexImage(gl::Texture *texture, EGLint buffer);
-    Error releaseTexImage(EGLint buffer);
+    Error bindTexImage(const gl::Context *context, gl::Texture *texture, EGLint buffer);
+    Error releaseTexImage(const gl::Context *context, EGLint buffer);
+
+    Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc);
 
     EGLint isPostSubBufferSupported() const;
 
     void setSwapInterval(EGLint interval);
-    void setIsCurrent(bool isCurrent);
-    void onDestroy();
+    Error setIsCurrent(const gl::Context *context, bool isCurrent);
+    Error onDestroy(const Display *display);
+
+    void setMipmapLevel(EGLint level);
+    void setMultisampleResolve(EGLenum resolve);
+    void setSwapBehavior(EGLenum behavior);
 
     const Config *getConfig() const;
 
@@ -63,19 +87,29 @@ class Surface final : public gl::FramebufferAttachmentObject
     EGLenum getSwapBehavior() const;
     EGLenum getTextureFormat() const;
     EGLenum getTextureTarget() const;
+    bool getLargestPbuffer() const;
+    EGLenum getGLColorspace() const;
+    EGLenum getVGAlphaFormat() const;
+    EGLenum getVGColorspace() const;
+    bool getMipmapTexture() const;
+    EGLint getMipmapLevel() const;
+    EGLint getHorizontalResolution() const;
+    EGLint getVerticalResolution() const;
+    EGLenum getMultisampleResolve() const;
 
     gl::Texture *getBoundTexture() const { return mTexture.get(); }
-    gl::Framebuffer *getDefaultFramebuffer() { return mDefaultFramebuffer; }
+    gl::Framebuffer *getDefaultFramebuffer() { return mState.defaultFramebuffer; }
 
     EGLint isFixedSize() const;
 
     // FramebufferAttachmentObject implementation
-    gl::Extents getAttachmentSize(const gl::FramebufferAttachment::Target &target) const override;
-    GLenum getAttachmentInternalFormat(const gl::FramebufferAttachment::Target &target) const override;
-    GLsizei getAttachmentSamples(const gl::FramebufferAttachment::Target &target) const override;
+    gl::Extents getAttachmentSize(const gl::ImageIndex &imageIndex) const override;
+    const gl::Format &getAttachmentFormat(GLenum binding,
+                                          const gl::ImageIndex &imageIndex) const override;
+    GLsizei getAttachmentSamples(const gl::ImageIndex &imageIndex) const override;
 
-    void onAttach() override {}
-    void onDetach() override {}
+    void onAttach(const gl::Context *context) override {}
+    void onDetach(const gl::Context *context) override {}
     GLuint getId() const override;
 
     bool flexibleSurfaceCompatibilityRequested() const
@@ -86,34 +120,50 @@ class Surface final : public gl::FramebufferAttachmentObject
 
     bool directComposition() const { return mDirectComposition; }
 
-  private:
-    virtual ~Surface();
-    rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override { return mImplementation; }
+    gl::InitState initState(const gl::ImageIndex &imageIndex) const override;
+    void setInitState(const gl::ImageIndex &imageIndex, gl::InitState initState) override;
+
+    bool isRobustResourceInitEnabled() const { return mRobustResourceInitialization; }
+
+  protected:
+    Surface(EGLint surfaceType, const egl::Config *config, const AttributeMap &attributes);
+    ~Surface() override;
+    rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
 
-    gl::Framebuffer *createDefaultFramebuffer();
+    gl::Framebuffer *createDefaultFramebuffer(const Display *display);
 
     // ANGLE-only method, used internally
     friend class gl::Texture;
-    void releaseTexImageFromTexture();
+    void releaseTexImageFromTexture(const gl::Context *context);
 
+    SurfaceState mState;
     rx::SurfaceImpl *mImplementation;
-    gl::Framebuffer *mDefaultFramebuffer;
     int mCurrentCount;
     bool mDestroyed;
 
     EGLint mType;
 
-    const egl::Config *mConfig;
-
     bool mPostSubBufferRequested;
     bool mFlexibleSurfaceCompatibilityRequested;
 
+    bool mLargestPbuffer;
+    EGLenum mGLColorspace;
+    EGLenum mVGAlphaFormat;
+    EGLenum mVGColorspace;
+    bool mMipmapTexture;
+    EGLint mMipmapLevel;
+    EGLint mHorizontalResolution;
+    EGLint mVerticalResolution;
+    EGLenum mMultisampleResolve;
+
     bool mFixedSize;
     size_t mFixedWidth;
     size_t mFixedHeight;
 
     bool mDirectComposition;
 
+    bool mRobustResourceInitialization;
+
     EGLenum mTextureFormat;
     EGLenum mTextureTarget;
 
@@ -123,9 +173,66 @@ class Surface final : public gl::FramebufferAttachmentObject
 
     EGLint mOrientation;
 
-    BindingPointer<gl::Texture> mTexture;
+    gl::BindingPointer<gl::Texture> mTexture;
+
+    gl::Format mBackFormat;
+    gl::Format mDSFormat;
+
+  private:
+    Error destroyImpl(const Display *display);
 };
 
-}
+class WindowSurface final : public Surface
+{
+  public:
+    WindowSurface(rx::EGLImplFactory *implFactory,
+                  const Config *config,
+                  EGLNativeWindowType window,
+                  const AttributeMap &attribs);
+    ~WindowSurface() override;
+};
+
+class PbufferSurface final : public Surface
+{
+  public:
+    PbufferSurface(rx::EGLImplFactory *implFactory,
+                   const Config *config,
+                   const AttributeMap &attribs);
+    PbufferSurface(rx::EGLImplFactory *implFactory,
+                   const Config *config,
+                   EGLenum buftype,
+                   EGLClientBuffer clientBuffer,
+                   const AttributeMap &attribs);
+
+  protected:
+    ~PbufferSurface() override;
+};
+
+class PixmapSurface final : public Surface
+{
+  public:
+    PixmapSurface(rx::EGLImplFactory *implFactory,
+                  const Config *config,
+                  NativePixmapType nativePixmap,
+                  const AttributeMap &attribs);
+
+  protected:
+    ~PixmapSurface() override;
+};
+
+class SurfaceDeleter final
+{
+  public:
+    SurfaceDeleter(const Display *display);
+    ~SurfaceDeleter();
+    void operator()(Surface *surface);
+
+  private:
+    const Display *mDisplay;
+};
+
+using SurfacePointer = angle::UniqueObjectPointerBase<Surface, SurfaceDeleter>;
+
+}  // namespace egl
 
 #endif   // LIBANGLE_SURFACE_H_