kc3-lang/angle/src/libANGLE/renderer/d3d/SurfaceD3D.h

• Show log

  Commit

• Hash : d66e1939
  Author :
  Date : 2018-01-17T11:36:24
  

  Allow creating EGL pbuffers from typeless D3D textures
  
  A new extension EGL_ANGLE_d3d_typeless_texture_client_buffer is added
  that allows creating EGL pbuffers from typeless D3D textures.
  
  The extension increases the flexibility of the API compared to plain
  EGL_ANGLE_D3D_texture_client_buffer. The colorspace for the created
  EGL pbuffer can be set by using the EGL_GL_COLORSPACE attribute.
  Internally this sets the ANGLE format of the buffer. There are new
  ANGLE formats that are used specifically for typeless textures,
  separate ones for SRGB and linear views into the D3D textures.
  
  The extension is only supported on the D3D11 backend of ANGLE.
  
  BUG=angleproject:2300
  TEST=angle_white_box_tests
  
  Change-Id: I6a6cb873d2cc0dca0b7f18a0f2cd35e7bafcb7d8
  Reviewed-on: https://chromium-review.googlesource.com/873917
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/libANGLE/renderer/d3d/SurfaceD3D.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.
  //
  
  // SurfaceD3D.h: D3D implementation of an EGL surface
  
  #ifndef LIBANGLE_RENDERER_D3D_SURFACED3D_H_
  #define LIBANGLE_RENDERER_D3D_SURFACED3D_H_
  
  #include "libANGLE/renderer/SurfaceImpl.h"
  #include "libANGLE/renderer/d3d/NativeWindowD3D.h"
  
  namespace egl
  {
  class Surface;
  }
  
  namespace rx
  {
  class SwapChainD3D;
  class RendererD3D;
  
  class SurfaceD3D : public SurfaceImpl
  {
    public:
      ~SurfaceD3D() override;
      void releaseSwapChain();
  
      egl::Error initialize(const egl::Display *display) override;
      FramebufferImpl *createDefaultFramebuffer(const gl::FramebufferState &state) override;
  
      egl::Error swap(const gl::Context *context) override;
      egl::Error postSubBuffer(const gl::Context *context,
                               EGLint x,
                               EGLint y,
                               EGLint width,
                               EGLint height) override;
      egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;
      egl::Error bindTexImage(gl::Texture *texture, EGLint buffer) override;
      egl::Error releaseTexImage(EGLint buffer) override;
      egl::Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) override;
      void setSwapInterval(EGLint interval) override;
  
      EGLint getWidth() const override;
      EGLint getHeight() const override;
  
      EGLint isPostSubBufferSupported() const override;
      EGLint getSwapBehavior() const override;
  
      // D3D implementations
      SwapChainD3D *getSwapChain() const;
  
      egl::Error resetSwapChain(const egl::Display *display);
  
      egl::Error checkForOutOfDateSwapChain(const gl::Context *context);
  
      gl::Error getAttachmentRenderTarget(const gl::Context *context,
                                          GLenum binding,
                                          const gl::ImageIndex &imageIndex,
                                          FramebufferAttachmentRenderTarget **rtOut) override;
  
      const angle::Format *getD3DTextureColorFormat() const override;
  
    protected:
      SurfaceD3D(const egl::SurfaceState &state,
                 RendererD3D *renderer,
                 egl::Display *display,
                 EGLNativeWindowType window,
                 EGLenum buftype,
                 EGLClientBuffer clientBuffer,
                 const egl::AttributeMap &attribs);
  
      egl::Error swapRect(const gl::Context *context,
                          EGLint x,
                          EGLint y,
                          EGLint width,
                          EGLint height);
      egl::Error resetSwapChain(const gl::Context *context,
                                int backbufferWidth,
                                int backbufferHeight);
      egl::Error resizeSwapChain(const gl::Context *context,
                                 int backbufferWidth,
                                 int backbufferHeight);
  
      RendererD3D *mRenderer;
      egl::Display *mDisplay;
  
      bool mFixedSize;
      GLint mOrientation;
  
      GLenum mRenderTargetFormat;
      GLenum mDepthStencilFormat;
      const angle::Format *mColorFormat;
  
      SwapChainD3D *mSwapChain;
      bool mSwapIntervalDirty;
  
      NativeWindowD3D *mNativeWindow;  // Handler for the Window that the surface is created for.
      EGLint mWidth;
      EGLint mHeight;
  
      EGLint mSwapInterval;
  
      HANDLE mShareHandle;
      IUnknown *mD3DTexture;
  
      EGLenum mBuftype;
  };
  
  class WindowSurfaceD3D : public SurfaceD3D
  {
    public:
      WindowSurfaceD3D(const egl::SurfaceState &state,
                       RendererD3D *renderer,
                       egl::Display *display,
                       EGLNativeWindowType window,
                       const egl::AttributeMap &attribs);
      ~WindowSurfaceD3D() override;
  };
  
  class PbufferSurfaceD3D : public SurfaceD3D
  {
    public:
      PbufferSurfaceD3D(const egl::SurfaceState &state,
                        RendererD3D *renderer,
                        egl::Display *display,
                        EGLenum buftype,
                        EGLClientBuffer clientBuffer,
                        const egl::AttributeMap &attribs);
      ~PbufferSurfaceD3D() override;
  };
  
  }  // namespace rx
  
  #endif // LIBANGLE_RENDERER_D3D_SURFACED3D_H_
  

Download