kc3-lang/angle/src/libANGLE/renderer/null/DisplayNULL.h

• Show log

  Commit

• Hash : 29bb612e
  Author :
  Date : 2020-05-28T10:32:26
  

  Add egl::ShareGroup class to abstract the share context group
  
  Vulkan backend has a barrier tracker that tracks memory barrier needs of
  all shared resources. Because the buffer/texture objects are shared
  resources within a shared group, the tracker can not live in a context.
  Putting it in a device/renderer requires locks. It fits perfectly in a
  shareGroup object. The work is already done at API level to handle the
  mutex lock for shared context access so that no extra lock needs to be
  taken in the backend. This CL adds egl::ShareGroup class that represents
  the object that are shared among all share context group. At the front
  end this usually will include all the shared resource managers (not done
  in this CL). The ShareGroup object is accessible from gl::State object.
  This CL also adds ability for backend driver to allocate implementation
  specific ShareGroupImpl object. Vulkan backend will then use it to keeps
  the barrier tracker and other things that naturally fits the share group
  concept.
  
  Bug: angleproject:4664
  Change-Id: Ifcd975cbdf5130022e21c41397894afc28f572e7
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2217252
  Reviewed-by: Courtney Goeltzenleuchter <courtneygo@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Charlie Lao <cclao@google.com>
  

Download

• src/libANGLE/renderer/null/DisplayNULL.h

• //
  // Copyright 2016 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.
  //
  // DisplayNULL.h:
  //    Defines the class interface for DisplayNULL, implementing DisplayImpl.
  //
  
  #ifndef LIBANGLE_RENDERER_NULL_DISPLAYNULL_H_
  #define LIBANGLE_RENDERER_NULL_DISPLAYNULL_H_
  
  #include "libANGLE/renderer/DisplayImpl.h"
  
  namespace rx
  {
  class ShareGroupNULL : public ShareGroupImpl
  {};
  
  class AllocationTrackerNULL;
  
  class DisplayNULL : public DisplayImpl
  {
    public:
      DisplayNULL(const egl::DisplayState &state);
      ~DisplayNULL() override;
  
      egl::Error initialize(egl::Display *display) override;
      void terminate() override;
  
      egl::Error makeCurrent(egl::Surface *drawSurface,
                             egl::Surface *readSurface,
                             gl::Context *context) override;
  
      egl::ConfigSet generateConfigs() override;
  
      bool testDeviceLost() override;
      egl::Error restoreLostDevice(const egl::Display *display) override;
  
      bool isValidNativeWindow(EGLNativeWindowType window) const override;
  
      std::string getVendorString() const override;
  
      DeviceImpl *createDevice() override;
  
      egl::Error waitClient(const gl::Context *context) override;
      egl::Error waitNative(const gl::Context *context, EGLint engine) override;
      gl::Version getMaxSupportedESVersion() const override;
      gl::Version getMaxConformantESVersion() const 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 buffer,
                                                 const egl::AttributeMap &attribs) override;
      SurfaceImpl *createPixmapSurface(const egl::SurfaceState &state,
                                       NativePixmapType nativePixmap,
                                       const egl::AttributeMap &attribs) override;
  
      ImageImpl *createImage(const egl::ImageState &state,
                             const gl::Context *context,
                             EGLenum target,
                             const egl::AttributeMap &attribs) override;
  
      ContextImpl *createContext(const gl::State &state,
                                 gl::ErrorSet *errorSet,
                                 const egl::Config *configuration,
                                 const gl::Context *shareContext,
                                 const egl::AttributeMap &attribs) override;
  
      StreamProducerImpl *createStreamProducerD3DTexture(egl::Stream::ConsumerType consumerType,
                                                         const egl::AttributeMap &attribs) override;
  
      ShareGroupImpl *createShareGroup() override;
  
      void populateFeatureList(angle::FeatureList *features) override {}
  
    private:
      void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
      void generateCaps(egl::Caps *outCaps) const override;
  
      std::unique_ptr<AllocationTrackerNULL> mAllocationTracker;
  };
  
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_NULL_DISPLAYNULL_H_
  

Download