1 /* 2 * Copyright 2015 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 9 #ifndef GrVkRenderTarget_DEFINED 10 #define GrVkRenderTarget_DEFINED 11 12 #include "src/gpu/GrRenderTarget.h" 13 #include "src/gpu/vk/GrVkImage.h" 14 15 #include "include/gpu/vk/GrVkTypes.h" 16 #include "src/gpu/vk/GrVkRenderPass.h" 17 #include "src/gpu/vk/GrVkResourceProvider.h" 18 19 class GrVkCommandBuffer; 20 class GrVkFramebuffer; 21 class GrVkGpu; 22 class GrVkImageView; 23 class GrVkSecondaryCommandBuffer; 24 class GrVkStencilAttachment; 25 26 struct GrVkImageInfo; 27 28 #ifdef SK_BUILD_FOR_WIN 29 // Windows gives bogus warnings about inheriting asTexture/asRenderTarget via dominance. 30 #pragma warning(push) 31 #pragma warning(disable: 4250) 32 #endif 33 34 class GrVkRenderTarget: public GrRenderTarget, public virtual GrVkImage { 35 public: 36 static sk_sp<GrVkRenderTarget> MakeWrappedRenderTarget(GrVkGpu*, const GrSurfaceDesc&, 37 int sampleCnt, const GrVkImageInfo&, 38 sk_sp<GrVkImageLayout>); 39 40 static sk_sp<GrVkRenderTarget> MakeSecondaryCBRenderTarget(GrVkGpu*, const GrSurfaceDesc&, 41 const GrVkDrawableInfo& vkInfo); 42 43 ~GrVkRenderTarget() override; 44 backendFormat()45 GrBackendFormat backendFormat() const override { return this->getBackendFormat(); } 46 framebuffer()47 const GrVkFramebuffer* framebuffer() const { return fFramebuffer; } colorAttachmentView()48 const GrVkImageView* colorAttachmentView() const { return fColorAttachmentView; } msaaImageResource()49 const GrVkResource* msaaImageResource() const { 50 if (fMSAAImage) { 51 return fMSAAImage->fResource; 52 } 53 return nullptr; 54 } msaaImage()55 GrVkImage* msaaImage() { return fMSAAImage.get(); } resolveAttachmentView()56 const GrVkImageView* resolveAttachmentView() const { return fResolveAttachmentView; } 57 const GrVkResource* stencilImageResource() const; 58 const GrVkImageView* stencilAttachmentView() const; 59 simpleRenderPass()60 const GrVkRenderPass* simpleRenderPass() const { return fCachedSimpleRenderPass; } compatibleRenderPassHandle()61 GrVkResourceProvider::CompatibleRPHandle compatibleRenderPassHandle() const { 62 SkASSERT(!this->wrapsSecondaryCommandBuffer()); 63 return fCompatibleRPHandle; 64 } externalRenderPass()65 const GrVkRenderPass* externalRenderPass() const { 66 SkASSERT(this->wrapsSecondaryCommandBuffer()); 67 // We use the cached simple render pass to hold the external render pass. 68 return fCachedSimpleRenderPass; 69 } 70 wrapsSecondaryCommandBuffer()71 bool wrapsSecondaryCommandBuffer() const { return fSecondaryCommandBuffer != VK_NULL_HANDLE; } getExternalSecondaryCommandBuffer()72 VkCommandBuffer getExternalSecondaryCommandBuffer() const { 73 return fSecondaryCommandBuffer; 74 } 75 canAttemptStencilAttachment()76 bool canAttemptStencilAttachment() const override { 77 // We don't know the status of the stencil attachment for wrapped external secondary command 78 // buffers so we just assume we don't have one. 79 return !this->wrapsSecondaryCommandBuffer(); 80 } 81 82 GrBackendRenderTarget getBackendRenderTarget() const override; 83 84 void getAttachmentsDescriptor(GrVkRenderPass::AttachmentsDescriptor* desc, 85 GrVkRenderPass::AttachmentFlags* flags) const; 86 87 void addResources(GrVkCommandBuffer& commandBuffer) const; 88 89 protected: 90 GrVkRenderTarget(GrVkGpu* gpu, 91 const GrSurfaceDesc& desc, 92 int sampleCnt, 93 const GrVkImageInfo& info, 94 sk_sp<GrVkImageLayout> layout, 95 const GrVkImageInfo& msaaInfo, 96 sk_sp<GrVkImageLayout> msaaLayout, 97 const GrVkImageView* colorAttachmentView, 98 const GrVkImageView* resolveAttachmentView, 99 GrBackendObjectOwnership); 100 101 GrVkRenderTarget(GrVkGpu* gpu, 102 const GrSurfaceDesc& desc, 103 const GrVkImageInfo& info, 104 sk_sp<GrVkImageLayout> layout, 105 const GrVkImageView* colorAttachmentView, 106 GrBackendObjectOwnership); 107 108 GrVkGpu* getVkGpu() const; 109 110 void onAbandon() override; 111 void onRelease() override; 112 113 // This accounts for the texture's memory and any MSAA renderbuffer's memory. onGpuMemorySize()114 size_t onGpuMemorySize() const override { 115 int numColorSamples = this->numSamples(); 116 if (numColorSamples > 1) { 117 // Add one to account for the resolved VkImage. 118 numColorSamples += 1; 119 } 120 const GrCaps& caps = *this->getGpu()->caps(); 121 return GrSurface::ComputeSize(caps, this->backendFormat(), this->width(), this->height(), 122 numColorSamples, GrMipMapped::kNo); 123 } 124 125 void createFramebuffer(GrVkGpu* gpu); 126 127 const GrVkImageView* fColorAttachmentView; 128 std::unique_ptr<GrVkImage> fMSAAImage; 129 const GrVkImageView* fResolveAttachmentView; 130 131 private: 132 GrVkRenderTarget(GrVkGpu* gpu, 133 const GrSurfaceDesc& desc, 134 int sampleCnt, 135 const GrVkImageInfo& info, 136 sk_sp<GrVkImageLayout> layout, 137 const GrVkImageInfo& msaaInfo, 138 sk_sp<GrVkImageLayout> msaaLayout, 139 const GrVkImageView* colorAttachmentView, 140 const GrVkImageView* resolveAttachmentView); 141 142 GrVkRenderTarget(GrVkGpu* gpu, 143 const GrSurfaceDesc& desc, 144 const GrVkImageInfo& info, 145 sk_sp<GrVkImageLayout> layout, 146 const GrVkImageView* colorAttachmentView); 147 148 149 GrVkRenderTarget(GrVkGpu* gpu, 150 const GrSurfaceDesc& desc, 151 const GrVkImageInfo& info, 152 sk_sp<GrVkImageLayout> layout, 153 const GrVkRenderPass* renderPass, 154 VkCommandBuffer secondaryCommandBuffer); 155 156 bool completeStencilAttachment() override; 157 158 // In Vulkan we call the release proc after we are finished with the underlying 159 // GrVkImage::Resource object (which occurs after the GPU has finished all work on it). onSetRelease(sk_sp<GrRefCntedCallback> releaseHelper)160 void onSetRelease(sk_sp<GrRefCntedCallback> releaseHelper) override { 161 // Forward the release proc on to GrVkImage 162 this->setResourceRelease(std::move(releaseHelper)); 163 } 164 165 void releaseInternalObjects(); 166 void abandonInternalObjects(); 167 168 const GrVkFramebuffer* fFramebuffer; 169 170 // This is a cached pointer to a simple render pass. The render target should unref it 171 // once it is done with it. 172 const GrVkRenderPass* fCachedSimpleRenderPass; 173 // This is a handle to be used to quickly get compatible GrVkRenderPasses for this render target 174 GrVkResourceProvider::CompatibleRPHandle fCompatibleRPHandle; 175 176 // If this render target wraps an external VkCommandBuffer, then this handle will be that 177 // VkCommandBuffer and not VK_NULL_HANDLE. In this case the render target will not be backed by 178 // an actual VkImage and will thus be limited in terms of what it can be used for. 179 VkCommandBuffer fSecondaryCommandBuffer = VK_NULL_HANDLE; 180 }; 181 182 #endif 183