aboutsummaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gn/gpu.gni1
-rw-r--r--include/gpu/GrContext.h4
-rw-r--r--include/gpu/vk/GrVkBackendContext.h55
-rw-r--r--src/gpu/GrDirectContext.cpp38
-rw-r--r--src/gpu/vk/GrVkBackendContext.cpp338
-rw-r--r--src/gpu/vk/GrVkGpu.cpp50
-rw-r--r--src/gpu/vk/GrVkGpu.h39
-rw-r--r--tools/gpu/vk/VkTestContext.cpp30
-rw-r--r--tools/gpu/vk/VkTestContext.h10
-rw-r--r--tools/gpu/vk/VkTestUtils.cpp320
-rw-r--r--tools/gpu/vk/VkTestUtils.h12
-rw-r--r--tools/sk_app/VulkanWindowContext.cpp196
-rw-r--r--tools/sk_app/VulkanWindowContext.h19
13 files changed, 538 insertions, 574 deletions
diff --git a/gn/gpu.gni b/gn/gpu.gni
index 76b9a16df8..91184fbeaf 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -543,7 +543,6 @@ skia_vk_sources = [
"$_include/private/GrVkTypesPriv.h",
"$_src/gpu/vk/GrVkAMDMemoryAllocator.cpp",
"$_src/gpu/vk/GrVkAMDMemoryAllocator.h",
- "$_src/gpu/vk/GrVkBackendContext.cpp",
"$_src/gpu/vk/GrVkBuffer.cpp",
"$_src/gpu/vk/GrVkBuffer.h",
"$_src/gpu/vk/GrVkBufferView.cpp",
diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h
index 565a3d504f..c1804e00ff 100644
--- a/include/gpu/GrContext.h
+++ b/include/gpu/GrContext.h
@@ -71,10 +71,6 @@ public:
#ifdef SK_VULKAN
static sk_sp<GrContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&);
static sk_sp<GrContext> MakeVulkan(const GrVkBackendContext&);
- // These calls that take an sk_sp GrVkBackendContext are deprecated. Use the previous calls and
- // set fOwnsInstanceAndDevice to false on the GrVkBackendContext.
- static sk_sp<GrContext> MakeVulkan(sk_sp<const GrVkBackendContext>, const GrContextOptions&);
- static sk_sp<GrContext> MakeVulkan(sk_sp<const GrVkBackendContext>);
#endif
#ifdef SK_METAL
diff --git a/include/gpu/vk/GrVkBackendContext.h b/include/gpu/vk/GrVkBackendContext.h
index e68e27988a..fe018e494f 100644
--- a/include/gpu/vk/GrVkBackendContext.h
+++ b/include/gpu/vk/GrVkBackendContext.h
@@ -34,9 +34,11 @@ enum GrVkFeatureFlags {
// is that the client will set these up and pass them to the GrVkGpu constructor. The VkDevice
// created must support at least one graphics queue, which is passed in as well.
// The QueueFamilyIndex must match the family of the given queue. It is needed for CommandPool
-// creation, and any GrBackendObjects handed to us (e.g., for wrapped textures) need to be created
-// in or transitioned to that family.
-struct SK_API GrVkBackendContext : public SkRefCnt {
+// creation, and any GrBackendObjects handed to us (e.g., for wrapped textures) needs to be created
+// in or transitioned to that family. The refs held by members of this struct must be released
+// (either by deleting the struct or manually releasing the refs) before the underlying vulkan
+// device and instance are destroyed.
+struct SK_API GrVkBackendContext {
VkInstance fInstance;
VkPhysicalDevice fPhysicalDevice;
VkDevice fDevice;
@@ -48,50 +50,9 @@ struct SK_API GrVkBackendContext : public SkRefCnt {
sk_sp<const GrVkInterface> fInterface;
sk_sp<GrVkMemoryAllocator> fMemoryAllocator;
- /**
- * Controls whether this object destroys the instance and device upon destruction. The default
- * is temporarily 'true' to avoid breaking existing clients but will be changed to 'false'.
- */
- bool fOwnsInstanceAndDevice = true;
-
-#if GR_TEST_UTILS || defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
- using CanPresentFn = std::function<bool(VkInstance, VkPhysicalDevice,
- uint32_t queueFamilyIndex)>;
-
- /**
- * Helper function to create the Vulkan objects needed for a Vulkan-backed GrContext.
- * Note that the version that uses the unified "GetProc" instead of separate "GetInstanceProc"
- * and "GetDeviceProc" functions will be removed.
- *
- * If presentQueueIndex is non-NULL, will try to set up presentQueue as part of device
- * creation using the platform-specific canPresent() function.
- *
- * This will set fOwnsInstanceAndDevice to 'true'. If it is subsequently set to 'false' then
- * the client owns the lifetime of the created VkDevice and VkInstance.
- */
- static const GrVkBackendContext* Create(uint32_t* presentQueueIndex = nullptr,
- CanPresentFn = CanPresentFn(),
- GrVkInterface::GetProc getProc = nullptr);
-
- static const GrVkBackendContext* Create(const GrVkInterface::GetInstanceProc& getInstanceProc,
- const GrVkInterface::GetDeviceProc& getDeviceProc,
- uint32_t* presentQueueIndex = nullptr,
- CanPresentFn canPresent = CanPresentFn()) {
- if (!getInstanceProc || !getDeviceProc) {
- return nullptr;
- }
- auto getProc = [&getInstanceProc, &getDeviceProc](const char* proc_name,
- VkInstance instance, VkDevice device) {
- if (device != VK_NULL_HANDLE) {
- return getDeviceProc(device, proc_name);
- }
- return getInstanceProc(instance, proc_name);
- };
- return Create(presentQueueIndex, canPresent, getProc);
- }
-#endif // GR_TEST_UTILS || defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
-
- ~GrVkBackendContext() override;
+ // This is deprecated and should be set to false. The client is responsible for managing the
+ // lifetime of the VkInstance and VkDevice objects.
+ bool fOwnsInstanceAndDevice = false;
};
#endif
diff --git a/src/gpu/GrDirectContext.cpp b/src/gpu/GrDirectContext.cpp
index 83e2194003..3e4b8ef5fa 100644
--- a/src/gpu/GrDirectContext.cpp
+++ b/src/gpu/GrDirectContext.cpp
@@ -156,43 +156,7 @@ sk_sp<GrContext> GrContext::MakeVulkan(const GrVkBackendContext& backendContext,
const GrContextOptions& options) {
sk_sp<GrContext> context(new GrDirectContext(kVulkan_GrBackend));
- sk_sp<GrVkBackendContext> backendContextRef(new GrVkBackendContext());
- backendContextRef->fInstance = backendContext.fInstance;
- backendContextRef->fPhysicalDevice = backendContext.fPhysicalDevice;
- backendContextRef->fDevice = backendContext.fDevice;
- backendContextRef->fQueue = backendContext.fQueue;
- backendContextRef->fGraphicsQueueIndex = backendContext.fGraphicsQueueIndex;
- backendContextRef->fMinAPIVersion = backendContext.fMinAPIVersion;
- backendContextRef->fExtensions = backendContext.fExtensions;
- backendContextRef->fFeatures = backendContext.fFeatures;
- backendContextRef->fInterface = backendContext.fInterface;
- backendContextRef->fMemoryAllocator = backendContext.fMemoryAllocator;
-
- SkASSERT(!backendContext.fOwnsInstanceAndDevice);
- backendContextRef->fOwnsInstanceAndDevice = false;
-
- context->fGpu = GrVkGpu::Make(std::move(backendContextRef), options, context.get());
- if (!context->fGpu) {
- return nullptr;
- }
-
- context->fCaps = context->fGpu->refCaps();
- if (!context->init(options)) {
- return nullptr;
- }
- return context;
-}
-
-sk_sp<GrContext> GrContext::MakeVulkan(sk_sp<const GrVkBackendContext> backendContext) {
- GrContextOptions defaultOptions;
- return MakeVulkan(std::move(backendContext), defaultOptions);
-}
-
-sk_sp<GrContext> GrContext::MakeVulkan(sk_sp<const GrVkBackendContext> backendContext,
- const GrContextOptions& options) {
- sk_sp<GrContext> context(new GrDirectContext(kVulkan_GrBackend));
-
- context->fGpu = GrVkGpu::Make(std::move(backendContext), options, context.get());
+ context->fGpu = GrVkGpu::Make(backendContext, options, context.get());
if (!context->fGpu) {
return nullptr;
}
diff --git a/src/gpu/vk/GrVkBackendContext.cpp b/src/gpu/vk/GrVkBackendContext.cpp
deleted file mode 100644
index 3c4e8d7a60..0000000000
--- a/src/gpu/vk/GrVkBackendContext.cpp
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkAutoMalloc.h"
-#include "vk/GrVkBackendContext.h"
-#include "vk/GrVkExtensions.h"
-#include "vk/GrVkUtil.h"
-
-#if GR_TEST_UTILS || defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
-
-////////////////////////////////////////////////////////////////////////////////
-// Helper code to set up Vulkan context objects
-
-#ifdef SK_ENABLE_VK_LAYERS
-const char* kDebugLayerNames[] = {
- // elements of VK_LAYER_LUNARG_standard_validation
- "VK_LAYER_GOOGLE_threading",
- "VK_LAYER_LUNARG_parameter_validation",
- "VK_LAYER_LUNARG_object_tracker",
- "VK_LAYER_LUNARG_image",
- "VK_LAYER_LUNARG_core_validation",
- "VK_LAYER_LUNARG_swapchain",
- "VK_LAYER_GOOGLE_unique_objects",
- // not included in standard_validation
- //"VK_LAYER_LUNARG_api_dump",
- //"VK_LAYER_LUNARG_vktrace",
- //"VK_LAYER_LUNARG_screenshot",
-};
-#endif
-
-// the minimum version of Vulkan supported
-#ifdef SK_BUILD_FOR_ANDROID
-const uint32_t kGrVkMinimumVersion = VK_MAKE_VERSION(1, 0, 3);
-#else
-const uint32_t kGrVkMinimumVersion = VK_MAKE_VERSION(1, 0, 8);
-#endif
-
-#define ACQUIRE_VK_PROC(name, instance, device) \
- PFN_vk##name grVk##name = \
- reinterpret_cast<PFN_vk##name>(getProc("vk" #name, instance, device)); \
- if (grVk##name == nullptr) { \
- SkDebugf("Function ptr for vk%s could not be acquired\n", #name); \
- return nullptr; \
- }
-
-// Create the base Vulkan objects needed by the GrVkGpu object
-const GrVkBackendContext* GrVkBackendContext::Create(uint32_t* presentQueueIndexPtr,
- CanPresentFn canPresent,
- GrVkInterface::GetProc getProc) {
- if (!getProc) {
- return nullptr;
- }
- SkASSERT(getProc);
-
- VkPhysicalDevice physDev;
- VkDevice device;
- VkInstance inst;
- VkResult err;
-
- const VkApplicationInfo app_info = {
- VK_STRUCTURE_TYPE_APPLICATION_INFO, // sType
- nullptr, // pNext
- "vktest", // pApplicationName
- 0, // applicationVersion
- "vktest", // pEngineName
- 0, // engineVerison
- kGrVkMinimumVersion, // apiVersion
- };
-
- GrVkExtensions extensions(getProc);
- extensions.initInstance(kGrVkMinimumVersion);
-
- SkTArray<const char*> instanceLayerNames;
- SkTArray<const char*> instanceExtensionNames;
- uint32_t extensionFlags = 0;
-#ifdef SK_ENABLE_VK_LAYERS
- for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
- if (extensions.hasInstanceLayer(kDebugLayerNames[i])) {
- instanceLayerNames.push_back(kDebugLayerNames[i]);
- }
- }
- if (extensions.hasInstanceExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
- instanceExtensionNames.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
- extensionFlags |= kEXT_debug_report_GrVkExtensionFlag;
- }
-#endif
-
- if (extensions.hasInstanceExtension(VK_KHR_SURFACE_EXTENSION_NAME)) {
- instanceExtensionNames.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
- extensionFlags |= kKHR_surface_GrVkExtensionFlag;
- }
- if (extensions.hasInstanceExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
- instanceExtensionNames.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
- extensionFlags |= kKHR_swapchain_GrVkExtensionFlag;
- }
-#ifdef SK_BUILD_FOR_WIN
- if (extensions.hasInstanceExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
- instanceExtensionNames.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
- extensionFlags |= kKHR_win32_surface_GrVkExtensionFlag;
- }
-#elif defined(SK_BUILD_FOR_ANDROID)
- if (extensions.hasInstanceExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {
- instanceExtensionNames.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
- extensionFlags |= kKHR_android_surface_GrVkExtensionFlag;
- }
-#elif defined(SK_BUILD_FOR_UNIX) && !defined(__Fuchsia__)
- if (extensions.hasInstanceExtension(VK_KHR_XCB_SURFACE_EXTENSION_NAME)) {
- instanceExtensionNames.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
- extensionFlags |= kKHR_xcb_surface_GrVkExtensionFlag;
- }
-#endif
-
- const VkInstanceCreateInfo instance_create = {
- VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType
- nullptr, // pNext
- 0, // flags
- &app_info, // pApplicationInfo
- (uint32_t) instanceLayerNames.count(), // enabledLayerNameCount
- instanceLayerNames.begin(), // ppEnabledLayerNames
- (uint32_t) instanceExtensionNames.count(), // enabledExtensionNameCount
- instanceExtensionNames.begin(), // ppEnabledExtensionNames
- };
-
- ACQUIRE_VK_PROC(CreateInstance, VK_NULL_HANDLE, VK_NULL_HANDLE);
- err = grVkCreateInstance(&instance_create, nullptr, &inst);
- if (err < 0) {
- SkDebugf("vkCreateInstance failed: %d\n", err);
- return nullptr;
- }
-
- ACQUIRE_VK_PROC(DestroyInstance, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(EnumeratePhysicalDevices, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(GetPhysicalDeviceQueueFamilyProperties, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(GetPhysicalDeviceFeatures, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(CreateDevice, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(GetDeviceQueue, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(DeviceWaitIdle, inst, VK_NULL_HANDLE);
- ACQUIRE_VK_PROC(DestroyDevice, inst, VK_NULL_HANDLE);
-
- uint32_t gpuCount;
- err = grVkEnumeratePhysicalDevices(inst, &gpuCount, nullptr);
- if (err) {
- SkDebugf("vkEnumeratePhysicalDevices failed: %d\n", err);
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
- if (!gpuCount) {
- SkDebugf("vkEnumeratePhysicalDevices returned no supported devices.\n");
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
- // Just returning the first physical device instead of getting the whole array.
- // TODO: find best match for our needs
- gpuCount = 1;
- err = grVkEnumeratePhysicalDevices(inst, &gpuCount, &physDev);
- // VK_INCOMPLETE is returned when the count we provide is less than the total device count.
- if (err && VK_INCOMPLETE != err) {
- SkDebugf("vkEnumeratePhysicalDevices failed: %d\n", err);
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
-
- // query to get the initial queue props size
- uint32_t queueCount;
- grVkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, nullptr);
- if (!queueCount) {
- SkDebugf("vkGetPhysicalDeviceQueueFamilyProperties returned no queues.\n");
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
-
- SkAutoMalloc queuePropsAlloc(queueCount * sizeof(VkQueueFamilyProperties));
- // now get the actual queue props
- VkQueueFamilyProperties* queueProps = (VkQueueFamilyProperties*)queuePropsAlloc.get();
-
- grVkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, queueProps);
-
- // iterate to find the graphics queue
- uint32_t graphicsQueueIndex = queueCount;
- for (uint32_t i = 0; i < queueCount; i++) {
- if (queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
- graphicsQueueIndex = i;
- break;
- }
- }
- if (graphicsQueueIndex == queueCount) {
- SkDebugf("Could not find any supported graphics queues.\n");
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
-
- // iterate to find the present queue, if needed
- uint32_t presentQueueIndex = queueCount;
- if (presentQueueIndexPtr && canPresent) {
- for (uint32_t i = 0; i < queueCount; i++) {
- if (canPresent(inst, physDev, i)) {
- presentQueueIndex = i;
- break;
- }
- }
- if (presentQueueIndex == queueCount) {
- SkDebugf("Could not find any supported present queues.\n");
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
- *presentQueueIndexPtr = presentQueueIndex;
- } else {
- // Just setting this so we end up make a single queue for graphics since there was no
- // request for a present queue.
- presentQueueIndex = graphicsQueueIndex;
- }
-
- extensions.initDevice(kGrVkMinimumVersion, inst, physDev);
-
- SkTArray<const char*> deviceLayerNames;
- SkTArray<const char*> deviceExtensionNames;
-#ifdef SK_ENABLE_VK_LAYERS
- for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
- if (extensions.hasDeviceLayer(kDebugLayerNames[i])) {
- deviceLayerNames.push_back(kDebugLayerNames[i]);
- }
- }
-#endif
- if (extensions.hasDeviceExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
- deviceExtensionNames.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
- extensionFlags |= kKHR_swapchain_GrVkExtensionFlag;
- }
- if (extensions.hasDeviceExtension("VK_NV_glsl_shader")) {
- deviceExtensionNames.push_back("VK_NV_glsl_shader");
- extensionFlags |= kNV_glsl_shader_GrVkExtensionFlag;
- }
-
- // query to get the physical device properties
- VkPhysicalDeviceFeatures deviceFeatures;
- grVkGetPhysicalDeviceFeatures(physDev, &deviceFeatures);
- // this looks like it would slow things down,
- // and we can't depend on it on all platforms
- deviceFeatures.robustBufferAccess = VK_FALSE;
-
- uint32_t featureFlags = 0;
- if (deviceFeatures.geometryShader) {
- featureFlags |= kGeometryShader_GrVkFeatureFlag;
- }
- if (deviceFeatures.dualSrcBlend) {
- featureFlags |= kDualSrcBlend_GrVkFeatureFlag;
- }
- if (deviceFeatures.sampleRateShading) {
- featureFlags |= kSampleRateShading_GrVkFeatureFlag;
- }
-
- float queuePriorities[1] = { 0.0 };
- // Here we assume no need for swapchain queue
- // If one is needed, the client will need its own setup code
- const VkDeviceQueueCreateInfo queueInfo[2] = {
- {
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
- nullptr, // pNext
- 0, // VkDeviceQueueCreateFlags
- graphicsQueueIndex, // queueFamilyIndex
- 1, // queueCount
- queuePriorities, // pQueuePriorities
- },
- {
- VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
- nullptr, // pNext
- 0, // VkDeviceQueueCreateFlags
- presentQueueIndex, // queueFamilyIndex
- 1, // queueCount
- queuePriorities, // pQueuePriorities
- }
- };
- uint32_t queueInfoCount = (presentQueueIndex != graphicsQueueIndex) ? 2 : 1;
-
- const VkDeviceCreateInfo deviceInfo = {
- VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
- nullptr, // pNext
- 0, // VkDeviceCreateFlags
- queueInfoCount, // queueCreateInfoCount
- queueInfo, // pQueueCreateInfos
- (uint32_t) deviceLayerNames.count(), // layerCount
- deviceLayerNames.begin(), // ppEnabledLayerNames
- (uint32_t) deviceExtensionNames.count(), // extensionCount
- deviceExtensionNames.begin(), // ppEnabledExtensionNames
- &deviceFeatures // ppEnabledFeatures
- };
-
- err = grVkCreateDevice(physDev, &deviceInfo, nullptr, &device);
- if (err) {
- SkDebugf("CreateDevice failed: %d\n", err);
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
-
- auto interface =
- sk_make_sp<GrVkInterface>(getProc, inst, device, extensionFlags);
- if (!interface->validate(extensionFlags)) {
- SkDebugf("Vulkan interface validation failed\n");
- grVkDeviceWaitIdle(device);
- grVkDestroyDevice(device, nullptr);
- grVkDestroyInstance(inst, nullptr);
- return nullptr;
- }
-
- VkQueue queue;
- grVkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
-
- GrVkBackendContext* ctx = new GrVkBackendContext();
- ctx->fInstance = inst;
- ctx->fPhysicalDevice = physDev;
- ctx->fDevice = device;
- ctx->fQueue = queue;
- ctx->fGraphicsQueueIndex = graphicsQueueIndex;
- ctx->fMinAPIVersion = kGrVkMinimumVersion;
- ctx->fExtensions = extensionFlags;
- ctx->fFeatures = featureFlags;
- ctx->fInterface.reset(interface.release());
- ctx->fOwnsInstanceAndDevice = true;
-
- return ctx;
-}
-#endif // GR_TEST_UTILS || defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
-
-GrVkBackendContext::~GrVkBackendContext() {
- fMemoryAllocator.reset();
- if (fInterface == nullptr || !fOwnsInstanceAndDevice) {
- return;
- }
-
- fInterface->fFunctions.fDeviceWaitIdle(fDevice);
- fInterface->fFunctions.fDestroyDevice(fDevice, nullptr);
- fDevice = VK_NULL_HANDLE;
- fInterface->fFunctions.fDestroyInstance(fInstance, nullptr);
- fInstance = VK_NULL_HANDLE;
-}
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index a98b3b3108..771be2e208 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -73,33 +73,38 @@ VKAPI_ATTR VkBool32 VKAPI_CALL DebugReportCallback(
}
#endif
-sk_sp<GrGpu> GrVkGpu::Make(sk_sp<const GrVkBackendContext> backendContext,
+sk_sp<GrGpu> GrVkGpu::Make(const GrVkBackendContext& backendContext,
const GrContextOptions& options, GrContext* context) {
- if (!backendContext) {
+ if (backendContext.fInstance == VK_NULL_HANDLE ||
+ backendContext.fPhysicalDevice == VK_NULL_HANDLE ||
+ backendContext.fDevice == VK_NULL_HANDLE ||
+ backendContext.fQueue == VK_NULL_HANDLE) {
return nullptr;
}
-
- if (!backendContext->fInterface->validate(backendContext->fExtensions)) {
+ if (!backendContext.fInterface ||
+ !backendContext.fInterface->validate(backendContext.fExtensions)) {
return nullptr;
}
- return sk_sp<GrGpu>(new GrVkGpu(context, options, std::move(backendContext)));
+ return sk_sp<GrGpu>(new GrVkGpu(context, options, backendContext));
}
////////////////////////////////////////////////////////////////////////////////
GrVkGpu::GrVkGpu(GrContext* context, const GrContextOptions& options,
- sk_sp<const GrVkBackendContext> backendCtx)
+ const GrVkBackendContext& backendContext)
: INHERITED(context)
- , fBackendContext(std::move(backendCtx))
- , fMemoryAllocator(fBackendContext->fMemoryAllocator)
- , fDevice(fBackendContext->fDevice)
- , fQueue(fBackendContext->fQueue)
+ , fInterface(std::move(backendContext.fInterface))
+ , fMemoryAllocator(backendContext.fMemoryAllocator)
+ , fInstance(backendContext.fInstance)
+ , fDevice(backendContext.fDevice)
+ , fQueue(backendContext.fQueue)
, fResourceProvider(this)
, fDisconnected(false) {
+ SkASSERT(!backendContext.fOwnsInstanceAndDevice);
#ifdef SK_ENABLE_VK_LAYERS
fCallback = VK_NULL_HANDLE;
- if (fBackendContext->fExtensions & kEXT_debug_report_GrVkExtensionFlag) {
+ if (backendContext.fExtensions & kEXT_debug_report_GrVkExtensionFlag) {
// Setup callback creation information
VkDebugReportCallbackCreateInfoEXT callbackCreateInfo;
callbackCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
@@ -114,32 +119,32 @@ GrVkGpu::GrVkGpu(GrContext* context, const GrContextOptions& options,
// Register the callback
GR_VK_CALL_ERRCHECK(this->vkInterface(),
- CreateDebugReportCallbackEXT(fBackendContext->fInstance,
+ CreateDebugReportCallbackEXT(backendContext.fInstance,
&callbackCreateInfo, nullptr, &fCallback));
}
#endif
if (!fMemoryAllocator) {
// We were not given a memory allocator at creation
- fMemoryAllocator.reset(new GrVkAMDMemoryAllocator(fBackendContext->fPhysicalDevice,
- fDevice, fBackendContext->fInterface));
+ fMemoryAllocator.reset(new GrVkAMDMemoryAllocator(backendContext.fPhysicalDevice,
+ fDevice, backendContext.fInterface));
}
fCompiler = new SkSL::Compiler();
- fVkCaps.reset(new GrVkCaps(options, this->vkInterface(), fBackendContext->fPhysicalDevice,
- fBackendContext->fFeatures, fBackendContext->fExtensions));
+ fVkCaps.reset(new GrVkCaps(options, this->vkInterface(), backendContext.fPhysicalDevice,
+ backendContext.fFeatures, backendContext.fExtensions));
fCaps.reset(SkRef(fVkCaps.get()));
- VK_CALL(GetPhysicalDeviceProperties(fBackendContext->fPhysicalDevice, &fPhysDevProps));
- VK_CALL(GetPhysicalDeviceMemoryProperties(fBackendContext->fPhysicalDevice, &fPhysDevMemProps));
+ VK_CALL(GetPhysicalDeviceProperties(backendContext.fPhysicalDevice, &fPhysDevProps));
+ VK_CALL(GetPhysicalDeviceMemoryProperties(backendContext.fPhysicalDevice, &fPhysDevMemProps));
const VkCommandPoolCreateInfo cmdPoolInfo = {
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
nullptr, // pNext
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT |
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // CmdPoolCreateFlags
- fBackendContext->fGraphicsQueueIndex, // queueFamilyIndex
+ backendContext.fGraphicsQueueIndex, // queueFamilyIndex
};
GR_VK_CALL_ERRCHECK(this->vkInterface(), CreateCommandPool(fDevice, &cmdPoolInfo, nullptr,
&fCmdPool));
@@ -201,10 +206,15 @@ void GrVkGpu::destroyResources() {
#ifdef SK_ENABLE_VK_LAYERS
if (fCallback) {
- VK_CALL(DestroyDebugReportCallbackEXT(fBackendContext->fInstance, fCallback, nullptr));
+ VK_CALL(DestroyDebugReportCallbackEXT(fInstance, fCallback, nullptr));
}
#endif
+ fMemoryAllocator.reset();
+
+ fQueue = VK_NULL_HANDLE;
+ fDevice = VK_NULL_HANDLE;
+ fInstance = VK_NULL_HANDLE;
}
GrVkGpu::~GrVkGpu() {
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 052476098d..f506d28b0e 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -38,13 +38,13 @@ namespace SkSL {
class GrVkGpu : public GrGpu {
public:
- static sk_sp<GrGpu> Make(sk_sp<const GrVkBackendContext>, const GrContextOptions&, GrContext*);
+ static sk_sp<GrGpu> Make(const GrVkBackendContext&, const GrContextOptions&, GrContext*);
~GrVkGpu() override;
void disconnect(DisconnectType) override;
- const GrVkInterface* vkInterface() const { return fBackendContext->fInterface.get(); }
+ const GrVkInterface* vkInterface() const { return fInterface.get(); }
const GrVkCaps& vkCaps() const { return *fVkCaps; }
GrVkMemoryAllocator* memoryAllocator() const { return fMemoryAllocator.get(); }
@@ -144,7 +144,7 @@ public:
bool updateBuffer(GrVkBuffer* buffer, const void* src, VkDeviceSize offset, VkDeviceSize size);
private:
- GrVkGpu(GrContext*, const GrContextOptions&, sk_sp<const GrVkBackendContext> backendContext);
+ GrVkGpu(GrContext*, const GrContextOptions&, const GrVkBackendContext& backendContext);
void onResetContext(uint32_t resetBits) override {}
@@ -222,28 +222,27 @@ private:
GrVkImageInfo* info);
#endif
- sk_sp<const GrVkBackendContext> fBackendContext;
- sk_sp<GrVkMemoryAllocator> fMemoryAllocator;
- sk_sp<GrVkCaps> fVkCaps;
+ sk_sp<const GrVkInterface> fInterface;
+ sk_sp<GrVkMemoryAllocator> fMemoryAllocator;
+ sk_sp<GrVkCaps> fVkCaps;
- // These Vulkan objects are provided by the client, and also stored in fBackendContext.
- // They're copied here for convenient access.
- VkDevice fDevice;
- VkQueue fQueue; // Must be Graphics queue
+ VkInstance fInstance;
+ VkDevice fDevice;
+ VkQueue fQueue; // Must be Graphics queue
// Created by GrVkGpu
- GrVkResourceProvider fResourceProvider;
- VkCommandPool fCmdPool;
+ GrVkResourceProvider fResourceProvider;
+ VkCommandPool fCmdPool;
- GrVkPrimaryCommandBuffer* fCurrentCmdBuffer;
+ GrVkPrimaryCommandBuffer* fCurrentCmdBuffer;
- SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToWaitOn;
- SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToSignal;
+ SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToWaitOn;
+ SkSTArray<1, GrVkSemaphore::Resource*> fSemaphoresToSignal;
- VkPhysicalDeviceProperties fPhysDevProps;
- VkPhysicalDeviceMemoryProperties fPhysDevMemProps;
+ VkPhysicalDeviceProperties fPhysDevProps;
+ VkPhysicalDeviceMemoryProperties fPhysDevMemProps;
- GrVkCopyManager fCopyManager;
+ GrVkCopyManager fCopyManager;
#ifdef SK_ENABLE_VK_LAYERS
// For reporting validation layer errors
@@ -252,11 +251,11 @@ private:
// compiler used for compiling sksl into spirv. We only want to create the compiler once since
// there is significant overhead to the first compile of any compiler.
- SkSL::Compiler* fCompiler;
+ SkSL::Compiler* fCompiler;
// We need a bool to track whether or not we've already disconnected all the gpu resources from
// vulkan context.
- bool fDisconnected;
+ bool fDisconnected;
typedef GrGpu INHERITED;
};
diff --git a/tools/gpu/vk/VkTestContext.cpp b/tools/gpu/vk/VkTestContext.cpp
index 25069fe521..592fb0f7b0 100644
--- a/tools/gpu/vk/VkTestContext.cpp
+++ b/tools/gpu/vk/VkTestContext.cpp
@@ -110,21 +110,24 @@ GR_STATIC_ASSERT(sizeof(VkFence) <= sizeof(sk_gpu_test::PlatformFence));
class VkTestContextImpl : public sk_gpu_test::VkTestContext {
public:
static VkTestContext* Create(VkTestContext* sharedContext) {
- sk_sp<const GrVkBackendContext> backendContext;
+ GrVkBackendContext backendContext;
+ bool ownsContext = true;
if (sharedContext) {
backendContext = sharedContext->getVkBackendContext();
+ // We always delete the parent context last so make sure the child does not think they
+ // own the vulkan context.
+ ownsContext = false;
} else {
PFN_vkGetInstanceProcAddr instProc;
PFN_vkGetDeviceProcAddr devProc;
if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc, &devProc)) {
return nullptr;
}
- backendContext.reset(GrVkBackendContext::Create(instProc, devProc));
- }
- if (!backendContext) {
- return nullptr;
+ if (!sk_gpu_test::CreateVkBackendContext(instProc, devProc, &backendContext)) {
+ return nullptr;
+ }
}
- return new VkTestContextImpl(std::move(backendContext));
+ return new VkTestContextImpl(backendContext, ownsContext);
}
~VkTestContextImpl() override { this->teardown(); }
@@ -143,14 +146,19 @@ public:
protected:
void teardown() override {
INHERITED::teardown();
- fVk.reset(nullptr);
+ fVk.fMemoryAllocator.reset();
+ if (fOwnsContext) {
+ GR_VK_CALL(this->vk(), DeviceWaitIdle(fVk.fDevice));
+ GR_VK_CALL(this->vk(), DestroyDevice(fVk.fDevice, nullptr));
+ GR_VK_CALL(this->vk(), DestroyInstance(fVk.fInstance, nullptr));
+ }
}
private:
- VkTestContextImpl(sk_sp<const GrVkBackendContext> backendContext)
- : VkTestContext(std::move(backendContext)) {
- fFenceSync.reset(new VkFenceSync(fVk->fInterface, fVk->fDevice, fVk->fQueue,
- fVk->fGraphicsQueueIndex));
+ VkTestContextImpl(const GrVkBackendContext& backendContext, bool ownsContext)
+ : VkTestContext(backendContext, ownsContext) {
+ fFenceSync.reset(new VkFenceSync(fVk.fInterface, fVk.fDevice, fVk.fQueue,
+ fVk.fGraphicsQueueIndex));
}
void onPlatformMakeCurrent() const override {}
diff --git a/tools/gpu/vk/VkTestContext.h b/tools/gpu/vk/VkTestContext.h
index 9fd4170d9d..0e62cc0b8c 100644
--- a/tools/gpu/vk/VkTestContext.h
+++ b/tools/gpu/vk/VkTestContext.h
@@ -19,16 +19,18 @@ class VkTestContext : public TestContext {
public:
virtual GrBackend backend() override { return kVulkan_GrBackend; }
- sk_sp<const GrVkBackendContext> getVkBackendContext() {
+ const GrVkBackendContext& getVkBackendContext() {
return fVk;
}
- const GrVkInterface* vk() const { return fVk->fInterface.get(); }
+ const GrVkInterface* vk() const { return fVk.fInterface.get(); }
protected:
- VkTestContext(sk_sp<const GrVkBackendContext> vk) : fVk(std::move(vk)) {}
+ VkTestContext(const GrVkBackendContext& vk, bool ownsContext)
+ : fVk(vk), fOwnsContext(ownsContext) {}
- sk_sp<const GrVkBackendContext> fVk;
+ GrVkBackendContext fVk;
+ bool fOwnsContext;
private:
typedef TestContext INHERITED;
diff --git a/tools/gpu/vk/VkTestUtils.cpp b/tools/gpu/vk/VkTestUtils.cpp
index c28a42b2c9..927f4fbe82 100644
--- a/tools/gpu/vk/VkTestUtils.cpp
+++ b/tools/gpu/vk/VkTestUtils.cpp
@@ -9,6 +9,9 @@
#ifdef SK_VULKAN
+#include "SkAutoMalloc.h"
+#include "vk/GrVkBackendContext.h"
+#include "vk/GrVkExtensions.h"
#include "../ports/SkOSLibrary.h"
namespace sk_gpu_test {
@@ -46,6 +49,323 @@ bool LoadVkLibraryAndGetProcAddrFuncs(PFN_vkGetInstanceProcAddr* instProc,
return true;
#endif
}
+
+////////////////////////////////////////////////////////////////////////////////
+// Helper code to set up Vulkan context objects
+
+#ifdef SK_ENABLE_VK_LAYERS
+const char* kDebugLayerNames[] = {
+ // elements of VK_LAYER_LUNARG_standard_validation
+ "VK_LAYER_GOOGLE_threading",
+ "VK_LAYER_LUNARG_parameter_validation",
+ "VK_LAYER_LUNARG_object_tracker",
+ "VK_LAYER_LUNARG_image",
+ "VK_LAYER_LUNARG_core_validation",
+ "VK_LAYER_LUNARG_swapchain",
+ "VK_LAYER_GOOGLE_unique_objects",
+ // not included in standard_validation
+ //"VK_LAYER_LUNARG_api_dump",
+ //"VK_LAYER_LUNARG_vktrace",
+ //"VK_LAYER_LUNARG_screenshot",
+};
+#endif
+
+// the minimum version of Vulkan supported
+#ifdef SK_BUILD_FOR_ANDROID
+const uint32_t kGrVkMinimumVersion = VK_MAKE_VERSION(1, 0, 3);
+#else
+const uint32_t kGrVkMinimumVersion = VK_MAKE_VERSION(1, 0, 8);
+#endif
+
+#define ACQUIRE_VK_PROC(name, instance, device) \
+ PFN_vk##name grVk##name = \
+ reinterpret_cast<PFN_vk##name>(getProc("vk" #name, instance, device)); \
+ if (grVk##name == nullptr) { \
+ SkDebugf("Function ptr for vk%s could not be acquired\n", #name); \
+ return false; \
+ }
+
+bool CreateVkBackendContext(const GrVkInterface::GetInstanceProc& getInstanceProc,
+ const GrVkInterface::GetDeviceProc& getDeviceProc,
+ GrVkBackendContext* ctx,
+ uint32_t* presentQueueIndexPtr,
+ CanPresentFn canPresent) {
+ auto getProc = [&getInstanceProc, &getDeviceProc](const char* proc_name,
+ VkInstance instance, VkDevice device) {
+ if (device != VK_NULL_HANDLE) {
+ return getDeviceProc(device, proc_name);
+ }
+ return getInstanceProc(instance, proc_name);
+ };
+
+ VkPhysicalDevice physDev;
+ VkDevice device;
+ VkInstance inst;
+ VkResult err;
+
+ const VkApplicationInfo app_info = {
+ VK_STRUCTURE_TYPE_APPLICATION_INFO, // sType
+ nullptr, // pNext
+ "vktest", // pApplicationName
+ 0, // applicationVersion
+ "vktest", // pEngineName
+ 0, // engineVerison
+ kGrVkMinimumVersion, // apiVersion
+ };
+
+ GrVkExtensions extensions(getProc);
+ extensions.initInstance(kGrVkMinimumVersion);
+
+ SkTArray<const char*> instanceLayerNames;
+ SkTArray<const char*> instanceExtensionNames;
+ uint32_t extensionFlags = 0;
+#ifdef SK_ENABLE_VK_LAYERS
+ for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
+ if (extensions.hasInstanceLayer(kDebugLayerNames[i])) {
+ instanceLayerNames.push_back(kDebugLayerNames[i]);
+ }
+ }
+ if (extensions.hasInstanceExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
+ instanceExtensionNames.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+ extensionFlags |= kEXT_debug_report_GrVkExtensionFlag;
+ }
+#endif
+
+ if (extensions.hasInstanceExtension(VK_KHR_SURFACE_EXTENSION_NAME)) {
+ instanceExtensionNames.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
+ extensionFlags |= kKHR_surface_GrVkExtensionFlag;
+ }
+ if (extensions.hasInstanceExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
+ instanceExtensionNames.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+ extensionFlags |= kKHR_swapchain_GrVkExtensionFlag;
+ }
+#ifdef SK_BUILD_FOR_WIN
+ if (extensions.hasInstanceExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
+ instanceExtensionNames.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
+ extensionFlags |= kKHR_win32_surface_GrVkExtensionFlag;
+ }
+#elif defined(SK_BUILD_FOR_ANDROID)
+ if (extensions.hasInstanceExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {
+ instanceExtensionNames.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
+ extensionFlags |= kKHR_android_surface_GrVkExtensionFlag;
+ }
+#elif defined(SK_BUILD_FOR_UNIX) && !defined(__Fuchsia__)
+ if (extensions.hasInstanceExtension(VK_KHR_XCB_SURFACE_EXTENSION_NAME)) {
+ instanceExtensionNames.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
+ extensionFlags |= kKHR_xcb_surface_GrVkExtensionFlag;
+ }
+#endif
+
+ const VkInstanceCreateInfo instance_create = {
+ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType
+ nullptr, // pNext
+ 0, // flags
+ &app_info, // pApplicationInfo
+ (uint32_t) instanceLayerNames.count(), // enabledLayerNameCount
+ instanceLayerNames.begin(), // ppEnabledLayerNames
+ (uint32_t) instanceExtensionNames.count(), // enabledExtensionNameCount
+ instanceExtensionNames.begin(), // ppEnabledExtensionNames
+ };
+
+ ACQUIRE_VK_PROC(CreateInstance, VK_NULL_HANDLE, VK_NULL_HANDLE);
+ err = grVkCreateInstance(&instance_create, nullptr, &inst);
+ if (err < 0) {
+ SkDebugf("vkCreateInstance failed: %d\n", err);
+ return false;
+ }
+
+ ACQUIRE_VK_PROC(DestroyInstance, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(EnumeratePhysicalDevices, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(GetPhysicalDeviceQueueFamilyProperties, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(GetPhysicalDeviceFeatures, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(CreateDevice, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(GetDeviceQueue, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(DeviceWaitIdle, inst, VK_NULL_HANDLE);
+ ACQUIRE_VK_PROC(DestroyDevice, inst, VK_NULL_HANDLE);
+
+ uint32_t gpuCount;
+ err = grVkEnumeratePhysicalDevices(inst, &gpuCount, nullptr);
+ if (err) {
+ SkDebugf("vkEnumeratePhysicalDevices failed: %d\n", err);
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+ if (!gpuCount) {
+ SkDebugf("vkEnumeratePhysicalDevices returned no supported devices.\n");
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+ // Just returning the first physical device instead of getting the whole array.
+ // TODO: find best match for our needs
+ gpuCount = 1;
+ err = grVkEnumeratePhysicalDevices(inst, &gpuCount, &physDev);
+ // VK_INCOMPLETE is returned when the count we provide is less than the total device count.
+ if (err && VK_INCOMPLETE != err) {
+ SkDebugf("vkEnumeratePhysicalDevices failed: %d\n", err);
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+
+ // query to get the initial queue props size
+ uint32_t queueCount;
+ grVkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, nullptr);
+ if (!queueCount) {
+ SkDebugf("vkGetPhysicalDeviceQueueFamilyProperties returned no queues.\n");
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+
+ SkAutoMalloc queuePropsAlloc(queueCount * sizeof(VkQueueFamilyProperties));
+ // now get the actual queue props
+ VkQueueFamilyProperties* queueProps = (VkQueueFamilyProperties*)queuePropsAlloc.get();
+
+ grVkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, queueProps);
+
+ // iterate to find the graphics queue
+ uint32_t graphicsQueueIndex = queueCount;
+ for (uint32_t i = 0; i < queueCount; i++) {
+ if (queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+ graphicsQueueIndex = i;
+ break;
+ }
+ }
+ if (graphicsQueueIndex == queueCount) {
+ SkDebugf("Could not find any supported graphics queues.\n");
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+
+ // iterate to find the present queue, if needed
+ uint32_t presentQueueIndex = queueCount;
+ if (presentQueueIndexPtr && canPresent) {
+ for (uint32_t i = 0; i < queueCount; i++) {
+ if (canPresent(inst, physDev, i)) {
+ presentQueueIndex = i;
+ break;
+ }
+ }
+ if (presentQueueIndex == queueCount) {
+ SkDebugf("Could not find any supported present queues.\n");
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+ *presentQueueIndexPtr = presentQueueIndex;
+ } else {
+ // Just setting this so we end up make a single queue for graphics since there was no
+ // request for a present queue.
+ presentQueueIndex = graphicsQueueIndex;
+ }
+
+ extensions.initDevice(kGrVkMinimumVersion, inst, physDev);
+
+ SkTArray<const char*> deviceLayerNames;
+ SkTArray<const char*> deviceExtensionNames;
+#ifdef SK_ENABLE_VK_LAYERS
+ for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
+ if (extensions.hasDeviceLayer(kDebugLayerNames[i])) {
+ deviceLayerNames.push_back(kDebugLayerNames[i]);
+ }
+ }
+#endif
+ if (extensions.hasDeviceExtension(VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
+ deviceExtensionNames.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+ extensionFlags |= kKHR_swapchain_GrVkExtensionFlag;
+ }
+ if (extensions.hasDeviceExtension("VK_NV_glsl_shader")) {
+ deviceExtensionNames.push_back("VK_NV_glsl_shader");
+ extensionFlags |= kNV_glsl_shader_GrVkExtensionFlag;
+ }
+
+ // query to get the physical device properties
+ VkPhysicalDeviceFeatures deviceFeatures;
+ grVkGetPhysicalDeviceFeatures(physDev, &deviceFeatures);
+ // this looks like it would slow things down,
+ // and we can't depend on it on all platforms
+ deviceFeatures.robustBufferAccess = VK_FALSE;
+
+ uint32_t featureFlags = 0;
+ if (deviceFeatures.geometryShader) {
+ featureFlags |= kGeometryShader_GrVkFeatureFlag;
+ }
+ if (deviceFeatures.dualSrcBlend) {
+ featureFlags |= kDualSrcBlend_GrVkFeatureFlag;
+ }
+ if (deviceFeatures.sampleRateShading) {
+ featureFlags |= kSampleRateShading_GrVkFeatureFlag;
+ }
+
+ float queuePriorities[1] = { 0.0 };
+ // Here we assume no need for swapchain queue
+ // If one is needed, the client will need its own setup code
+ const VkDeviceQueueCreateInfo queueInfo[2] = {
+ {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
+ nullptr, // pNext
+ 0, // VkDeviceQueueCreateFlags
+ graphicsQueueIndex, // queueFamilyIndex
+ 1, // queueCount
+ queuePriorities, // pQueuePriorities
+ },
+ {
+ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
+ nullptr, // pNext
+ 0, // VkDeviceQueueCreateFlags
+ presentQueueIndex, // queueFamilyIndex
+ 1, // queueCount
+ queuePriorities, // pQueuePriorities
+ }
+ };
+ uint32_t queueInfoCount = (presentQueueIndex != graphicsQueueIndex) ? 2 : 1;
+
+ const VkDeviceCreateInfo deviceInfo = {
+ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
+ nullptr, // pNext
+ 0, // VkDeviceCreateFlags
+ queueInfoCount, // queueCreateInfoCount
+ queueInfo, // pQueueCreateInfos
+ (uint32_t) deviceLayerNames.count(), // layerCount
+ deviceLayerNames.begin(), // ppEnabledLayerNames
+ (uint32_t) deviceExtensionNames.count(), // extensionCount
+ deviceExtensionNames.begin(), // ppEnabledExtensionNames
+ &deviceFeatures // ppEnabledFeatures
+ };
+
+ err = grVkCreateDevice(physDev, &deviceInfo, nullptr, &device);
+ if (err) {
+ SkDebugf("CreateDevice failed: %d\n", err);
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+
+ auto interface =
+ sk_make_sp<GrVkInterface>(getProc, inst, device, extensionFlags);
+ if (!interface->validate(extensionFlags)) {
+ SkDebugf("Vulkan interface validation failed\n");
+ grVkDeviceWaitIdle(device);
+ grVkDestroyDevice(device, nullptr);
+ grVkDestroyInstance(inst, nullptr);
+ return false;
+ }
+
+ VkQueue queue;
+ grVkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
+
+ ctx->fInstance = inst;
+ ctx->fPhysicalDevice = physDev;
+ ctx->fDevice = device;
+ ctx->fQueue = queue;
+ ctx->fGraphicsQueueIndex = graphicsQueueIndex;
+ ctx->fMinAPIVersion = kGrVkMinimumVersion;
+ ctx->fExtensions = extensionFlags;
+ ctx->fFeatures = featureFlags;
+ ctx->fInterface.reset(interface.release());
+ ctx->fOwnsInstanceAndDevice = false;
+
+ return true;
+
+
+}
+
}
#endif
diff --git a/tools/gpu/vk/VkTestUtils.h b/tools/gpu/vk/VkTestUtils.h
index 9f34ef09c5..30471a78c0 100644
--- a/tools/gpu/vk/VkTestUtils.h
+++ b/tools/gpu/vk/VkTestUtils.h
@@ -13,9 +13,21 @@
#ifdef SK_VULKAN
#include "vk/GrVkDefines.h"
+#include "vk/GrVkInterface.h"
+
+struct GrVkBackendContext;
namespace sk_gpu_test {
bool LoadVkLibraryAndGetProcAddrFuncs(PFN_vkGetInstanceProcAddr*, PFN_vkGetDeviceProcAddr*);
+
+ using CanPresentFn = std::function<bool(VkInstance, VkPhysicalDevice,
+ uint32_t queueFamilyIndex)>;
+
+ bool CreateVkBackendContext(const GrVkInterface::GetInstanceProc& getInstanceProc,
+ const GrVkInterface::GetDeviceProc& getDeviceProc,
+ GrVkBackendContext* ctx,
+ uint32_t* presentQueueIndexPtr = nullptr,
+ CanPresentFn canPresent = CanPresentFn());
}
#endif
diff --git a/tools/sk_app/VulkanWindowContext.cpp b/tools/sk_app/VulkanWindowContext.cpp
index 2f00add92c..bc9f8d5998 100644
--- a/tools/sk_app/VulkanWindowContext.cpp
+++ b/tools/sk_app/VulkanWindowContext.cpp
@@ -13,7 +13,6 @@
#include "VulkanWindowContext.h"
#include "vk/GrVkImage.h"
-#include "vk/GrVkInterface.h"
#include "vk/GrVkUtil.h"
#include "vk/GrVkTypes.h"
@@ -22,8 +21,8 @@
#undef CreateSemaphore
#endif
-#define GET_PROC(F) f ## F = (PFN_vk ## F) fGetInstanceProcAddr(instance, "vk" #F)
-#define GET_DEV_PROC(F) f ## F = (PFN_vk ## F) fGetDeviceProcAddr(device, "vk" #F)
+#define GET_PROC(F) f ## F = (PFN_vk ## F) fGetInstanceProcAddr(fInstance, "vk" #F)
+#define GET_DEV_PROC(F) f ## F = (PFN_vk ## F) fGetDeviceProcAddr(fDevice, "vk" #F)
namespace sk_app {
@@ -49,22 +48,34 @@ VulkanWindowContext::VulkanWindowContext(const DisplayParams& params,
void VulkanWindowContext::initializeContext() {
// any config code here (particularly for msaa)?
- fBackendContext.reset(GrVkBackendContext::Create(fGetInstanceProcAddr, fGetDeviceProcAddr,
- &fPresentQueueIndex, fCanPresentFn));
- if (!(fBackendContext->fExtensions & kKHR_surface_GrVkExtensionFlag) ||
- !(fBackendContext->fExtensions & kKHR_swapchain_GrVkExtensionFlag)) {
- fBackendContext.reset(nullptr);
+ GrVkBackendContext backendContext;
+ if (!sk_gpu_test::CreateVkBackendContext(fGetInstanceProcAddr, fGetDeviceProcAddr,
+ &backendContext, &fPresentQueueIndex, fCanPresentFn)) {
return;
}
- VkInstance instance = fBackendContext->fInstance;
- VkDevice device = fBackendContext->fDevice;
+ if (!(backendContext.fExtensions & kKHR_surface_GrVkExtensionFlag) ||
+ !(backendContext.fExtensions & kKHR_swapchain_GrVkExtensionFlag)) {
+ return;
+ }
+
+ fInstance = backendContext.fInstance;
+ fPhysicalDevice = backendContext.fPhysicalDevice;
+ fDevice = backendContext.fDevice;
+ fGraphicsQueueIndex = backendContext.fGraphicsQueueIndex;
+ fGraphicsQueue = backendContext.fQueue;
+ fInterface = backendContext.fInterface;
+
+ GET_PROC(DestroyInstance);
GET_PROC(DestroySurfaceKHR);
GET_PROC(GetPhysicalDeviceSurfaceSupportKHR);
GET_PROC(GetPhysicalDeviceSurfaceCapabilitiesKHR);
GET_PROC(GetPhysicalDeviceSurfaceFormatsKHR);
GET_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
+ GET_DEV_PROC(DeviceWaitIdle);
+ GET_DEV_PROC(QueueWaitIdle);
+ GET_DEV_PROC(DestroyDevice);
GET_DEV_PROC(CreateSwapchainKHR);
GET_DEV_PROC(DestroySwapchainKHR);
GET_DEV_PROC(GetSwapchainImagesKHR);
@@ -72,18 +83,17 @@ void VulkanWindowContext::initializeContext() {
GET_DEV_PROC(QueuePresentKHR);
GET_DEV_PROC(GetDeviceQueue);
- fContext = GrContext::MakeVulkan(fBackendContext, fDisplayParams.fGrContextOptions);
+ fContext = GrContext::MakeVulkan(backendContext, fDisplayParams.fGrContextOptions);
- fSurface = fCreateVkSurfaceFn(instance);
+ fSurface = fCreateVkSurfaceFn(fInstance);
if (VK_NULL_HANDLE == fSurface) {
- fBackendContext.reset(nullptr);
+ this->destroyContext();
return;
}
VkBool32 supported;
- VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
- fPresentQueueIndex, fSurface,
- &supported);
+ VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fPhysicalDevice, fPresentQueueIndex,
+ fSurface, &supported);
if (VK_SUCCESS != res) {
this->destroyContext();
return;
@@ -95,45 +105,44 @@ void VulkanWindowContext::initializeContext() {
}
// create presentQueue
- fGetDeviceQueue(fBackendContext->fDevice, fPresentQueueIndex, 0, &fPresentQueue);
+ fGetDeviceQueue(fDevice, fPresentQueueIndex, 0, &fPresentQueue);
}
bool VulkanWindowContext::createSwapchain(int width, int height,
const DisplayParams& params) {
// check for capabilities
VkSurfaceCapabilitiesKHR caps;
- VkResult res = fGetPhysicalDeviceSurfaceCapabilitiesKHR(fBackendContext->fPhysicalDevice,
- fSurface, &caps);
+ VkResult res = fGetPhysicalDeviceSurfaceCapabilitiesKHR(fPhysicalDevice, fSurface, &caps);
if (VK_SUCCESS != res) {
return false;
}
uint32_t surfaceFormatCount;
- res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
- &surfaceFormatCount, nullptr);
+ res = fGetPhysicalDeviceSurfaceFormatsKHR(fPhysicalDevice, fSurface, &surfaceFormatCount,
+ nullptr);
if (VK_SUCCESS != res) {
return false;
}
SkAutoMalloc surfaceFormatAlloc(surfaceFormatCount * sizeof(VkSurfaceFormatKHR));
VkSurfaceFormatKHR* surfaceFormats = (VkSurfaceFormatKHR*)surfaceFormatAlloc.get();
- res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
- &surfaceFormatCount, surfaceFormats);
+ res = fGetPhysicalDeviceSurfaceFormatsKHR(fPhysicalDevice, fSurface, &surfaceFormatCount,
+ surfaceFormats);
if (VK_SUCCESS != res) {
return false;
}
uint32_t presentModeCount;
- res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
- &presentModeCount, nullptr);
+ res = fGetPhysicalDeviceSurfacePresentModesKHR(fPhysicalDevice, fSurface, &presentModeCount,
+ nullptr);
if (VK_SUCCESS != res) {
return false;
}
SkAutoMalloc presentModeAlloc(presentModeCount * sizeof(VkPresentModeKHR));
VkPresentModeKHR* presentModes = (VkPresentModeKHR*)presentModeAlloc.get();
- res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
- &presentModeCount, presentModes);
+ res = fGetPhysicalDeviceSurfacePresentModesKHR(fPhysicalDevice, fSurface, &presentModeCount,
+ presentModes);
if (VK_SUCCESS != res) {
return false;
}
@@ -234,8 +243,8 @@ bool VulkanWindowContext::createSwapchain(int width, int height,
swapchainCreateInfo.imageArrayLayers = 1;
swapchainCreateInfo.imageUsage = usageFlags;
- uint32_t queueFamilies[] = { fBackendContext->fGraphicsQueueIndex, fPresentQueueIndex };
- if (fBackendContext->fGraphicsQueueIndex != fPresentQueueIndex) {
+ uint32_t queueFamilies[] = { fGraphicsQueueIndex, fPresentQueueIndex };
+ if (fGraphicsQueueIndex != fPresentQueueIndex) {
swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
swapchainCreateInfo.queueFamilyIndexCount = 2;
swapchainCreateInfo.pQueueFamilyIndices = queueFamilies;
@@ -251,18 +260,18 @@ bool VulkanWindowContext::createSwapchain(int width, int height,
swapchainCreateInfo.clipped = true;
swapchainCreateInfo.oldSwapchain = fSwapchain;
- res = fCreateSwapchainKHR(fBackendContext->fDevice, &swapchainCreateInfo, nullptr, &fSwapchain);
+ res = fCreateSwapchainKHR(fDevice, &swapchainCreateInfo, nullptr, &fSwapchain);
if (VK_SUCCESS != res) {
return false;
}
// destroy the old swapchain
if (swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) {
- GR_VK_CALL(fBackendContext->fInterface, DeviceWaitIdle(fBackendContext->fDevice));
+ fDeviceWaitIdle(fDevice);
this->destroyBuffers();
- fDestroySwapchainKHR(fBackendContext->fDevice, swapchainCreateInfo.oldSwapchain, nullptr);
+ fDestroySwapchainKHR(fDevice, swapchainCreateInfo.oldSwapchain, nullptr);
}
this->createBuffers(swapchainCreateInfo.imageFormat, colorType);
@@ -271,10 +280,10 @@ bool VulkanWindowContext::createSwapchain(int width, int height,
}
void VulkanWindowContext::createBuffers(VkFormat format, SkColorType colorType) {
- fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, nullptr);
+ fGetSwapchainImagesKHR(fDevice, fSwapchain, &fImageCount, nullptr);
SkASSERT(fImageCount);
fImages = new VkImage[fImageCount];
- fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, fImages);
+ fGetSwapchainImagesKHR(fDevice, fSwapchain, &fImageCount, fImages);
// set up initial image layouts and create surfaces
fImageLayouts = new VkImageLayout[fImageCount];
@@ -306,10 +315,10 @@ void VulkanWindowContext::createBuffers(VkFormat format, SkColorType colorType)
memset(&commandPoolInfo, 0, sizeof(VkCommandPoolCreateInfo));
commandPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
// this needs to be on the render queue
- commandPoolInfo.queueFamilyIndex = fBackendContext->fGraphicsQueueIndex;
+ commandPoolInfo.queueFamilyIndex = fGraphicsQueueIndex;
commandPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- CreateCommandPool(fBackendContext->fDevice, &commandPoolInfo,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ CreateCommandPool(fDevice, &commandPoolInfo,
nullptr, &fCommandPool));
}
@@ -337,20 +346,20 @@ void VulkanWindowContext::createBuffers(VkFormat format, SkColorType colorType)
fBackbuffers = new BackbufferInfo[fImageCount + 1];
for (uint32_t i = 0; i < fImageCount + 1; ++i) {
fBackbuffers[i].fImageIndex = -1;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- CreateSemaphore(fBackendContext->fDevice, &semaphoreInfo,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ CreateSemaphore(fDevice, &semaphoreInfo,
nullptr, &fBackbuffers[i].fAcquireSemaphore));
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- CreateSemaphore(fBackendContext->fDevice, &semaphoreInfo,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ CreateSemaphore(fDevice, &semaphoreInfo,
nullptr, &fBackbuffers[i].fRenderSemaphore));
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- AllocateCommandBuffers(fBackendContext->fDevice, &commandBuffersInfo,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ AllocateCommandBuffers(fDevice, &commandBuffersInfo,
fBackbuffers[i].fTransitionCmdBuffers));
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- CreateFence(fBackendContext->fDevice, &fenceInfo, nullptr,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ CreateFence(fDevice, &fenceInfo, nullptr,
&fBackbuffers[i].fUsageFences[0]));
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- CreateFence(fBackendContext->fDevice, &fenceInfo, nullptr,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ CreateFence(fDevice, &fenceInfo, nullptr,
&fBackbuffers[i].fUsageFences[1]));
}
fCurrentBackbufferIndex = fImageCount;
@@ -360,26 +369,26 @@ void VulkanWindowContext::destroyBuffers() {
if (fBackbuffers) {
for (uint32_t i = 0; i < fImageCount + 1; ++i) {
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- WaitForFences(fBackendContext->fDevice, 2,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ WaitForFences(fDevice, 2,
fBackbuffers[i].fUsageFences,
true, UINT64_MAX));
fBackbuffers[i].fImageIndex = -1;
- GR_VK_CALL(fBackendContext->fInterface,
- DestroySemaphore(fBackendContext->fDevice,
+ GR_VK_CALL(fInterface,
+ DestroySemaphore(fDevice,
fBackbuffers[i].fAcquireSemaphore,
nullptr));
- GR_VK_CALL(fBackendContext->fInterface,
- DestroySemaphore(fBackendContext->fDevice,
+ GR_VK_CALL(fInterface,
+ DestroySemaphore(fDevice,
fBackbuffers[i].fRenderSemaphore,
nullptr));
- GR_VK_CALL(fBackendContext->fInterface,
- FreeCommandBuffers(fBackendContext->fDevice, fCommandPool, 2,
+ GR_VK_CALL(fInterface,
+ FreeCommandBuffers(fDevice, fCommandPool, 2,
fBackbuffers[i].fTransitionCmdBuffers));
- GR_VK_CALL(fBackendContext->fInterface,
- DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[0], 0));
- GR_VK_CALL(fBackendContext->fInterface,
- DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[1], 0));
+ GR_VK_CALL(fInterface,
+ DestroyFence(fDevice, fBackbuffers[i].fUsageFences[0], 0));
+ GR_VK_CALL(fInterface,
+ DestroyFence(fDevice, fBackbuffers[i].fUsageFences[1], 0));
}
}
@@ -400,34 +409,43 @@ VulkanWindowContext::~VulkanWindowContext() {
}
void VulkanWindowContext::destroyContext() {
- if (!fBackendContext.get()) {
+ if (!this->isValid()) {
return;
}
- GR_VK_CALL(fBackendContext->fInterface, QueueWaitIdle(fPresentQueue));
- GR_VK_CALL(fBackendContext->fInterface, DeviceWaitIdle(fBackendContext->fDevice));
+ fQueueWaitIdle(fPresentQueue);
+ fDeviceWaitIdle(fDevice);
this->destroyBuffers();
if (VK_NULL_HANDLE != fCommandPool) {
- GR_VK_CALL(fBackendContext->fInterface, DestroyCommandPool(fBackendContext->fDevice,
- fCommandPool, nullptr));
+ GR_VK_CALL(fInterface, DestroyCommandPool(fDevice, fCommandPool, nullptr));
fCommandPool = VK_NULL_HANDLE;
}
if (VK_NULL_HANDLE != fSwapchain) {
- fDestroySwapchainKHR(fBackendContext->fDevice, fSwapchain, nullptr);
+ fDestroySwapchainKHR(fDevice, fSwapchain, nullptr);
fSwapchain = VK_NULL_HANDLE;
}
if (VK_NULL_HANDLE != fSurface) {
- fDestroySurfaceKHR(fBackendContext->fInstance, fSurface, nullptr);
+ fDestroySurfaceKHR(fInstance, fSurface, nullptr);
fSurface = VK_NULL_HANDLE;
}
fContext.reset();
+ fInterface.reset();
+
+ if (VK_NULL_HANDLE != fDevice) {
+ fDestroyDevice(fDevice, nullptr);
+ fDevice = VK_NULL_HANDLE;
+ }
+ fPhysicalDevice = VK_NULL_HANDLE;
- fBackendContext.reset(nullptr);
+ if (VK_NULL_HANDLE != fInstance) {
+ fDestroyInstance(fInstance, nullptr);
+ fInstance = VK_NULL_HANDLE;
+ }
}
VulkanWindowContext::BackbufferInfo* VulkanWindowContext::getAvailableBackbuffer() {
@@ -439,8 +457,8 @@ VulkanWindowContext::BackbufferInfo* VulkanWindowContext::getAvailableBackbuffer
}
BackbufferInfo* backbuffer = fBackbuffers + fCurrentBackbufferIndex;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- WaitForFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ WaitForFences(fDevice, 2, backbuffer->fUsageFences,
true, UINT64_MAX));
return backbuffer;
}
@@ -450,12 +468,12 @@ sk_sp<SkSurface> VulkanWindowContext::getBackbufferSurface() {
SkASSERT(backbuffer);
// reset the fence
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- ResetFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences));
+ GR_VK_CALL_ERRCHECK(fInterface,
+ ResetFences(fDevice, 2, backbuffer->fUsageFences));
// semaphores should be in unsignaled state
// acquire the image
- VkResult res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
+ VkResult res = fAcquireNextImageKHR(fDevice, fSwapchain, UINT64_MAX,
backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
&backbuffer->fImageIndex);
if (VK_ERROR_SURFACE_LOST_KHR == res) {
@@ -469,11 +487,11 @@ sk_sp<SkSurface> VulkanWindowContext::getBackbufferSurface() {
return nullptr;
}
backbuffer = this->getAvailableBackbuffer();
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- ResetFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences));
+ GR_VK_CALL_ERRCHECK(fInterface,
+ ResetFences(fDevice, 2, backbuffer->fUsageFences));
// acquire the image
- res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
+ res = fAcquireNextImageKHR(fDevice, fSwapchain, UINT64_MAX,
backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
&backbuffer->fImageIndex);
@@ -501,27 +519,27 @@ sk_sp<SkSurface> VulkanWindowContext::getBackbufferSurface() {
layout, // oldLayout
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
fPresentQueueIndex, // srcQueueFamilyIndex
- fBackendContext->fGraphicsQueueIndex, // dstQueueFamilyIndex
+ fGraphicsQueueIndex, // dstQueueFamilyIndex
fImages[backbuffer->fImageIndex], // image
{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
};
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
+ GR_VK_CALL_ERRCHECK(fInterface,
ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[0], 0));
VkCommandBufferBeginInfo info;
memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
info.flags = 0;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
+ GR_VK_CALL_ERRCHECK(fInterface,
BeginCommandBuffer(backbuffer->fTransitionCmdBuffers[0], &info));
- GR_VK_CALL(fBackendContext->fInterface,
+ GR_VK_CALL(fInterface,
CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[0],
srcStageMask, dstStageMask, 0,
0, nullptr,
0, nullptr,
1, &imageMemoryBarrier));
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
+ GR_VK_CALL_ERRCHECK(fInterface,
EndCommandBuffer(backbuffer->fTransitionCmdBuffers[0]));
VkPipelineStageFlags waitDstStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
@@ -536,8 +554,8 @@ sk_sp<SkSurface> VulkanWindowContext::getBackbufferSurface() {
submitInfo.pCommandBuffers = &backbuffer->fTransitionCmdBuffers[0];
submitInfo.signalSemaphoreCount = 0;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- QueueSubmit(fBackendContext->fQueue, 1, &submitInfo,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ QueueSubmit(fGraphicsQueue, 1, &submitInfo,
backbuffer->fUsageFences[0]));
SkSurface* surface = fSurfaces[backbuffer->fImageIndex].get();
@@ -574,26 +592,26 @@ void VulkanWindowContext::swapBuffers() {
dstAccessMask, // inputMask
layout, // oldLayout
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // newLayout
- fBackendContext->fGraphicsQueueIndex, // srcQueueFamilyIndex
+ fGraphicsQueueIndex, // srcQueueFamilyIndex
fPresentQueueIndex, // dstQueueFamilyIndex
fImages[backbuffer->fImageIndex], // image
{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
};
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
+ GR_VK_CALL_ERRCHECK(fInterface,
ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[1], 0));
VkCommandBufferBeginInfo info;
memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
info.flags = 0;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
+ GR_VK_CALL_ERRCHECK(fInterface,
BeginCommandBuffer(backbuffer->fTransitionCmdBuffers[1], &info));
- GR_VK_CALL(fBackendContext->fInterface,
+ GR_VK_CALL(fInterface,
CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[1],
srcStageMask, dstStageMask, 0,
0, nullptr,
0, nullptr,
1, &imageMemoryBarrier));
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
+ GR_VK_CALL_ERRCHECK(fInterface,
EndCommandBuffer(backbuffer->fTransitionCmdBuffers[1]));
fImageLayouts[backbuffer->fImageIndex] = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
@@ -609,8 +627,8 @@ void VulkanWindowContext::swapBuffers() {
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &backbuffer->fRenderSemaphore;
- GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
- QueueSubmit(fBackendContext->fQueue, 1, &submitInfo,
+ GR_VK_CALL_ERRCHECK(fInterface,
+ QueueSubmit(fGraphicsQueue, 1, &submitInfo,
backbuffer->fUsageFences[1]));
// Submit present operation to present queue
diff --git a/tools/sk_app/VulkanWindowContext.h b/tools/sk_app/VulkanWindowContext.h
index 1fca9dc83e..79298f6b38 100644
--- a/tools/sk_app/VulkanWindowContext.h
+++ b/tools/sk_app/VulkanWindowContext.h
@@ -13,6 +13,8 @@
#ifdef SK_VULKAN
#include "vk/GrVkBackendContext.h"
+#include "vk/GrVkInterface.h"
+#include "vk/VkTestUtils.h"
#include "WindowContext.h"
class GrRenderTarget;
@@ -26,7 +28,7 @@ public:
sk_sp<SkSurface> getBackbufferSurface() override;
void swapBuffers() override;
- bool isValid() override { return SkToBool(fBackendContext.get()); }
+ bool isValid() override { return fDevice != VK_NULL_HANDLE; }
void resize(int w, int h) override {
this->createSwapchain(w, h, fDisplayParams);
@@ -41,7 +43,7 @@ public:
/** Platform specific function that creates a VkSurfaceKHR for a window */
using CreateVkSurfaceFn = std::function<VkSurfaceKHR(VkInstance)>;
/** Platform specific function that determines whether presentation will succeed. */
- using CanPresentFn = GrVkBackendContext::CanPresentFn;
+ using CanPresentFn = sk_gpu_test::CanPresentFn;
VulkanWindowContext(const DisplayParams&, CreateVkSurfaceFn, CanPresentFn,
PFN_vkGetInstanceProcAddr, PFN_vkGetDeviceProcAddr);
@@ -63,7 +65,9 @@ private:
void createBuffers(VkFormat format, SkColorType colorType);
void destroyBuffers();
- sk_sp<const GrVkBackendContext> fBackendContext;
+ VkInstance fInstance = VK_NULL_HANDLE;
+ VkPhysicalDevice fPhysicalDevice = VK_NULL_HANDLE;
+ VkDevice fDevice = VK_NULL_HANDLE;
// simple wrapper class that exists only to initialize a pointer to NULL
template <typename FNPTR_TYPE> class VkPtr {
@@ -95,10 +99,19 @@ private:
VkPtr<PFN_vkGetSwapchainImagesKHR> fGetSwapchainImagesKHR;
VkPtr<PFN_vkAcquireNextImageKHR> fAcquireNextImageKHR;
VkPtr<PFN_vkQueuePresentKHR> fQueuePresentKHR;
+
+ VkPtr<PFN_vkDestroyInstance> fDestroyInstance;
+ VkPtr<PFN_vkDeviceWaitIdle> fDeviceWaitIdle;
+ VkPtr<PFN_vkQueueWaitIdle> fQueueWaitIdle;
+ VkPtr<PFN_vkDestroyDevice> fDestroyDevice;
VkPtr<PFN_vkGetDeviceQueue> fGetDeviceQueue;
+ sk_sp<const GrVkInterface> fInterface;
+
VkSurfaceKHR fSurface;
VkSwapchainKHR fSwapchain;
+ uint32_t fGraphicsQueueIndex;
+ VkQueue fGraphicsQueue;
uint32_t fPresentQueueIndex;
VkQueue fPresentQueue;
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-17 08:40:19 +0000