kc3-lang/angle/src/libANGLE/renderer/vulkan/DisplayVk.cpp

• Show log

  Commit

• Hash : caa55cd7
  Author :
  Date : 2018-07-05T13:19:35
  

  Vulkan: Support EGL_ANGLE_surface_orientation for vertical surface flipping.
  
  This is a simpler way of flipping when the client is aware of the extension.
  This allows Chrome to render with the correct orientation.
  
  BUG=angleproject:2709
  
  Change-Id: I52216b765a42930f2be043a07fe441a9f875a14d
  Reviewed-on: https://chromium-review.googlesource.com/1127342
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Luc Ferron <lucferron@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/DisplayVk.cpp

• //
  // 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.
  //
  // DisplayVk.cpp:
  //    Implements the class methods for DisplayVk.
  //
  
  #include "libANGLE/renderer/vulkan/DisplayVk.h"
  
  #include "common/debug.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/renderer/vulkan/ContextVk.h"
  #include "libANGLE/renderer/vulkan/RendererVk.h"
  #include "libANGLE/renderer/vulkan/SurfaceVk.h"
  
  namespace rx
  {
  
  DisplayVk::DisplayVk(const egl::DisplayState &state) : DisplayImpl(state), mRenderer(nullptr)
  {
  }
  
  DisplayVk::~DisplayVk()
  {
  }
  
  egl::Error DisplayVk::initialize(egl::Display *display)
  {
      ASSERT(!mRenderer && display != nullptr);
      mRenderer.reset(new RendererVk());
      return mRenderer->initialize(display->getAttributeMap(), getWSIName())
          .toEGL(EGL_NOT_INITIALIZED);
  }
  
  void DisplayVk::terminate()
  {
      mRenderer.reset(nullptr);
  }
  
  egl::Error DisplayVk::makeCurrent(egl::Surface * /*drawSurface*/,
                                    egl::Surface * /*readSurface*/,
                                    gl::Context * /*context*/)
  {
      return egl::NoError();
  }
  
  bool DisplayVk::testDeviceLost()
  {
      // TODO(jmadill): Figure out how to do device lost in Vulkan.
      return false;
  }
  
  egl::Error DisplayVk::restoreLostDevice(const egl::Display *display)
  {
      UNIMPLEMENTED();
      return egl::EglBadAccess();
  }
  
  std::string DisplayVk::getVendorString() const
  {
      std::string vendorString = "Google Inc.";
      if (mRenderer)
      {
          vendorString += " " + mRenderer->getVendorString();
      }
  
      return vendorString;
  }
  
  DeviceImpl *DisplayVk::createDevice()
  {
      UNIMPLEMENTED();
      return nullptr;
  }
  
  egl::Error DisplayVk::waitClient(const gl::Context *context) const
  {
      // TODO(jmadill): Call flush instead of finish once it is implemented in RendererVK.
      // http://anglebug.com/2504
      UNIMPLEMENTED();
  
      return mRenderer->finish(context);
  }
  
  egl::Error DisplayVk::waitNative(const gl::Context *context, EGLint engine) const
  {
      UNIMPLEMENTED();
      return egl::EglBadAccess();
  }
  
  SurfaceImpl *DisplayVk::createWindowSurface(const egl::SurfaceState &state,
                                              EGLNativeWindowType window,
                                              const egl::AttributeMap &attribs)
  {
      EGLint width  = attribs.getAsInt(EGL_WIDTH, 0);
      EGLint height = attribs.getAsInt(EGL_HEIGHT, 0);
  
      return createWindowSurfaceVk(state, window, width, height);
  }
  
  SurfaceImpl *DisplayVk::createPbufferSurface(const egl::SurfaceState &state,
                                               const egl::AttributeMap &attribs)
  {
      ASSERT(mRenderer);
  
      EGLint width  = attribs.getAsInt(EGL_WIDTH, 0);
      EGLint height = attribs.getAsInt(EGL_HEIGHT, 0);
  
      return new OffscreenSurfaceVk(state, width, height);
  }
  
  SurfaceImpl *DisplayVk::createPbufferFromClientBuffer(const egl::SurfaceState &state,
                                                        EGLenum buftype,
                                                        EGLClientBuffer clientBuffer,
                                                        const egl::AttributeMap &attribs)
  {
      UNIMPLEMENTED();
      return static_cast<SurfaceImpl *>(0);
  }
  
  SurfaceImpl *DisplayVk::createPixmapSurface(const egl::SurfaceState &state,
                                              NativePixmapType nativePixmap,
                                              const egl::AttributeMap &attribs)
  {
      UNIMPLEMENTED();
      return static_cast<SurfaceImpl *>(0);
  }
  
  ImageImpl *DisplayVk::createImage(const egl::ImageState &state,
                                    EGLenum target,
                                    const egl::AttributeMap &attribs)
  {
      UNIMPLEMENTED();
      return static_cast<ImageImpl *>(0);
  }
  
  ContextImpl *DisplayVk::createContext(const gl::ContextState &state,
                                        const egl::Config *configuration,
                                        const gl::Context *shareContext,
                                        const egl::AttributeMap &attribs)
  {
      return new ContextVk(state, mRenderer.get());
  }
  
  StreamProducerImpl *DisplayVk::createStreamProducerD3DTexture(
      egl::Stream::ConsumerType consumerType,
      const egl::AttributeMap &attribs)
  {
      UNIMPLEMENTED();
      return static_cast<StreamProducerImpl *>(0);
  }
  
  gl::Version DisplayVk::getMaxSupportedESVersion() const
  {
      UNIMPLEMENTED();
      return gl::Version(0, 0);
  }
  
  void DisplayVk::generateExtensions(egl::DisplayExtensions *outExtensions) const
  {
      outExtensions->surfaceOrientation = true;
  }
  
  void DisplayVk::generateCaps(egl::Caps *outCaps) const
  {
      outCaps->textureNPOT = true;
  }
  
  }  // namespace rx
  

Download