chromium/third_party/angle/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 "common/system_utils.h"
#include "libANGLE/BlobCache.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/renderer/vulkan/BufferVk.h"
#include "libANGLE/renderer/vulkan/ContextVk.h"
#include "libANGLE/renderer/vulkan/DeviceVk.h"
#include "libANGLE/renderer/vulkan/ImageVk.h"
#include "libANGLE/renderer/vulkan/ShareGroupVk.h"
#include "libANGLE/renderer/vulkan/SurfaceVk.h"
#include "libANGLE/renderer/vulkan/SyncVk.h"
#include "libANGLE/renderer/vulkan/TextureVk.h"
#include "libANGLE/renderer/vulkan/VkImageImageSiblingVk.h"
#include "libANGLE/renderer/vulkan/vk_renderer.h"

namespace rx
{

namespace
{
// Query surface format and colorspace support.
void GetSupportedFormatColorspaces(VkPhysicalDevice physicalDevice,
                                   const angle::FeaturesVk &featuresVk,
                                   VkSurfaceKHR surface,
                                   std::vector<VkSurfaceFormat2KHR> *surfaceFormatsOut)
{ … }

vk::UseDebugLayers ShouldLoadDebugLayers(const egl::AttributeMap &attribs)
{ … }

angle::vk::ICD ChooseICDFromAttribs(const egl::AttributeMap &attribs)
{ … }

void InstallDebugAnnotator(egl::Display *display, vk::Renderer *renderer)
{ … }
}  // namespace

DisplayVk::DisplayVk(const egl::DisplayState &state)
    : … { … }

DisplayVk::~DisplayVk()
{ … }

egl::Error DisplayVk::initialize(egl::Display *display)
{ … }

void DisplayVk::terminate()
{ … }

egl::Error DisplayVk::makeCurrent(egl::Display *display,
                                  egl::Surface * /*drawSurface*/,
                                  egl::Surface * /*readSurface*/,
                                  gl::Context * /*context*/)
{ … }

bool DisplayVk::testDeviceLost()
{ … }

egl::Error DisplayVk::restoreLostDevice(const egl::Display *display)
{ … }

std::string DisplayVk::getRendererDescription()
{ … }

std::string DisplayVk::getVendorString()
{ … }

std::string DisplayVk::getVersionString(bool includeFullVersion)
{ … }

DeviceImpl *DisplayVk::createDevice()
{ … }

egl::Error DisplayVk::waitClient(const gl::Context *context)
{ … }

egl::Error DisplayVk::waitNative(const gl::Context *context, EGLint engine)
{ … }

angle::Result DisplayVk::waitNativeImpl()
{ … }

SurfaceImpl *DisplayVk::createWindowSurface(const egl::SurfaceState &state,
                                            EGLNativeWindowType window,
                                            const egl::AttributeMap &attribs)
{ … }

SurfaceImpl *DisplayVk::createPbufferSurface(const egl::SurfaceState &state,
                                             const egl::AttributeMap &attribs)
{ … }

SurfaceImpl *DisplayVk::createPbufferFromClientBuffer(const egl::SurfaceState &state,
                                                      EGLenum buftype,
                                                      EGLClientBuffer clientBuffer,
                                                      const egl::AttributeMap &attribs)
{ … }

SurfaceImpl *DisplayVk::createPixmapSurface(const egl::SurfaceState &state,
                                            NativePixmapType nativePixmap,
                                            const egl::AttributeMap &attribs)
{ … }

ImageImpl *DisplayVk::createImage(const egl::ImageState &state,
                                  const gl::Context *context,
                                  EGLenum target,
                                  const egl::AttributeMap &attribs)
{ … }

ShareGroupImpl *DisplayVk::createShareGroup(const egl::ShareGroupState &state)
{ … }

bool DisplayVk::isConfigFormatSupported(VkFormat format) const
{ … }

bool DisplayVk::isSurfaceFormatColorspacePairSupported(VkSurfaceKHR surface,
                                                       VkFormat format,
                                                       VkColorSpaceKHR colorspace) const
{ … }

bool DisplayVk::isColorspaceSupported(VkColorSpaceKHR colorspace) const
{ … }

void DisplayVk::initSupportedSurfaceFormatColorspaces()
{ … }

ContextImpl *DisplayVk::createContext(const gl::State &state,
                                      gl::ErrorSet *errorSet,
                                      const egl::Config *configuration,
                                      const gl::Context *shareContext,
                                      const egl::AttributeMap &attribs)
{ … }

StreamProducerImpl *DisplayVk::createStreamProducerD3DTexture(
    egl::Stream::ConsumerType consumerType,
    const egl::AttributeMap &attribs)
{ … }

EGLSyncImpl *DisplayVk::createSync()
{ … }

gl::Version DisplayVk::getMaxSupportedESVersion() const
{ … }

gl::Version DisplayVk::getMaxConformantESVersion() const
{ … }

Optional<gl::Version> DisplayVk::getMaxSupportedDesktopVersion() const
{ … }

egl::Error DisplayVk::validateImageClientBuffer(const gl::Context *context,
                                                EGLenum target,
                                                EGLClientBuffer clientBuffer,
                                                const egl::AttributeMap &attribs) const
{ … }

ExternalImageSiblingImpl *DisplayVk::createExternalImageSibling(const gl::Context *context,
                                                                EGLenum target,
                                                                EGLClientBuffer buffer,
                                                                const egl::AttributeMap &attribs)
{ … }

void DisplayVk::generateExtensions(egl::DisplayExtensions *outExtensions) const
{ … }

void DisplayVk::generateCaps(egl::Caps *outCaps) const
{ … }

const char *DisplayVk::getWSILayer() const
{ … }

void DisplayVk::handleError(VkResult result,
                            const char *file,
                            const char *function,
                            unsigned int line)
{ … }

void DisplayVk::initializeFrontendFeatures(angle::FrontendFeatures *features) const
{ … }

void DisplayVk::populateFeatureList(angle::FeatureList *features)
{ … }

// vk::GlobalOps
void DisplayVk::putBlob(const angle::BlobCacheKey &key, const angle::MemoryBuffer &value)
{ … }

bool DisplayVk::getBlob(const angle::BlobCacheKey &key, angle::BlobCacheValue *valueOut)
{ … }

std::shared_ptr<angle::WaitableEvent> DisplayVk::postMultiThreadWorkerTask(
    const std::shared_ptr<angle::Closure> &task)
{ … }

void DisplayVk::notifyDeviceLost()
{ … }
}  // namespace rx