1
2 /*
3 * Copyright 2015 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9 #include "GrBackendSurface.h"
10 #include "GrContext.h"
11 #include "SkAutoMalloc.h"
12 #include "SkSurface.h"
13 #include "VulkanWindowContext.h"
14
15 #include "vk/GrVkInterface.h"
16 #include "vk/GrVkMemory.h"
17 #include "vk/GrVkUtil.h"
18 #include "vk/GrVkTypes.h"
19
20 #ifdef VK_USE_PLATFORM_WIN32_KHR
21 // windows wants to define this as CreateSemaphoreA or CreateSemaphoreW
22 #undef CreateSemaphore
23 #endif
24
25 #define GET_PROC(F) f ## F = (PFN_vk ## F) fGetInstanceProcAddr(instance, "vk" #F)
26 #define GET_DEV_PROC(F) f ## F = (PFN_vk ## F) fGetDeviceProcAddr(device, "vk" #F)
27
28 namespace sk_app {
29
VulkanWindowContext(const DisplayParams & params,CreateVkSurfaceFn createVkSurface,CanPresentFn canPresent,PFN_vkGetInstanceProcAddr instProc,PFN_vkGetDeviceProcAddr devProc)30 VulkanWindowContext::VulkanWindowContext(const DisplayParams& params,
31 CreateVkSurfaceFn createVkSurface,
32 CanPresentFn canPresent,
33 PFN_vkGetInstanceProcAddr instProc,
34 PFN_vkGetDeviceProcAddr devProc)
35 : WindowContext(params)
36 , fCreateVkSurfaceFn(createVkSurface)
37 , fCanPresentFn(canPresent)
38 , fSurface(VK_NULL_HANDLE)
39 , fSwapchain(VK_NULL_HANDLE)
40 , fImages(nullptr)
41 , fImageLayouts(nullptr)
42 , fSurfaces(nullptr)
43 , fCommandPool(VK_NULL_HANDLE)
44 , fBackbuffers(nullptr) {
45 fGetInstanceProcAddr = instProc;
46 fGetDeviceProcAddr = devProc;
47 this->initializeContext();
48 }
49
initializeContext()50 void VulkanWindowContext::initializeContext() {
51 // any config code here (particularly for msaa)?
52 fBackendContext.reset(GrVkBackendContext::Create(fGetInstanceProcAddr, fGetDeviceProcAddr,
53 &fPresentQueueIndex, fCanPresentFn));
54
55 if (!(fBackendContext->fExtensions & kKHR_surface_GrVkExtensionFlag) ||
56 !(fBackendContext->fExtensions & kKHR_swapchain_GrVkExtensionFlag)) {
57 fBackendContext.reset(nullptr);
58 return;
59 }
60
61 VkInstance instance = fBackendContext->fInstance;
62 VkDevice device = fBackendContext->fDevice;
63 GET_PROC(DestroySurfaceKHR);
64 GET_PROC(GetPhysicalDeviceSurfaceSupportKHR);
65 GET_PROC(GetPhysicalDeviceSurfaceCapabilitiesKHR);
66 GET_PROC(GetPhysicalDeviceSurfaceFormatsKHR);
67 GET_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
68 GET_DEV_PROC(CreateSwapchainKHR);
69 GET_DEV_PROC(DestroySwapchainKHR);
70 GET_DEV_PROC(GetSwapchainImagesKHR);
71 GET_DEV_PROC(AcquireNextImageKHR);
72 GET_DEV_PROC(QueuePresentKHR);
73 GET_DEV_PROC(GetDeviceQueue);
74
75 fContext = GrContext::MakeVulkan(fBackendContext, fDisplayParams.fGrContextOptions);
76
77 fSurface = fCreateVkSurfaceFn(instance);
78 if (VK_NULL_HANDLE == fSurface) {
79 fBackendContext.reset(nullptr);
80 return;
81 }
82
83 VkBool32 supported;
84 VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
85 fPresentQueueIndex, fSurface,
86 &supported);
87 if (VK_SUCCESS != res) {
88 this->destroyContext();
89 return;
90 }
91
92 if (!this->createSwapchain(-1, -1, fDisplayParams)) {
93 this->destroyContext();
94 return;
95 }
96
97 // create presentQueue
98 fGetDeviceQueue(fBackendContext->fDevice, fPresentQueueIndex, 0, &fPresentQueue);
99 }
100
createSwapchain(int width,int height,const DisplayParams & params)101 bool VulkanWindowContext::createSwapchain(int width, int height,
102 const DisplayParams& params) {
103 // check for capabilities
104 VkSurfaceCapabilitiesKHR caps;
105 VkResult res = fGetPhysicalDeviceSurfaceCapabilitiesKHR(fBackendContext->fPhysicalDevice,
106 fSurface, &caps);
107 if (VK_SUCCESS != res) {
108 return false;
109 }
110
111 uint32_t surfaceFormatCount;
112 res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
113 &surfaceFormatCount, nullptr);
114 if (VK_SUCCESS != res) {
115 return false;
116 }
117
118 SkAutoMalloc surfaceFormatAlloc(surfaceFormatCount * sizeof(VkSurfaceFormatKHR));
119 VkSurfaceFormatKHR* surfaceFormats = (VkSurfaceFormatKHR*)surfaceFormatAlloc.get();
120 res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
121 &surfaceFormatCount, surfaceFormats);
122 if (VK_SUCCESS != res) {
123 return false;
124 }
125
126 uint32_t presentModeCount;
127 res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
128 &presentModeCount, nullptr);
129 if (VK_SUCCESS != res) {
130 return false;
131 }
132
133 SkAutoMalloc presentModeAlloc(presentModeCount * sizeof(VkPresentModeKHR));
134 VkPresentModeKHR* presentModes = (VkPresentModeKHR*)presentModeAlloc.get();
135 res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
136 &presentModeCount, presentModes);
137 if (VK_SUCCESS != res) {
138 return false;
139 }
140
141 VkExtent2D extent = caps.currentExtent;
142 // use the hints
143 if (extent.width == (uint32_t)-1) {
144 extent.width = width;
145 extent.height = height;
146 }
147
148 // clamp width; to protect us from broken hints
149 if (extent.width < caps.minImageExtent.width) {
150 extent.width = caps.minImageExtent.width;
151 } else if (extent.width > caps.maxImageExtent.width) {
152 extent.width = caps.maxImageExtent.width;
153 }
154 // clamp height
155 if (extent.height < caps.minImageExtent.height) {
156 extent.height = caps.minImageExtent.height;
157 } else if (extent.height > caps.maxImageExtent.height) {
158 extent.height = caps.maxImageExtent.height;
159 }
160
161 fWidth = (int)extent.width;
162 fHeight = (int)extent.height;
163
164 uint32_t imageCount = caps.minImageCount + 2;
165 if (caps.maxImageCount > 0 && imageCount > caps.maxImageCount) {
166 // Application must settle for fewer images than desired:
167 imageCount = caps.maxImageCount;
168 }
169
170 VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
171 VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
172 VK_IMAGE_USAGE_TRANSFER_DST_BIT;
173 SkASSERT((caps.supportedUsageFlags & usageFlags) == usageFlags);
174 SkASSERT(caps.supportedTransforms & caps.currentTransform);
175 SkASSERT(caps.supportedCompositeAlpha & (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
176 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
177 VkCompositeAlphaFlagBitsKHR composite_alpha =
178 (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
179 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR :
180 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
181
182 // Pick our surface format. For now, just make sure it matches our sRGB request:
183 VkFormat surfaceFormat = VK_FORMAT_UNDEFINED;
184 VkColorSpaceKHR colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
185 auto srgbColorSpace = SkColorSpace::MakeSRGB();
186 bool wantSRGB = srgbColorSpace == params.fColorSpace;
187 for (uint32_t i = 0; i < surfaceFormatCount; ++i) {
188 VkFormat localFormat = surfaceFormats[i].format;
189 if (GrVkFormatIsSupported(localFormat) &&
190 GrVkFormatIsSRGB(localFormat, nullptr) == wantSRGB) {
191 surfaceFormat = localFormat;
192 colorSpace = surfaceFormats[i].colorSpace;
193 break;
194 }
195 }
196 fDisplayParams = params;
197 fSampleCount = params.fMSAASampleCount;
198 fStencilBits = 8;
199
200 if (VK_FORMAT_UNDEFINED == surfaceFormat) {
201 return false;
202 }
203
204 SkColorType colorType;
205 switch (surfaceFormat) {
206 case VK_FORMAT_R8G8B8A8_UNORM: // fall through
207 case VK_FORMAT_R8G8B8A8_SRGB:
208 colorType = kRGBA_8888_SkColorType;
209 break;
210 case VK_FORMAT_B8G8R8A8_UNORM: // fall through
211 case VK_FORMAT_B8G8R8A8_SRGB:
212 colorType = kBGRA_8888_SkColorType;
213 break;
214 default:
215 return false;
216 }
217
218 // If mailbox mode is available, use it, as it is the lowest-latency non-
219 // tearing mode. If not, fall back to FIFO which is always available.
220 VkPresentModeKHR mode = VK_PRESENT_MODE_FIFO_KHR;
221 for (uint32_t i = 0; i < presentModeCount; ++i) {
222 // use mailbox
223 if (VK_PRESENT_MODE_MAILBOX_KHR == presentModes[i]) {
224 mode = presentModes[i];
225 break;
226 }
227 }
228
229 VkSwapchainCreateInfoKHR swapchainCreateInfo;
230 memset(&swapchainCreateInfo, 0, sizeof(VkSwapchainCreateInfoKHR));
231 swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
232 swapchainCreateInfo.surface = fSurface;
233 swapchainCreateInfo.minImageCount = imageCount;
234 swapchainCreateInfo.imageFormat = surfaceFormat;
235 swapchainCreateInfo.imageColorSpace = colorSpace;
236 swapchainCreateInfo.imageExtent = extent;
237 swapchainCreateInfo.imageArrayLayers = 1;
238 swapchainCreateInfo.imageUsage = usageFlags;
239
240 uint32_t queueFamilies[] = { fBackendContext->fGraphicsQueueIndex, fPresentQueueIndex };
241 if (fBackendContext->fGraphicsQueueIndex != fPresentQueueIndex) {
242 swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
243 swapchainCreateInfo.queueFamilyIndexCount = 2;
244 swapchainCreateInfo.pQueueFamilyIndices = queueFamilies;
245 } else {
246 swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
247 swapchainCreateInfo.queueFamilyIndexCount = 0;
248 swapchainCreateInfo.pQueueFamilyIndices = nullptr;
249 }
250
251 swapchainCreateInfo.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
252 swapchainCreateInfo.compositeAlpha = composite_alpha;
253 swapchainCreateInfo.presentMode = mode;
254 swapchainCreateInfo.clipped = true;
255 swapchainCreateInfo.oldSwapchain = fSwapchain;
256
257 res = fCreateSwapchainKHR(fBackendContext->fDevice, &swapchainCreateInfo, nullptr, &fSwapchain);
258 if (VK_SUCCESS != res) {
259 return false;
260 }
261
262 // destroy the old swapchain
263 if (swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) {
264 GR_VK_CALL(fBackendContext->fInterface, DeviceWaitIdle(fBackendContext->fDevice));
265
266 this->destroyBuffers();
267
268 fDestroySwapchainKHR(fBackendContext->fDevice, swapchainCreateInfo.oldSwapchain, nullptr);
269 }
270
271 this->createBuffers(swapchainCreateInfo.imageFormat, colorType);
272
273 return true;
274 }
275
createBuffers(VkFormat format,SkColorType colorType)276 void VulkanWindowContext::createBuffers(VkFormat format, SkColorType colorType) {
277 fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, nullptr);
278 SkASSERT(fImageCount);
279 fImages = new VkImage[fImageCount];
280 fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, fImages);
281
282 // set up initial image layouts and create surfaces
283 fImageLayouts = new VkImageLayout[fImageCount];
284 fSurfaces = new sk_sp<SkSurface>[fImageCount];
285 for (uint32_t i = 0; i < fImageCount; ++i) {
286 fImageLayouts[i] = VK_IMAGE_LAYOUT_UNDEFINED;
287
288 GrVkImageInfo info;
289 info.fImage = fImages[i];
290 info.fAlloc = GrVkAlloc();
291 info.fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
292 info.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
293 info.fFormat = format;
294 info.fLevelCount = 1;
295
296 GrBackendTexture backendTex(fWidth, fHeight, info);
297
298 fSurfaces[i] = SkSurface::MakeFromBackendTextureAsRenderTarget(fContext.get(), backendTex,
299 kTopLeft_GrSurfaceOrigin,
300 fSampleCount,
301 colorType,
302 fDisplayParams.fColorSpace,
303 &fSurfaceProps);
304 }
305
306 // create the command pool for the command buffers
307 if (VK_NULL_HANDLE == fCommandPool) {
308 VkCommandPoolCreateInfo commandPoolInfo;
309 memset(&commandPoolInfo, 0, sizeof(VkCommandPoolCreateInfo));
310 commandPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
311 // this needs to be on the render queue
312 commandPoolInfo.queueFamilyIndex = fBackendContext->fGraphicsQueueIndex;
313 commandPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
314 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
315 CreateCommandPool(fBackendContext->fDevice, &commandPoolInfo,
316 nullptr, &fCommandPool));
317 }
318
319 // set up the backbuffers
320 VkSemaphoreCreateInfo semaphoreInfo;
321 memset(&semaphoreInfo, 0, sizeof(VkSemaphoreCreateInfo));
322 semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
323 semaphoreInfo.pNext = nullptr;
324 semaphoreInfo.flags = 0;
325 VkCommandBufferAllocateInfo commandBuffersInfo;
326 memset(&commandBuffersInfo, 0, sizeof(VkCommandBufferAllocateInfo));
327 commandBuffersInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
328 commandBuffersInfo.pNext = nullptr;
329 commandBuffersInfo.commandPool = fCommandPool;
330 commandBuffersInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
331 commandBuffersInfo.commandBufferCount = 2;
332 VkFenceCreateInfo fenceInfo;
333 memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
334 fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
335 fenceInfo.pNext = nullptr;
336 fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
337
338 // we create one additional backbuffer structure here, because we want to
339 // give the command buffers they contain a chance to finish before we cycle back
340 fBackbuffers = new BackbufferInfo[fImageCount + 1];
341 for (uint32_t i = 0; i < fImageCount + 1; ++i) {
342 fBackbuffers[i].fImageIndex = -1;
343 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
344 CreateSemaphore(fBackendContext->fDevice, &semaphoreInfo,
345 nullptr, &fBackbuffers[i].fAcquireSemaphore));
346 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
347 CreateSemaphore(fBackendContext->fDevice, &semaphoreInfo,
348 nullptr, &fBackbuffers[i].fRenderSemaphore));
349 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
350 AllocateCommandBuffers(fBackendContext->fDevice, &commandBuffersInfo,
351 fBackbuffers[i].fTransitionCmdBuffers));
352 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
353 CreateFence(fBackendContext->fDevice, &fenceInfo, nullptr,
354 &fBackbuffers[i].fUsageFences[0]));
355 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
356 CreateFence(fBackendContext->fDevice, &fenceInfo, nullptr,
357 &fBackbuffers[i].fUsageFences[1]));
358 }
359 fCurrentBackbufferIndex = fImageCount;
360 }
361
destroyBuffers()362 void VulkanWindowContext::destroyBuffers() {
363
364 if (fBackbuffers) {
365 for (uint32_t i = 0; i < fImageCount + 1; ++i) {
366 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
367 WaitForFences(fBackendContext->fDevice, 2,
368 fBackbuffers[i].fUsageFences,
369 true, UINT64_MAX));
370 fBackbuffers[i].fImageIndex = -1;
371 GR_VK_CALL(fBackendContext->fInterface,
372 DestroySemaphore(fBackendContext->fDevice,
373 fBackbuffers[i].fAcquireSemaphore,
374 nullptr));
375 GR_VK_CALL(fBackendContext->fInterface,
376 DestroySemaphore(fBackendContext->fDevice,
377 fBackbuffers[i].fRenderSemaphore,
378 nullptr));
379 GR_VK_CALL(fBackendContext->fInterface,
380 FreeCommandBuffers(fBackendContext->fDevice, fCommandPool, 2,
381 fBackbuffers[i].fTransitionCmdBuffers));
382 GR_VK_CALL(fBackendContext->fInterface,
383 DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[0], 0));
384 GR_VK_CALL(fBackendContext->fInterface,
385 DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[1], 0));
386 }
387 }
388
389 delete[] fBackbuffers;
390 fBackbuffers = nullptr;
391
392 // Does this actually free the surfaces?
393 delete[] fSurfaces;
394 fSurfaces = nullptr;
395 delete[] fImageLayouts;
396 fImageLayouts = nullptr;
397 delete[] fImages;
398 fImages = nullptr;
399 }
400
~VulkanWindowContext()401 VulkanWindowContext::~VulkanWindowContext() {
402 this->destroyContext();
403 }
404
destroyContext()405 void VulkanWindowContext::destroyContext() {
406 if (!fBackendContext.get()) {
407 return;
408 }
409
410 GR_VK_CALL(fBackendContext->fInterface, QueueWaitIdle(fPresentQueue));
411 GR_VK_CALL(fBackendContext->fInterface, DeviceWaitIdle(fBackendContext->fDevice));
412
413 this->destroyBuffers();
414
415 if (VK_NULL_HANDLE != fCommandPool) {
416 GR_VK_CALL(fBackendContext->fInterface, DestroyCommandPool(fBackendContext->fDevice,
417 fCommandPool, nullptr));
418 fCommandPool = VK_NULL_HANDLE;
419 }
420
421 if (VK_NULL_HANDLE != fSwapchain) {
422 fDestroySwapchainKHR(fBackendContext->fDevice, fSwapchain, nullptr);
423 fSwapchain = VK_NULL_HANDLE;
424 }
425
426 if (VK_NULL_HANDLE != fSurface) {
427 fDestroySurfaceKHR(fBackendContext->fInstance, fSurface, nullptr);
428 fSurface = VK_NULL_HANDLE;
429 }
430
431 fContext.reset();
432
433 fBackendContext.reset(nullptr);
434 }
435
getAvailableBackbuffer()436 VulkanWindowContext::BackbufferInfo* VulkanWindowContext::getAvailableBackbuffer() {
437 SkASSERT(fBackbuffers);
438
439 ++fCurrentBackbufferIndex;
440 if (fCurrentBackbufferIndex > fImageCount) {
441 fCurrentBackbufferIndex = 0;
442 }
443
444 BackbufferInfo* backbuffer = fBackbuffers + fCurrentBackbufferIndex;
445 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
446 WaitForFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences,
447 true, UINT64_MAX));
448 return backbuffer;
449 }
450
getBackbufferSurface()451 sk_sp<SkSurface> VulkanWindowContext::getBackbufferSurface() {
452 BackbufferInfo* backbuffer = this->getAvailableBackbuffer();
453 SkASSERT(backbuffer);
454
455 // reset the fence
456 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
457 ResetFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences));
458 // semaphores should be in unsignaled state
459
460 // acquire the image
461 VkResult res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
462 backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
463 &backbuffer->fImageIndex);
464 if (VK_ERROR_SURFACE_LOST_KHR == res) {
465 // need to figure out how to create a new vkSurface without the platformData*
466 // maybe use attach somehow? but need a Window
467 return nullptr;
468 }
469 if (VK_ERROR_OUT_OF_DATE_KHR == res) {
470 // tear swapchain down and try again
471 if (!this->createSwapchain(-1, -1, fDisplayParams)) {
472 return nullptr;
473 }
474 backbuffer = this->getAvailableBackbuffer();
475 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
476 ResetFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences));
477
478 // acquire the image
479 res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
480 backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
481 &backbuffer->fImageIndex);
482
483 if (VK_SUCCESS != res) {
484 return nullptr;
485 }
486 }
487
488 // set up layout transfer from initial to color attachment
489 VkImageLayout layout = fImageLayouts[backbuffer->fImageIndex];
490 SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED == layout || VK_IMAGE_LAYOUT_PRESENT_SRC_KHR == layout);
491 VkPipelineStageFlags srcStageMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
492 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT :
493 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
494 VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
495 VkAccessFlags srcAccessMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
496 0 : VK_ACCESS_MEMORY_READ_BIT;
497 VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
498
499 VkImageMemoryBarrier imageMemoryBarrier = {
500 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
501 NULL, // pNext
502 srcAccessMask, // outputMask
503 dstAccessMask, // inputMask
504 layout, // oldLayout
505 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
506 fPresentQueueIndex, // srcQueueFamilyIndex
507 fBackendContext->fGraphicsQueueIndex, // dstQueueFamilyIndex
508 fImages[backbuffer->fImageIndex], // image
509 { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
510 };
511 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
512 ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[0], 0));
513 VkCommandBufferBeginInfo info;
514 memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
515 info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
516 info.flags = 0;
517 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
518 BeginCommandBuffer(backbuffer->fTransitionCmdBuffers[0], &info));
519
520 GR_VK_CALL(fBackendContext->fInterface,
521 CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[0],
522 srcStageMask, dstStageMask, 0,
523 0, nullptr,
524 0, nullptr,
525 1, &imageMemoryBarrier));
526
527 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
528 EndCommandBuffer(backbuffer->fTransitionCmdBuffers[0]));
529
530 VkPipelineStageFlags waitDstStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
531 // insert the layout transfer into the queue and wait on the acquire
532 VkSubmitInfo submitInfo;
533 memset(&submitInfo, 0, sizeof(VkSubmitInfo));
534 submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
535 submitInfo.waitSemaphoreCount = 1;
536 submitInfo.pWaitSemaphores = &backbuffer->fAcquireSemaphore;
537 submitInfo.pWaitDstStageMask = &waitDstStageFlags;
538 submitInfo.commandBufferCount = 1;
539 submitInfo.pCommandBuffers = &backbuffer->fTransitionCmdBuffers[0];
540 submitInfo.signalSemaphoreCount = 0;
541
542 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
543 QueueSubmit(fBackendContext->fQueue, 1, &submitInfo,
544 backbuffer->fUsageFences[0]));
545
546 GrVkImageInfo* imageInfo;
547 SkSurface* surface = fSurfaces[backbuffer->fImageIndex].get();
548 surface->getRenderTargetHandle((GrBackendObject*)&imageInfo,
549 SkSurface::kFlushRead_BackendHandleAccess);
550 imageInfo->updateImageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
551
552 return sk_ref_sp(surface);
553 }
554
swapBuffers()555 void VulkanWindowContext::swapBuffers() {
556
557 BackbufferInfo* backbuffer = fBackbuffers + fCurrentBackbufferIndex;
558 GrVkImageInfo* imageInfo;
559 SkSurface* surface = fSurfaces[backbuffer->fImageIndex].get();
560 surface->getRenderTargetHandle((GrBackendObject*)&imageInfo,
561 SkSurface::kFlushRead_BackendHandleAccess);
562 // Check to make sure we never change the actually wrapped image
563 SkASSERT(imageInfo->fImage == fImages[backbuffer->fImageIndex]);
564
565 VkImageLayout layout = imageInfo->fImageLayout;
566 VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(layout);
567 VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
568 VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
569 VkAccessFlags dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
570
571 VkImageMemoryBarrier imageMemoryBarrier = {
572 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // sType
573 NULL, // pNext
574 srcAccessMask, // outputMask
575 dstAccessMask, // inputMask
576 layout, // oldLayout
577 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, // newLayout
578 fBackendContext->fGraphicsQueueIndex, // srcQueueFamilyIndex
579 fPresentQueueIndex, // dstQueueFamilyIndex
580 fImages[backbuffer->fImageIndex], // image
581 { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
582 };
583 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
584 ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[1], 0));
585 VkCommandBufferBeginInfo info;
586 memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
587 info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
588 info.flags = 0;
589 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
590 BeginCommandBuffer(backbuffer->fTransitionCmdBuffers[1], &info));
591 GR_VK_CALL(fBackendContext->fInterface,
592 CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[1],
593 srcStageMask, dstStageMask, 0,
594 0, nullptr,
595 0, nullptr,
596 1, &imageMemoryBarrier));
597 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
598 EndCommandBuffer(backbuffer->fTransitionCmdBuffers[1]));
599
600 fImageLayouts[backbuffer->fImageIndex] = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
601
602 // insert the layout transfer into the queue and wait on the acquire
603 VkSubmitInfo submitInfo;
604 memset(&submitInfo, 0, sizeof(VkSubmitInfo));
605 submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
606 submitInfo.waitSemaphoreCount = 0;
607 submitInfo.pWaitDstStageMask = 0;
608 submitInfo.commandBufferCount = 1;
609 submitInfo.pCommandBuffers = &backbuffer->fTransitionCmdBuffers[1];
610 submitInfo.signalSemaphoreCount = 1;
611 submitInfo.pSignalSemaphores = &backbuffer->fRenderSemaphore;
612
613 GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
614 QueueSubmit(fBackendContext->fQueue, 1, &submitInfo,
615 backbuffer->fUsageFences[1]));
616
617 // Submit present operation to present queue
618 const VkPresentInfoKHR presentInfo =
619 {
620 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // sType
621 NULL, // pNext
622 1, // waitSemaphoreCount
623 &backbuffer->fRenderSemaphore, // pWaitSemaphores
624 1, // swapchainCount
625 &fSwapchain, // pSwapchains
626 &backbuffer->fImageIndex, // pImageIndices
627 NULL // pResults
628 };
629
630 fQueuePresentKHR(fPresentQueue, &presentInfo);
631 }
632
633 } //namespace sk_app
634