GLX: Expose EGL_ANGLE_window_fixed_size

src/libANGLE/Surface.cpp

@@ -34,9 +34,11 @@ SurfaceState::SurfaceState(const egl::Config *configIn, const AttributeMap &attr
       config((configIn != nullptr) ? new egl::Config(*configIn) : nullptr),
       attributes(attributesIn),
       timestampsEnabled(false),
-      directComposition(false)
+      directComposition(false),
+      isFixedSize(false)
 {
     directComposition = attributes.get(EGL_DIRECT_COMPOSITION_ANGLE, EGL_FALSE) == EGL_TRUE;
+    isFixedSize       = attributes.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE) == EGL_TRUE;
 }
 
 SurfaceState::~SurfaceState()
@@ -70,7 +72,6 @@ Surface::Surface(EGLint surfaceType,
       mHorizontalResolution(EGL_UNKNOWN),
       mVerticalResolution(EGL_UNKNOWN),
       mMultisampleResolve(EGL_MULTISAMPLE_RESOLVE_DEFAULT),
-      mFixedSize(false),
       mFixedWidth(0),
       mFixedHeight(0),
       mTextureFormat(TextureFormat::NoTexture),
@@ -115,8 +116,7 @@ Surface::Surface(EGLint surfaceType,
         mInitState = gl::InitState::MayNeedInit;
     }
 
-    mFixedSize = (attributes.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE) == EGL_TRUE);
-    if (mFixedSize)
+    if (mState.isFixedSize)
     {
         mFixedWidth  = static_cast<size_t>(attributes.get(EGL_WIDTH, 0));
         mFixedHeight = static_cast<size_t>(attributes.get(EGL_HEIGHT, 0));
@@ -469,22 +469,22 @@ EGLenum Surface::getMultisampleResolve() const
 
 EGLint Surface::isFixedSize() const
 {
-    return mFixedSize;
+    return mState.isFixedSize;
 }
 
 EGLint Surface::getWidth() const
 {
-    return mFixedSize ? static_cast<EGLint>(mFixedWidth) : mImplementation->getWidth();
+    return mState.isFixedSize ? static_cast<EGLint>(mFixedWidth) : mImplementation->getWidth();
 }
 
 EGLint Surface::getHeight() const
 {
-    return mFixedSize ? static_cast<EGLint>(mFixedHeight) : mImplementation->getHeight();
+    return mState.isFixedSize ? static_cast<EGLint>(mFixedHeight) : mImplementation->getHeight();
 }
 
 egl::Error Surface::getUserWidth(const egl::Display *display, EGLint *value) const
 {
-    if (mFixedSize)
+    if (mState.isFixedSize)
     {
         *value = static_cast<EGLint>(mFixedWidth);
         return NoError();
@@ -497,7 +497,7 @@ egl::Error Surface::getUserWidth(const egl::Display *display, EGLint *value) con
 
 egl::Error Surface::getUserHeight(const egl::Display *display, EGLint *value) const
 {
-    if (mFixedSize)
+    if (mState.isFixedSize)
     {
         *value = static_cast<EGLint>(mFixedHeight);
         return NoError();

src/libANGLE/Surface.h

@@ -58,6 +58,7 @@ struct SurfaceState final : private angle::NonCopyable
     SupportedCompositorTiming supportedCompositorTimings;
     SupportedTimestamps supportedTimestamps;
     bool directComposition;
+    bool isFixedSize;
 };
 
 class Surface : public LabeledObject, public gl::FramebufferAttachmentObject

src/libANGLE/renderer/gl/glx/DisplayGLX.cpp

@@ -896,6 +896,7 @@ void DisplayGLX::generateExtensions(egl::DisplayExtensions *outExtensions) const
     outExtensions->displaySemaphoreShareGroup = true;
 
     outExtensions->surfacelessContext = true;
+    outExtensions->windowFixedSize    = true;
 
     if (!mRenderer->getFeatures().disableSyncControlSupport.enabled)
     {

src/libANGLE/renderer/gl/glx/WindowSurfaceGLX.cpp

@@ -10,6 +10,7 @@
 
 #include "common/debug.h"
 
+#include "libANGLE/Surface.h"
 #include "libANGLE/renderer/gl/glx/DisplayGLX.h"
 #include "libANGLE/renderer/gl/glx/FunctionsGLX.h"
 
@@ -140,10 +141,13 @@ egl::Error WindowSurfaceGLX::swap(const gl::Context *context)
     mGLXDisplay->setSwapInterval(mGLXWindow, &mSwapControl);
     mGLX.swapBuffers(mGLXWindow);
 
-    egl::Error error = checkForResize();
-    if (error.isError())
+    if (!mState.isFixedSize)
     {
-        return error;
+        egl::Error error = checkForResize();
+        if (error.isError())
+        {
+            return error;
+        }
     }
 
     return egl::NoError();
@@ -235,6 +239,24 @@ glx::Drawable WindowSurfaceGLX::getDrawable() const
     return mGLXWindow;
 }
 
+void WindowSurfaceGLX::setFixedWidth(EGLint width)
+{
+    mParentWidth = width;
+    mGLX.waitGL();
+    XResizeWindow(mDisplay, mWindow, mParentWidth, mParentHeight);
+    mGLX.waitX();
+    XSync(mDisplay, False);
+}
+
+void WindowSurfaceGLX::setFixedHeight(EGLint height)
+{
+    mParentHeight = height;
+    mGLX.waitGL();
+    XResizeWindow(mDisplay, mWindow, mParentWidth, mParentHeight);
+    mGLX.waitX();
+    XSync(mDisplay, False);
+}
+
 bool WindowSurfaceGLX::getWindowDimensions(Window window,
                                            unsigned int *width,
                                            unsigned int *height) const

src/libANGLE/renderer/gl/glx/WindowSurfaceGLX.h

@@ -56,6 +56,9 @@ class WindowSurfaceGLX : public SurfaceGLX
     egl::Error checkForResize() override;
     glx::Drawable getDrawable() const override;
 
+    void setFixedWidth(EGLint width) override;
+    void setFixedHeight(EGLint height) override;
+
     egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override;
     egl::Error getMscRate(EGLint *numerator, EGLint *denominator) override;