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