kc3-lang/angle/util/EGLWindow.h

• Show log

  Commit

• Hash : 029a4c94
  Author :
  Date : 2022-05-10T13:02:03
  

  util: Add calls for createImage* and destroyImage* to GLWindow
  
  This adds the interface to the GLWindowBase, an implementation to
  EGLWindow, and placeholder functions to WGLWindow.
  
  Bug: angleproject:4964
  Change-Id: Ia13f5237500cece9564910c95c6c5eea67ca022d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3637559
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Gert Wollny <gert.wollny@collabora.com>
  

Download

• util/EGLWindow.h

• //
  // Copyright 2014 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.
  //
  
  #ifndef UTIL_EGLWINDOW_H_
  #define UTIL_EGLWINDOW_H_
  
  #include <stdint.h>
  #include <list>
  #include <memory>
  #include <string>
  
  #include "common/Optional.h"
  #include "common/angleutils.h"
  #include "util/EGLPlatformParameters.h"
  #include "util/util_export.h"
  #include "util/util_gl.h"
  
  class OSWindow;
  
  namespace angle
  {
  class Library;
  struct PlatformMethods;
  using GenericProc = void (*)();
  }  // namespace angle
  
  struct ANGLE_UTIL_EXPORT ConfigParameters
  {
      ConfigParameters();
      ~ConfigParameters();
  
      void reset();
  
      // Surface and Context parameters.
      int redBits;
      int greenBits;
      int blueBits;
      int alphaBits;
      int depthBits;
      int stencilBits;
  
      Optional<bool> webGLCompatibility;
      Optional<bool> robustResourceInit;
  
      // EGLWindow-specific.
      EGLenum componentType;
      bool multisample;
      bool debug;
      bool noError;
      Optional<bool> extensionsEnabled;
      bool bindGeneratesResource;
      bool clientArraysEnabled;
      bool robustAccess;
      bool mutableRenderBuffer;
      EGLint samples;
      Optional<bool> contextProgramCacheEnabled;
      EGLenum resetStrategy;
      EGLenum colorSpace;
      EGLint swapInterval;
  };
  
  using GLWindowContext = struct GLWindowHandleContext_T *;
  
  enum class GLWindowResult
  {
      NoError,
      NoColorspaceSupport,
      NoMutableRenderBufferSupport,
      Error,
  };
  
  class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
  {
    public:
      static void Delete(GLWindowBase **window);
  
      using Image        = void *;
      using ClientBuffer = void *;
      using Enum         = unsigned int;
      using Attrib       = intptr_t;
      using AttribKHR    = khronos_int32_t;
      using Boolean      = unsigned int;
  
      // It should also be possible to set multisample and floating point framebuffers.
      EGLint getClientMajorVersion() const { return mClientMajorVersion; }
      EGLint getClientMinorVersion() const { return mClientMinorVersion; }
  
      virtual bool initializeGL(OSWindow *osWindow,
                                angle::Library *glWindowingLibrary,
                                angle::GLESDriverType driverType,
                                const EGLPlatformParameters &platformParams,
                                const ConfigParameters &configParams) = 0;
  
      virtual GLWindowResult initializeGLWithResult(OSWindow *osWindow,
                                                    angle::Library *glWindowingLibrary,
                                                    angle::GLESDriverType driverType,
                                                    const EGLPlatformParameters &platformParams,
                                                    const ConfigParameters &configParams) = 0;
  
      virtual bool isGLInitialized() const                        = 0;
      virtual void swap()                                         = 0;
      virtual void destroyGL()                                    = 0;
      virtual bool makeCurrent()                                  = 0;
      virtual bool hasError() const                               = 0;
      virtual bool setSwapInterval(EGLint swapInterval)           = 0;
      virtual angle::GenericProc getProcAddress(const char *name) = 0;
      // EGLContext and HGLRC (WGL) are both "handles", which are implemented as pointers.
      // Use void* here and let the underlying implementation handle interpreting the type correctly.
      virtual GLWindowContext getCurrentContextGeneric()                  = 0;
      virtual GLWindowContext createContextGeneric(GLWindowContext share) = 0;
      virtual bool makeCurrentGeneric(GLWindowContext context)            = 0;
      virtual Image createImage(GLWindowContext context,
                                Enum target,
                                ClientBuffer buffer,
                                const Attrib *attrib_list)                = 0;
      virtual Image createImageKHR(GLWindowContext context,
                                   Enum target,
                                   ClientBuffer buffer,
                                   const AttribKHR *attrib_list)          = 0;
      virtual EGLBoolean destroyImage(Image image)                        = 0;
      virtual EGLBoolean destroyImageKHR(Image image)                     = 0;
  
      bool isMultisample() const { return mConfigParams.multisample; }
      bool isDebugEnabled() const { return mConfigParams.debug; }
  
      const angle::PlatformMethods *getPlatformMethods() const { return mPlatform.platformMethods; }
  
      const EGLPlatformParameters &getPlatform() const { return mPlatform; }
      const ConfigParameters &getConfigParams() const { return mConfigParams; }
  
    protected:
      GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion);
      virtual ~GLWindowBase();
  
      EGLint mClientMajorVersion;
      EGLint mClientMinorVersion;
      EGLPlatformParameters mPlatform;
      ConfigParameters mConfigParams;
  };
  
  class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
  {
    public:
      static EGLWindow *New(EGLint glesMajorVersion, EGLint glesMinorVersion);
      static void Delete(EGLWindow **window);
  
      static EGLBoolean FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *config);
  
      EGLConfig getConfig() const;
      EGLDisplay getDisplay() const;
      EGLSurface getSurface() const;
      EGLContext getContext() const;
  
      bool isContextVersion(EGLint glesMajorVersion, EGLint glesMinorVersion) const;
  
      // Internally initializes the Display, Surface and Context.
      bool initializeGL(OSWindow *osWindow,
                        angle::Library *glWindowingLibrary,
                        angle::GLESDriverType driverType,
                        const EGLPlatformParameters &platformParams,
                        const ConfigParameters &configParams) override;
  
      GLWindowResult initializeGLWithResult(OSWindow *osWindow,
                                            angle::Library *glWindowingLibrary,
                                            angle::GLESDriverType driverType,
                                            const EGLPlatformParameters &platformParams,
                                            const ConfigParameters &configParams) override;
  
      bool isGLInitialized() const override;
      void swap() override;
      void destroyGL() override;
      bool makeCurrent() override;
      bool hasError() const override;
      bool setSwapInterval(EGLint swapInterval) override;
      angle::GenericProc getProcAddress(const char *name) override;
      // Initializes EGL resources.
      GLWindowContext getCurrentContextGeneric() override;
      GLWindowContext createContextGeneric(GLWindowContext share) override;
      bool makeCurrentGeneric(GLWindowContext context) override;
  
      // Only initializes the Display.
      bool initializeDisplay(OSWindow *osWindow,
                             angle::Library *glWindowingLibrary,
                             angle::GLESDriverType driverType,
                             const EGLPlatformParameters &params);
  
      // Only initializes the Surface.
      GLWindowResult initializeSurface(OSWindow *osWindow,
                                       angle::Library *glWindowingLibrary,
                                       const ConfigParameters &params);
  
      // Create an EGL context with this window's configuration
      EGLContext createContext(EGLContext share, EGLint *extraAttributes);
      // Make the EGL context current
      bool makeCurrent(EGLContext context);
  
      Image createImage(GLWindowContext context,
                        Enum target,
                        ClientBuffer buffer,
                        const Attrib *attrib_list) override;
      Image createImageKHR(GLWindowContext context,
                           Enum target,
                           ClientBuffer buffer,
                           const AttribKHR *attrib_list) override;
      EGLBoolean destroyImage(Image image) override;
      EGLBoolean destroyImageKHR(Image image) override;
  
      // Only initializes the Context.
      bool initializeContext();
  
      void destroySurface();
      void destroyContext();
  
      bool isDisplayInitialized() const { return mDisplay != EGL_NO_DISPLAY; }
  
    private:
      EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion);
      ~EGLWindow() override;
  
      EGLConfig mConfig;
      EGLDisplay mDisplay;
      EGLSurface mSurface;
      EGLContext mContext;
  
      EGLint mEGLMajorVersion;
      EGLint mEGLMinorVersion;
  };
  
  #endif  // UTIL_EGLWINDOW_H_
  

Download