kc3-lang/angle/src/libANGLE/renderer/gl/glx/DisplayGLX.h

• Show log

  Commit

• Hash : d8f088e0
  Author :
  Date : 2023-08-14T11:07:24
  

  GL: Remove parallel compile/link without driver support
  
  This feature was practically disabled everywhere due to various bugs,
  and is complicating the code.  In effect, the code was always spawning a
  thread for the compilation and link jobs, immediately fail it (due to a
  workaround), then do the job when compile/link is resolved (much closer
  to draw time).  This leads to bad user experience, but also is racy
  because the shaders may get recompiled in the meantime and there is
  little the GL backend could do to stop that (efficiently).
  
  After this change, parallel compile/link
  is either done by the driver (if supported), or it isn't done.
  
  This is a partial revert of a100d8f471f79b9f88d387164992cc5bd9c6ee9f.
  
  Bug: angleproject:3031
  Bug: chromium:922936
  Bug: chromium:1184692
  Bug: chromium:1202928
  Change-Id: I6348bee3249ccb3828bb98ac2a69dc7d305f821c
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4774785
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/gl/glx/DisplayGLX.h

• //
  // Copyright 2015 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // DisplayGLX.h: GLX implementation of egl::Display
  
  #ifndef LIBANGLE_RENDERER_GL_GLX_DISPLAYGLX_H_
  #define LIBANGLE_RENDERER_GL_GLX_DISPLAYGLX_H_
  
  #include <string>
  #include <vector>
  
  #include "common/Optional.h"
  #include "libANGLE/renderer/gl/DisplayGL.h"
  #include "libANGLE/renderer/gl/RendererGL.h"
  #include "libANGLE/renderer/gl/glx/FunctionsGLX.h"
  
  namespace rx
  {
  
  class FunctionsGLX;
  
  struct SwapControlData;
  
  class DisplayGLX : public DisplayGL
  {
    public:
      DisplayGLX(const egl::DisplayState &state);
      ~DisplayGLX() override;
  
      egl::Error initialize(egl::Display *display) override;
      void terminate() override;
  
      egl::Error makeCurrent(egl::Display *display,
                             egl::Surface *drawSurface,
                             egl::Surface *readSurface,
                             gl::Context *context) override;
  
      SurfaceImpl *createWindowSurface(const egl::SurfaceState &state,
                                       EGLNativeWindowType window,
                                       const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPbufferSurface(const egl::SurfaceState &state,
                                        const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPbufferFromClientBuffer(const egl::SurfaceState &state,
                                                 EGLenum buftype,
                                                 EGLClientBuffer clientBuffer,
                                                 const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPixmapSurface(const egl::SurfaceState &state,
                                       NativePixmapType nativePixmap,
                                       const egl::AttributeMap &attribs) override;
  
      egl::Error validatePixmap(const egl::Config *config,
                                EGLNativePixmapType pixmap,
                                const egl::AttributeMap &attributes) const override;
  
      ContextImpl *createContext(const gl::State &state,
                                 gl::ErrorSet *errorSet,
                                 const egl::Config *configuration,
                                 const gl::Context *shareContext,
                                 const egl::AttributeMap &attribs) override;
  
      egl::ConfigSet generateConfigs() override;
  
      bool testDeviceLost() override;
      egl::Error restoreLostDevice(const egl::Display *display) override;
  
      bool isValidNativeWindow(EGLNativeWindowType window) const override;
  
      egl::Error waitClient(const gl::Context *context) override;
      egl::Error waitNative(const gl::Context *context, EGLint engine) override;
  
      gl::Version getMaxSupportedESVersion() const override;
  
      // Synchronizes with the X server.
      // Calling this is required at the end of every functions that does buffered
      // X calls (not for glX calls) otherwise there might be race conditions
      // between the application's display and ANGLE's one.
      // Calling this only syncs if ANGLE opened the display, or if alwaysSync
      // is true.
      void syncXCommands(bool alwaysSync) const;
  
      // Depending on the supported GLX extension, swap interval can be set
      // globally or per drawable. This function will make sure the drawable's
      // swap interval is the one required so that the subsequent swapBuffers
      // acts as expected.
      void setSwapInterval(glx::Drawable drawable, SwapControlData *data);
  
      bool isWindowVisualIdSpecified() const;
      bool isMatchingWindowVisualId(unsigned long visualId) const;
  
      void initializeFrontendFeatures(angle::FrontendFeatures *features) const override;
  
      void populateFeatureList(angle::FeatureList *features) override;
  
      RendererGL *getRenderer() const override;
  
      bool isX11() const override;
  
    private:
      egl::Error initializeContext(glx::FBConfig config,
                                   const egl::AttributeMap &eglAttributes,
                                   glx::Context *context);
  
      void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
      void generateCaps(egl::Caps *outCaps) const override;
  
      egl::Error makeCurrentSurfaceless(gl::Context *context) override;
  
      int getGLXFBConfigAttrib(glx::FBConfig config, int attrib) const;
      egl::Error createContextAttribs(glx::FBConfig,
                                      const Optional<gl::Version> &version,
                                      int profileMask,
                                      glx::Context *context) const;
  
      std::shared_ptr<RendererGL> mRenderer;
  
      std::map<int, glx::FBConfig> configIdToGLXConfig;
  
      EGLint mRequestedVisual;
      glx::FBConfig mContextConfig;
      glx::Context mContext;
      angle::HashMap<uint64_t, glx::Context> mCurrentNativeContexts;
  
      // A pbuffer the context is current on during ANGLE initialization
      glx::Pbuffer mInitPbuffer;
  
      bool mUsesNewXDisplay;
      bool mIsMesa;
      bool mHasMultisample;
      bool mHasARBCreateContext;
      bool mHasARBCreateContextProfile;
      bool mHasARBCreateContextRobustness;
      bool mHasEXTCreateContextES2Profile;
      bool mHasNVRobustnessVideoMemoryPurge;
  
      enum class SwapControl
      {
          Absent,
          EXT,
          Mesa,
          SGI,
      };
      SwapControl mSwapControl;
      int mMinSwapInterval;
      int mMaxSwapInterval;
      int mCurrentSwapInterval;
  
      glx::Drawable mCurrentDrawable;
  
      FunctionsGLX mGLX;
      Display *mXDisplay;
      egl::Display *mEGLDisplay;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_GL_GLX_DISPLAYGLX_H_
  

Download