kc3-lang/angle/src/libANGLE/renderer/SurfaceImpl.h

• Show log

  Commit

• Hash : ceffd20c
  Author :
  Date : 2018-01-08T16:39:45
  

  Set colorspace of D3D pbuffers according to DXGI format
  
  When a EGL pbuffer is created based on a D3D SRGB texture using
  EGL_ANGLE_d3d_texture_client_buffer, SRGB conversions are performed as
  if it was an SRGB surface. The value of EGL_GL_COLORSPACE now
  reflects that correctly. If the pbuffer is bound to a texture and used
  as a framebuffer attachment, querying GL_FRAMEBUFFER_COLOR_ATTACHMENT
  also reflects that correctly.
  
  The behavior is the same on both the D3D backend, where there is no
  native interop involved, and on the GL backend using
  WGL_NV_DX_interop(2).
  
  There are a few limitations on the GL backend that relies on native
  interop:
  
  1. SRGB conversion for textures created this way can't be disabled
  using the GL_FRAMEBUFFER_SRGB_EXT toggle that's exposed in ANGLE
  through EXT_sRGB_write_control. This is now documented in the
  EGL_ANGLE_d3d_texture_client_buffer spec. On the D3D backend this is
  not a problem since EXT_sRGB_write_control is not supported either
  way.
  
  2. Creating a pbuffer out of a D3D11 texture with the format
  DXGI_FORMAT_B8G8R8A8_UNORM_SRGB does not work, even though it was
  listed as one of the supported formats in the
  EGL_ANGLE_d3d_texture_client_buffer spec. It's now mentioned that
  support for this format is optional.
  
  BUG=angleproject:2300
  TEST=angle_white_box_tests
  
  Change-Id: I70ee0646680805e4469291a5b2ce59e92fda009e
  Reviewed-on: https://chromium-review.googlesource.com/866743
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/libANGLE/renderer/SurfaceImpl.h

• //
  // Copyright (c) 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.
  //
  
  // SurfaceImpl.h: Implementation methods of egl::Surface
  
  #ifndef LIBANGLE_RENDERER_SURFACEIMPL_H_
  #define LIBANGLE_RENDERER_SURFACEIMPL_H_
  
  #include <EGL/egl.h>
  #include <EGL/eglext.h>
  
  #include "common/angleutils.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/renderer/FramebufferAttachmentObjectImpl.h"
  
  namespace angle
  {
  struct Format;
  }
  
  namespace gl
  {
  class FramebufferState;
  }
  
  namespace egl
  {
  class Display;
  struct Config;
  struct SurfaceState;
  class Thread;
  }
  
  namespace rx
  {
  class FramebufferImpl;
  
  class SurfaceImpl : public FramebufferAttachmentObjectImpl
  {
    public:
      SurfaceImpl(const egl::SurfaceState &surfaceState);
      ~SurfaceImpl() override;
      virtual void destroy(const egl::Display *display) {}
  
      virtual egl::Error initialize(const egl::Display *display)                           = 0;
      virtual FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) = 0;
      virtual egl::Error swap(const gl::Context *context)                                  = 0;
      virtual egl::Error swapWithDamage(const gl::Context *context, EGLint *rects, EGLint n_rects);
      virtual egl::Error postSubBuffer(const gl::Context *context,
                                       EGLint x,
                                       EGLint y,
                                       EGLint width,
                                       EGLint height) = 0;
      virtual egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) = 0;
      virtual egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) = 0;
      virtual egl::Error releaseTexImage(EGLint buffer) = 0;
      virtual egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) = 0;
      virtual void setSwapInterval(EGLint interval) = 0;
  
      // width and height can change with client window resizing
      virtual EGLint getWidth() const = 0;
      virtual EGLint getHeight() const = 0;
  
      virtual EGLint isPostSubBufferSupported() const = 0;
      virtual EGLint getSwapBehavior() const = 0;
  
      // Used to query color format from pbuffers created from D3D textures.
      virtual const angle::Format *getD3DTextureColorFormat() const
      {
          UNREACHABLE();
          return nullptr;
      }
  
    protected:
      const egl::SurfaceState &mState;
  };
  
  }
  
  #endif // LIBANGLE_RENDERER_SURFACEIMPL_H_
  
  

Download