| /* |
| * Copyright 2023 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/graphite/vk/VulkanRenderPass.h" |
| |
| #include "include/gpu/graphite/vk/VulkanGraphiteTypes.h" |
| #include "src/gpu/graphite/RenderPassDesc.h" |
| #include "src/gpu/graphite/Texture.h" |
| #include "src/gpu/graphite/vk/VulkanCommandBuffer.h" |
| #include "src/gpu/graphite/vk/VulkanGraphiteUtils.h" |
| #include "src/gpu/graphite/vk/VulkanSharedContext.h" |
| #include "src/gpu/graphite/vk/VulkanTexture.h" |
| |
| #include <limits> |
| |
| static constexpr uint32_t kColorFormatOffset = 0; |
| static constexpr uint32_t kDepthStencilFormatOffset = kColorFormatOffset + 8; |
| static constexpr uint32_t kSampleCountOffset = kDepthStencilFormatOffset + 8; |
| static constexpr uint32_t kColorLoadOpOffset = kSampleCountOffset + 5; |
| static constexpr uint32_t kColorStoreOpOffset = kColorLoadOpOffset + 2; |
| static constexpr uint32_t kResolveLoadOpOffset = kColorStoreOpOffset + 1; |
| static constexpr uint32_t kResolveStoreOpOffset = kResolveLoadOpOffset + 2; |
| static constexpr uint32_t kMSRTTOffset = kResolveStoreOpOffset + 1; |
| |
| static constexpr uint32_t kFormatMask = 0xFF; |
| static constexpr uint32_t kSampleCountMask = 0x1F; |
| static constexpr uint32_t kLoadOpMask = 0x3; |
| static constexpr uint32_t kStoreOpMask = 0x1; |
| static constexpr uint32_t kMSRTTMask = 0x1; |
| |
| namespace skgpu::graphite { |
| |
| uint32_t VulkanRenderPass::GetRenderPassKey(const RenderPassDesc& originalRenderPassDesc, |
| bool compatibleForPipelineKey) { |
| const RenderPassDesc renderPassDesc = |
| compatibleForPipelineKey ? MakePipelineCompatibleRenderPass(originalRenderPassDesc) |
| : originalRenderPassDesc; |
| const AttachmentDesc color = renderPassDesc.fColorAttachment; |
| const AttachmentDesc resolve = renderPassDesc.fColorResolveAttachment; |
| const AttachmentDesc depthStencil = renderPassDesc.fDepthStencilAttachment; |
| |
| const bool hasResolveAttachment = resolve.fFormat != TextureFormat::kUnsupported; |
| const bool isMultisampledRenderToSingleSampled = |
| RenderPassDescWillImplicitlyLoadMSAA(renderPassDesc); |
| // Silence warning about unused variable in release builds. |
| (void)hasResolveAttachment; |
| |
| // Current assumptions in the render pass desc, allowing us to create a smaller key: |
| SkASSERT(color.fFormat != TextureFormat::kUnsupported); |
| SkASSERT(!hasResolveAttachment || resolve.fFormat == color.fFormat); |
| SkASSERT(depthStencil.fFormat == TextureFormat::kUnsupported || |
| depthStencil.fSampleCount == color.fSampleCount); |
| SkASSERT(depthStencil.fFormat == TextureFormat::kUnsupported || |
| depthStencil.fLoadOp == LoadOp::kClear); |
| SkASSERT(depthStencil.fFormat == TextureFormat::kUnsupported || |
| depthStencil.fStoreOp == StoreOp::kDiscard); |
| SkASSERT(!hasResolveAttachment || resolve.fSampleCount == 1); |
| SkASSERT(color.fSampleCount == renderPassDesc.fSampleCount || |
| isMultisampledRenderToSingleSampled); |
| SkASSERT(!hasResolveAttachment || color.fLoadOp == LoadOp::kDiscard || |
| color.fLoadOp == LoadOp::kClear); |
| SkASSERT(!hasResolveAttachment || resolve.fLoadOp == LoadOp::kDiscard || |
| resolve.fLoadOp == LoadOp::kLoad); |
| SkASSERT(!hasResolveAttachment || color.fStoreOp == StoreOp::kDiscard); |
| |
| // The following information uniquely defines the render pass: |
| // |
| // Color format (CF): TextureFormat, fits in 6 bits |
| // Depth/stencil format (DSF): TextureFormat, fits in 6 bits |
| // Sample count (M): Up to 16, fits in 5 bit |
| // Color load op (L): LoadOp, fits in 2 bits |
| // Color store op (S): StoreOp, fits in 1 bit |
| // Whether multisampled data s loaded from resolve attachment: fits in 1 bit |
| // Whether rendering multisampled->single-sampled (MSRTSS): fits in 1 bit |
| // |
| // Note that technically, renderable color formats can fit in 5 bits and depth/stencil formats |
| // in 3 bits if more packing is needed. Sample count can also be `log()`'ed to reduce the bit |
| // count. |
| // |
| // Depth/stencil load op is always kClear, and store op is always kDiscard. |
| // Color load op is either found in fColorAttachment if no resolve attachment, or can be derived |
| // from a combination of the load ops specified in the color and resolve attachments: |
| // * If color attachment is kClear, load op is kClear |
| // * Otherwise, if resolve attachment is kLoad, load op is kLoad |
| // * Otherwise, it's kDiscard |
| // Color store op is either found in fColorAttachment if no resolve attachment, or it's found in |
| // fColorResolveAttachment. |
| // |
| // There are currently lots of free bits, so with regards to load/store ops, we don't try too |
| // hard to pack things. Including the color and resolve's load and store ops obviates the need |
| // to store a "load MSAA from resolve" bit. The format of the key is thus: |
| // |
| // LSB MSB |
| // +----+-----+---+---+---+------------+------------+--------+---+ |
| // | CF | DSF | M | L | S | L(resolve) | S(resolve) | MSRTSS | 0 | |
| // +----+-----+---+---+---+------------+------------+--------+---+ |
| // bits 8 8 5 2 1 2 1 1 4 |
| // |
| SkASSERT(renderPassDesc.fSampleCount < (1 << 5)); |
| static_assert(static_cast<uint32_t>(TextureFormat::kLast) < (1 << 8)); |
| static_assert(static_cast<uint32_t>(LoadOp::kLast) < (1 << 2)); |
| static_assert(static_cast<uint32_t>(StoreOp::kLast) < (1 << 1)); |
| |
| const uint32_t key = |
| (static_cast<uint32_t>(color.fFormat) << kColorFormatOffset) | |
| (static_cast<uint32_t>(depthStencil.fFormat) << kDepthStencilFormatOffset) | |
| (static_cast<uint32_t>(renderPassDesc.fSampleCount) << kSampleCountOffset) | |
| (static_cast<uint32_t>(color.fLoadOp) << kColorLoadOpOffset) | |
| (static_cast<uint32_t>(color.fStoreOp) << kColorStoreOpOffset) | |
| (static_cast<uint32_t>(resolve.fLoadOp) << kResolveLoadOpOffset) | |
| (static_cast<uint32_t>(resolve.fStoreOp) << kResolveStoreOpOffset) | |
| (static_cast<uint32_t>(isMultisampledRenderToSingleSampled) << kMSRTTOffset); |
| |
| return key; |
| } |
| |
| void VulkanRenderPass::ExtractRenderPassDesc(uint32_t key, |
| Swizzle writeSwizzle, |
| DstReadStrategy dstReadStrategy, |
| RenderPassDesc* renderPassDesc) { |
| // See comment in GetRenderPassKey() describing the format of the key. |
| const TextureFormat colorFormat = |
| SkTo<TextureFormat>((key >> kColorFormatOffset) & kFormatMask); |
| const TextureFormat depthStencilFormat = |
| SkTo<TextureFormat>((key >> kDepthStencilFormatOffset) & kFormatMask); |
| const uint8_t sampleCount = SkTo<uint8_t>((key >> kSampleCountOffset) & kSampleCountMask); |
| const LoadOp colorLoadOp = SkTo<LoadOp>((key >> kColorLoadOpOffset) & kLoadOpMask); |
| const StoreOp colorStoreOp = SkTo<StoreOp>((key >> kColorStoreOpOffset) & kStoreOpMask); |
| const LoadOp resolveLoadOp = SkTo<LoadOp>((key >> kResolveLoadOpOffset) & kLoadOpMask); |
| const StoreOp resolveStoreOp = SkTo<StoreOp>((key >> kResolveStoreOpOffset) & kStoreOpMask); |
| const bool isMultisampledRenderToSingleSampled = SkTo<bool>((key >> kMSRTTOffset) & kMSRTTMask); |
| |
| // Relationship between render pass sample count, attachment's sample counts and resolve |
| // attachments: |
| // |
| // | RP Samples == 1 | RP Samples > 1 && MSRTSS | RP Samples > 1 && !MSRTSS | |
| // +-----------------+--------------------------+---------------------------+ |
| // Has Resolve? | No | No | Yes | |
| // +-----------------+--------------------------+---------------------------+ |
| // Resolve Format | Unsupported | Unsupported | Color Format | |
| // +-----------------+--------------------------+---------------------------+ |
| // Color Samples | RP Samples (1) | 1 | RP Samples | |
| // +-----------------+--------------------------+---------------------------+ |
| // D/S Samples | RP Samples (1) | 1 | RP Samples | |
| // +-----------------+--------------------------+---------------------------+ |
| // |
| // The color and resolve attachment's load/store op are already stored in the key. For |
| // depth/stencil, load op is always Clear and store op is always Discard. |
| const uint8_t attachmentSamples = isMultisampledRenderToSingleSampled ? 1 : sampleCount; |
| |
| *renderPassDesc = {}; |
| renderPassDesc->fColorAttachment = {colorFormat, colorLoadOp, colorStoreOp, attachmentSamples}; |
| renderPassDesc->fDepthStencilAttachment = { |
| depthStencilFormat, LoadOp::kClear, StoreOp::kDiscard, attachmentSamples}; |
| if (attachmentSamples > 1 && !isMultisampledRenderToSingleSampled) { |
| renderPassDesc->fColorResolveAttachment = {colorFormat, |
| resolveLoadOp, |
| resolveStoreOp, |
| /*fSampleCount=*/1}; |
| } |
| renderPassDesc->fSampleCount = sampleCount; |
| renderPassDesc->fWriteSwizzle = writeSwizzle; |
| renderPassDesc->fDstReadStrategy = dstReadStrategy; |
| } |
| |
| namespace { |
| |
| template <typename AttachmentDescription> |
| void setup_vk_attachment_description(AttachmentDescription* outAttachment, |
| const AttachmentDesc& desc, |
| const AttachmentDescription& defaultAttachmentDescription, |
| bool isColor) { |
| static_assert((int) LoadOp::kLoad == (int) VK_ATTACHMENT_LOAD_OP_LOAD); |
| static_assert((int) LoadOp::kClear == (int) VK_ATTACHMENT_LOAD_OP_CLEAR); |
| static_assert((int) LoadOp::kDiscard == (int) VK_ATTACHMENT_LOAD_OP_DONT_CARE); |
| static_assert((int) StoreOp::kStore == (int) VK_ATTACHMENT_STORE_OP_STORE); |
| static_assert((int) StoreOp::kDiscard == (int) VK_ATTACHMENT_STORE_OP_DONT_CARE); |
| |
| VkAttachmentLoadOp vkLoadOp = static_cast<VkAttachmentLoadOp>(desc.fLoadOp); |
| VkAttachmentStoreOp vkStoreOp = static_cast<VkAttachmentStoreOp>(desc.fStoreOp); |
| |
| *outAttachment = defaultAttachmentDescription; |
| outAttachment->format = TextureFormatToVkFormat(desc.fFormat); |
| VkSampleCountFlagBits sampleCount; |
| SkAssertResult(SampleCountToVkSampleCount(desc.fSampleCount, &sampleCount)); |
| outAttachment->samples = sampleCount; |
| |
| outAttachment->loadOp = vkLoadOp; |
| outAttachment->storeOp = vkStoreOp; |
| if (isColor) { |
| outAttachment->initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| outAttachment->finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| outAttachment->stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; |
| outAttachment->stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; |
| } else { |
| outAttachment->initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; |
| outAttachment->finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; |
| outAttachment->stencilLoadOp = vkLoadOp; |
| outAttachment->stencilStoreOp = vkStoreOp; |
| } |
| } |
| |
| template <typename AttachmentDescription, typename AttachmentReference> |
| void populate_attachment_refs(const RenderPassDesc& renderPassDesc, |
| bool needLoadMSAAFromResolveSubpass, |
| skia_private::TArray<AttachmentDescription>& descs, |
| AttachmentReference& colorRef, |
| AttachmentReference& resolveRef, |
| AttachmentReference& resolveLoadInputRef, |
| AttachmentReference& depthStencilRef, |
| const AttachmentDescription& defaultAttachmentDescription) { |
| // Note: See assumptions regarding RenderPassDesc structure in AddToKey(). |
| const AttachmentDesc color = renderPassDesc.fColorAttachment; |
| const AttachmentDesc resolve = renderPassDesc.fColorResolveAttachment; |
| const AttachmentDesc depthStencil = renderPassDesc.fDepthStencilAttachment; |
| SkASSERT(color.fFormat != TextureFormat::kUnsupported); |
| // If MSAA data needs to be loaded from the resolve attachment, there must be a resolve |
| // attachment! |
| SkASSERT(!needLoadMSAAFromResolveSubpass || resolve.fFormat != TextureFormat::kUnsupported); |
| |
| // If reading from the dst as an input attachment, we must use VK_IMAGE_LAYOUT_GENERAL |
| // for the color attachment description. Use a general image layout for all renderpasses to |
| // support this. |
| // |
| // As long as the initial/final layouts are VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, the |
| // choice of the VK_IMAGE_LAYOUT_GENERAL for the subpass layout is efficient; the few GPUs |
| // that treat VK_IMAGE_LAYOUT_GENERAL differently recognize this pattern and keep the |
| // internal layout optimal. |
| colorRef.layout = VK_IMAGE_LAYOUT_GENERAL; |
| colorRef.attachment = descs.size(); |
| AttachmentDescription& vkColorAttachDesc = descs.push_back(); |
| setup_vk_attachment_description(&vkColorAttachDesc, |
| color, |
| defaultAttachmentDescription, |
| /*isColor=*/true); |
| |
| if (resolve.fFormat != TextureFormat::kUnsupported) { |
| resolveRef.attachment = descs.size(); |
| resolveRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| if (needLoadMSAAFromResolveSubpass) { |
| resolveLoadInputRef.attachment = resolveRef.attachment; |
| // The resolve attachment is used as input attachment in the first subpass. In that |
| // subpass, it is only read from so the layout could have been read-only. To avoid |
| // special-casing this input attachment though, the VK_IMAGE_LAYOUT_GENERAL layout |
| // is used like with the color attachment. This is no less efficient than the |
| // read-only layout when specified on the attachment ref. |
| resolveLoadInputRef.layout = VK_IMAGE_LAYOUT_GENERAL; |
| } else { |
| resolveLoadInputRef.attachment = VK_ATTACHMENT_UNUSED; |
| } |
| |
| AttachmentDescription& vkResolveAttachDesc = descs.push_back(); |
| setup_vk_attachment_description(&vkResolveAttachDesc, |
| resolve, |
| defaultAttachmentDescription, |
| /*isColor=*/true); |
| } else { |
| resolveRef.attachment = resolveLoadInputRef.attachment = VK_ATTACHMENT_UNUSED; |
| } |
| |
| if (depthStencil.fFormat != TextureFormat::kUnsupported) { |
| depthStencilRef.attachment = descs.size(); |
| depthStencilRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; |
| |
| AttachmentDescription& vkDepthStencilAttachDesc = descs.push_back(); |
| setup_vk_attachment_description(&vkDepthStencilAttachDesc, |
| depthStencil, |
| defaultAttachmentDescription, |
| /*isColor=*/false); |
| } else { |
| depthStencilRef.attachment = VK_ATTACHMENT_UNUSED; |
| } |
| } |
| |
| template <typename SubpassDependency, typename SubpassDependencyArray> |
| void populate_subpass_dependencies(const VulkanSharedContext* context, |
| SubpassDependencyArray& deps, |
| bool needLoadMSAAFromResolveSubpass, |
| const SubpassDependency& defaultSubpassDependency) { |
| const int mainSubpassIdx = needLoadMSAAFromResolveSubpass ? 1 : 0; |
| |
| // Adding a single subpass self-dependency for color attachments is basically free, so apply |
| // one to every RenderPass which has an input attachment on the main subpass. This is useful |
| // because it means that as we perform draw calls, if we encounter a draw that uses a blend |
| // operation requiring a dst read, we can avoid having to switch RenderPasses. |
| |
| const bool hasRasterizationOrderColorAttachmentAccess = |
| context->vulkanCaps().supportsRasterizationOrderColorAttachmentAccess(); |
| const bool hasNonCoherentAdvancedBlend = context->vulkanCaps().blendEquationSupport() == |
| Caps::BlendEquationSupport::kAdvancedNoncoherent; |
| |
| if (!hasRasterizationOrderColorAttachmentAccess || hasNonCoherentAdvancedBlend) { |
| SubpassDependency& selfDependency = deps.push_back(); |
| selfDependency = defaultSubpassDependency; |
| selfDependency.srcSubpass = mainSubpassIdx; |
| selfDependency.dstSubpass = mainSubpassIdx; |
| selfDependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; |
| selfDependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; |
| selfDependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; |
| selfDependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; |
| selfDependency.dstAccessMask = 0; |
| |
| if (!hasRasterizationOrderColorAttachmentAccess) { |
| selfDependency.dstStageMask |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; |
| selfDependency.dstAccessMask |= VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; |
| } |
| if (hasNonCoherentAdvancedBlend) { |
| selfDependency.dstAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT; |
| } |
| } |
| |
| // If loading MSAA from resolve, enforce that subpass goes first with a subpass dependency. |
| if (needLoadMSAAFromResolveSubpass) { |
| SubpassDependency& dependency = deps.push_back(); |
| dependency = defaultSubpassDependency; |
| dependency.srcSubpass = 0; |
| dependency.dstSubpass = mainSubpassIdx; |
| dependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT; |
| dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; |
| dependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; |
| dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; |
| dependency.dstAccessMask = |
| VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; |
| } |
| } |
| |
| template <typename SubpassDescription, typename AttachmentReference> |
| void populate_main_subpass_desc(const VulkanCaps& caps, |
| SubpassDescription& mainSubpassDesc, |
| const AttachmentReference& colorRef, |
| const AttachmentReference& resolveRef, |
| const AttachmentReference& depthStencilRef) { |
| mainSubpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; |
| // In the main subpass, the input attachment is the color attachment. We could have excluded |
| // this attachment if unused, but always assigning it to be the color attachment even when |
| // unused allows for compatible-only renderpasses to be shared for pipelines that do read from |
| // the dst and those that do not. |
| mainSubpassDesc.inputAttachmentCount = 1; |
| mainSubpassDesc.pInputAttachments = &colorRef; |
| mainSubpassDesc.colorAttachmentCount = 1; |
| mainSubpassDesc.pColorAttachments = &colorRef; |
| mainSubpassDesc.pResolveAttachments = &resolveRef; |
| mainSubpassDesc.pDepthStencilAttachment = &depthStencilRef; |
| } |
| |
| void populate_subpass_descs(const VulkanCaps& caps, |
| skia_private::TArray<VkSubpassDescription>& descs, |
| const VkAttachmentReference& colorRef, |
| const VkAttachmentReference& resolveRef, |
| const VkAttachmentReference& resolveLoadInputRef, |
| const VkAttachmentReference& depthStencilRef) { |
| // If loading MSAA from resolve, add the additional subpass to do so. |
| if (resolveLoadInputRef.attachment != VK_ATTACHMENT_UNUSED) { |
| VkSubpassDescription& loadSubpassDesc = descs.push_back(); |
| loadSubpassDesc = {}; |
| loadSubpassDesc.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; |
| loadSubpassDesc.inputAttachmentCount = 1; |
| loadSubpassDesc.pInputAttachments = &resolveLoadInputRef; |
| loadSubpassDesc.colorAttachmentCount = 1; |
| loadSubpassDesc.pColorAttachments = &colorRef; |
| } |
| |
| VkSubpassDescription& mainSubpassDesc = descs.push_back(); |
| mainSubpassDesc = {}; |
| populate_main_subpass_desc(caps, mainSubpassDesc, colorRef, resolveRef, depthStencilRef); |
| |
| if (caps.supportsRasterizationOrderColorAttachmentAccess()) { |
| for (VkSubpassDescription& desc : descs) { |
| desc.flags = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT; |
| } |
| } |
| } |
| |
| } // anonymous namespace |
| |
| sk_sp<VulkanRenderPass> VulkanRenderPass::Make(const VulkanSharedContext* context, |
| const RenderPassDesc& renderPassDesc) { |
| const bool needLoadMSAAFromResolveSubpass = |
| RenderPassDescWillLoadMSAAFromResolve(renderPassDesc); |
| const bool isMultisampledRenderToSingleSampled = |
| RenderPassDescWillImplicitlyLoadMSAA(renderPassDesc); |
| |
| VkResult result; |
| VkRenderPass renderPass = VK_NULL_HANDLE; |
| |
| // VK_EXT_multisampled_render_to_single_sampled usage requires vkCreateRenderPass2. |
| if (isMultisampledRenderToSingleSampled) { |
| // Set up attachment descriptions + references. Declare them before having a helper populate |
| // their values so we can reference them later during RP creation. |
| SkASSERT(renderPassDesc.fColorResolveAttachment.fFormat == TextureFormat::kUnsupported); |
| SkASSERT(!needLoadMSAAFromResolveSubpass); |
| |
| VkAttachmentDescription2 defaultAttachmentDescription = {}; |
| defaultAttachmentDescription.sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2; |
| |
| VkAttachmentReference2 defaultAttachmentReference = {}; |
| defaultAttachmentReference.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2; |
| defaultAttachmentReference.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| |
| skia_private::TArray<VkAttachmentDescription2> attachmentDescs; |
| VkAttachmentReference2 colorRef = defaultAttachmentReference; |
| VkAttachmentReference2 resolveRef = defaultAttachmentReference; |
| VkAttachmentReference2 resolveLoadInputRef = defaultAttachmentReference; |
| VkAttachmentReference2 depthStencilRef = defaultAttachmentReference; |
| depthStencilRef.aspectMask = |
| GetVkImageAspectFlags(renderPassDesc.fDepthStencilAttachment.fFormat); |
| |
| populate_attachment_refs(renderPassDesc, |
| /*needLoadMSAAFromResolveSubpass=*/false, |
| attachmentDescs, |
| colorRef, |
| resolveRef, |
| resolveLoadInputRef, |
| depthStencilRef, |
| defaultAttachmentDescription); |
| SkASSERT(resolveLoadInputRef.attachment == VK_ATTACHMENT_UNUSED); |
| |
| // Assemble subpass information before creating the renderpass. Each renderpass has at least |
| // one subpass dependency (self-dependency for reading the dst texture). |
| VkSubpassDescription2 mainSubpassDesc = {}; |
| mainSubpassDesc.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2; |
| populate_main_subpass_desc( |
| context->vulkanCaps(), mainSubpassDesc, colorRef, resolveRef, depthStencilRef); |
| |
| // Enable multisampled render to single-sampled with the render pass's sample count. |
| VkMultisampledRenderToSingleSampledInfoEXT msrtss = {}; |
| msrtss.sType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; |
| msrtss.multisampledRenderToSingleSampledEnable = VK_TRUE; |
| SampleCountToVkSampleCount(renderPassDesc.fSampleCount, &msrtss.rasterizationSamples); |
| AddToPNextChain(&mainSubpassDesc, &msrtss); |
| |
| // Depth/stencil resolve needs additional configuration (even though Graphite always |
| // discards depth/stencil). |
| SkASSERT(renderPassDesc.fDepthStencilAttachment.fStoreOp == StoreOp::kDiscard); |
| VkSubpassDescriptionDepthStencilResolve dsResolve = {}; |
| dsResolve.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; |
| dsResolve.depthResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT; |
| dsResolve.stencilResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT; |
| AddToPNextChain(&mainSubpassDesc, &dsResolve); |
| |
| VkSubpassDependency2 defaultSubpassDependency = {}; |
| defaultSubpassDependency.sType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2; |
| |
| skia_private::STArray<1, VkSubpassDependency2> dependencies; |
| populate_subpass_dependencies(context, |
| dependencies, |
| /*needLoadMSAAFromResolveSubpass=*/false, |
| defaultSubpassDependency); |
| |
| // Create VkRenderPass |
| VkRenderPassCreateInfo2 renderPassInfo = {}; |
| renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2; |
| renderPassInfo.subpassCount = 1; |
| renderPassInfo.pSubpasses = &mainSubpassDesc; |
| renderPassInfo.dependencyCount = dependencies.size(); |
| renderPassInfo.pDependencies = dependencies.data(); |
| renderPassInfo.attachmentCount = attachmentDescs.size(); |
| renderPassInfo.pAttachments = attachmentDescs.data(); |
| |
| VULKAN_CALL_RESULT( |
| context, |
| result, |
| CreateRenderPass2(context->device(), &renderPassInfo, nullptr, &renderPass)); |
| } else { |
| // Same thing as above, but using Vulkan 1.0 render pass API. Practically every usable |
| // driver supports VK_KHR_create_renderpass2, but that is not yet a minimum requirement of |
| // Graphite. |
| skia_private::TArray<VkAttachmentDescription> attachmentDescs; |
| VkAttachmentReference colorRef = {}; |
| VkAttachmentReference resolveRef = {}; |
| VkAttachmentReference resolveLoadInputRef = {}; |
| VkAttachmentReference depthStencilRef = {}; |
| populate_attachment_refs(renderPassDesc, |
| needLoadMSAAFromResolveSubpass, |
| attachmentDescs, |
| colorRef, |
| resolveRef, |
| resolveLoadInputRef, |
| depthStencilRef, |
| /*defaultAttachmentDescription=*/{}); |
| |
| // If loading MSAA from resolve, an extra subpass and an additional dependency is needed. |
| skia_private::STArray<2, VkSubpassDescription> subpassDescs; |
| populate_subpass_descs(context->vulkanCaps(), |
| subpassDescs, |
| colorRef, |
| resolveRef, |
| resolveLoadInputRef, |
| depthStencilRef); |
| skia_private::STArray<2, VkSubpassDependency> dependencies; |
| populate_subpass_dependencies(context, |
| dependencies, |
| needLoadMSAAFromResolveSubpass, |
| /*defaultSubpassDependency=*/VkSubpassDependency{}); |
| |
| // Create VkRenderPass |
| VkRenderPassCreateInfo renderPassInfo = {}; |
| renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; |
| renderPassInfo.subpassCount = subpassDescs.size(); |
| renderPassInfo.pSubpasses = subpassDescs.begin(); |
| renderPassInfo.dependencyCount = dependencies.size(); |
| renderPassInfo.pDependencies = dependencies.data(); |
| renderPassInfo.attachmentCount = attachmentDescs.size(); |
| renderPassInfo.pAttachments = attachmentDescs.data(); |
| |
| VULKAN_CALL_RESULT( |
| context, |
| result, |
| CreateRenderPass(context->device(), &renderPassInfo, nullptr, &renderPass)); |
| } |
| |
| if (result != VK_SUCCESS) { |
| return nullptr; |
| } |
| VkExtent2D granularity; |
| VULKAN_CALL(context->interface(), GetRenderAreaGranularity(context->device(), |
| renderPass, |
| &granularity)); |
| return sk_sp<VulkanRenderPass>(new VulkanRenderPass(context, renderPass, granularity)); |
| } |
| |
| VulkanRenderPass::VulkanRenderPass(const VulkanSharedContext* context, |
| VkRenderPass renderPass, |
| VkExtent2D granularity) |
| : Resource(context, |
| Ownership::kOwned, |
| /*gpuMemorySize=*/0) |
| , fSharedContext(context) |
| , fRenderPass(renderPass) |
| , fGranularity(granularity) {} |
| |
| void VulkanRenderPass::freeGpuData() { |
| VULKAN_CALL(fSharedContext->interface(), |
| DestroyRenderPass(fSharedContext->device(), fRenderPass, nullptr)); |
| } |
| |
| } // namespace skgpu::graphite |
