Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(25)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: src/gpu/vk/GrVkCommandBuffer.cpp

Issue 2019723002: Subclass GrVkCommandBuffer into Primary and Secondary CommandBuffers. (Closed) Base URL: https://skia.googlesource.com/skia.git@renderPass2
Patch Set: Add executeCommands impl Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/gpu/vk/GrVkCommandBuffer.h ('k') | src/gpu/vk/GrVkGpu.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 /* 1 /*
2 * Copyright 2015 Google Inc. 2 * Copyright 2015 Google Inc.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license that can be 4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file. 5 * found in the LICENSE file.
6 */ 6 */
7 7
8 #include "GrVkCommandBuffer.h" 8 #include "GrVkCommandBuffer.h"
9 9
10 #include "GrVkFramebuffer.h" 10 #include "GrVkFramebuffer.h"
11 #include "GrVkImageView.h" 11 #include "GrVkImageView.h"
12 #include "GrVkPipeline.h" 12 #include "GrVkPipeline.h"
13 #include "GrVkRenderPass.h" 13 #include "GrVkRenderPass.h"
14 #include "GrVkRenderTarget.h" 14 #include "GrVkRenderTarget.h"
15 #include "GrVkPipelineState.h" 15 #include "GrVkPipelineState.h"
16 #include "GrVkTransferBuffer.h" 16 #include "GrVkTransferBuffer.h"
17 #include "GrVkUtil.h" 17 #include "GrVkUtil.h"
18 18
19 GrVkCommandBuffer* GrVkCommandBuffer::Create(const GrVkGpu* gpu, VkCommandPool c mdPool) {
20 const VkCommandBufferAllocateInfo cmdInfo = {
21 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
22 NULL, // pNext
23 cmdPool, // commandPool
24 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
25 1 // bufferCount
26 };
27
28 VkCommandBuffer cmdBuffer;
29 VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateCommandBuffers(gpu->de vice(),
30 &cmdInf o,
31 &cmdBuf fer));
32 if (err) {
33 return nullptr;
34 }
35 return new GrVkCommandBuffer(cmdBuffer);
36 }
37 19
38 GrVkCommandBuffer::~GrVkCommandBuffer() { 20 GrVkCommandBuffer::~GrVkCommandBuffer() {
39 // Should have ended any render pass we're in the middle of 21 // Should have ended any render pass we're in the middle of
40 SkASSERT(!fActiveRenderPass); 22 SkASSERT(!fActiveRenderPass);
41 } 23 }
42 24
43 void GrVkCommandBuffer::invalidateState() { 25 void GrVkCommandBuffer::invalidateState() {
44 fBoundVertexBuffer = VK_NULL_HANDLE; 26 fBoundVertexBuffer = VK_NULL_HANDLE;
45 fBoundVertexBufferIsValid = false; 27 fBoundVertexBufferIsValid = false;
46 fBoundIndexBuffer = VK_NULL_HANDLE; 28 fBoundIndexBuffer = VK_NULL_HANDLE;
(...skipping 25 matching lines...) Expand all
72 GR_VK_CALL(gpu->vkInterface(), FreeCommandBuffers(gpu->device(), gpu->cmdPoo l(), 54 GR_VK_CALL(gpu->vkInterface(), FreeCommandBuffers(gpu->device(), gpu->cmdPoo l(),
73 1, &fCmdBuffer)); 55 1, &fCmdBuffer));
74 } 56 }
75 57
76 void GrVkCommandBuffer::abandonSubResources() const { 58 void GrVkCommandBuffer::abandonSubResources() const {
77 for (int i = 0; i < fTrackedResources.count(); ++i) { 59 for (int i = 0; i < fTrackedResources.count(); ++i) {
78 fTrackedResources[i]->unrefAndAbandon(); 60 fTrackedResources[i]->unrefAndAbandon();
79 } 61 }
80 } 62 }
81 63
82 void GrVkCommandBuffer::begin(const GrVkGpu* gpu) { 64 ////////////////////////////////////////////////////////////////////////////////
65 // CommandBuffer commands
66 ////////////////////////////////////////////////////////////////////////////////
67
68 void GrVkCommandBuffer::pipelineBarrier(const GrVkGpu* gpu,
69 VkPipelineStageFlags srcStageMask,
70 VkPipelineStageFlags dstStageMask,
71 bool byRegion,
72 BarrierType barrierType,
73 void* barrier) const {
74 SkASSERT(fIsActive);
75 // For images we can have barriers inside of render passes but they require us to add more
76 // support in subpasses which need self dependencies to have barriers inside them. Also, we can
77 // never have buffer barriers inside of a render pass. For now we will just assert that we are
78 // not in a render pass.
79 SkASSERT(!fActiveRenderPass);
80 VkDependencyFlags dependencyFlags = byRegion ? VK_DEPENDENCY_BY_REGION_BIT : 0;
81
82 switch (barrierType) {
83 case kMemory_BarrierType: {
84 const VkMemoryBarrier* barrierPtr = reinterpret_cast<VkMemoryBarrier *>(barrier);
85 GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcSta geMask,
86 dstStageMask, depe ndencyFlags,
87 1, barrierPtr,
88 0, nullptr,
89 0, nullptr));
90 break;
91 }
92
93 case kBufferMemory_BarrierType: {
94 const VkBufferMemoryBarrier* barrierPtr =
95 reinterpret_cast<VkBufferMemory Barrier*>(barrier);
96 GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcSta geMask,
97 dstStageMask, depe ndencyFlags,
98 0, nullptr,
99 1, barrierPtr,
100 0, nullptr));
101 break;
102 }
103
104 case kImageMemory_BarrierType: {
105 const VkImageMemoryBarrier* barrierPtr =
106 reinterpret_cast<VkImageMemory Barrier*>(barrier);
107 GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcSta geMask,
108 dstStageMask, depe ndencyFlags,
109 0, nullptr,
110 0, nullptr,
111 1, barrierPtr));
112 break;
113 }
114 }
115
116 }
117
118 void GrVkCommandBuffer::clearAttachments(const GrVkGpu* gpu,
119 int numAttachments,
120 const VkClearAttachment* attachments,
121 int numRects,
122 const VkClearRect* clearRects) const {
123 SkASSERT(fIsActive);
124 SkASSERT(fActiveRenderPass);
125 SkASSERT(numAttachments > 0);
126 SkASSERT(numRects > 0);
127 #ifdef SK_DEBUG
128 for (int i = 0; i < numAttachments; ++i) {
129 if (attachments[i].aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) {
130 uint32_t testIndex;
131 SkAssertResult(fActiveRenderPass->colorAttachmentIndex(&testIndex));
132 SkASSERT(testIndex == attachments[i].colorAttachment);
133 }
134 }
135 #endif
136 GR_VK_CALL(gpu->vkInterface(), CmdClearAttachments(fCmdBuffer,
137 numAttachments,
138 attachments,
139 numRects,
140 clearRects));
141 }
142
143 void GrVkCommandBuffer::bindDescriptorSets(const GrVkGpu* gpu,
144 GrVkPipelineState* pipelineState,
145 VkPipelineLayout layout,
146 uint32_t firstSet,
147 uint32_t setCount,
148 const VkDescriptorSet* descriptorSets ,
149 uint32_t dynamicOffsetCount,
150 const uint32_t* dynamicOffsets) {
151 SkASSERT(fIsActive);
152 GR_VK_CALL(gpu->vkInterface(), CmdBindDescriptorSets(fCmdBuffer,
153 VK_PIPELINE_BIND_POINT_ GRAPHICS,
154 layout,
155 firstSet,
156 setCount,
157 descriptorSets,
158 dynamicOffsetCount,
159 dynamicOffsets));
160 pipelineState->addUniformResources(*this);
161 }
162
163 void GrVkCommandBuffer::bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pip eline) {
164 SkASSERT(fIsActive);
165 GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer,
166 VK_PIPELINE_BIND_POINT_GRAPHI CS,
167 pipeline->pipeline()));
168 addResource(pipeline);
169 }
170
171 void GrVkCommandBuffer::drawIndexed(const GrVkGpu* gpu,
172 uint32_t indexCount,
173 uint32_t instanceCount,
174 uint32_t firstIndex,
175 int32_t vertexOffset,
176 uint32_t firstInstance) const {
177 SkASSERT(fIsActive);
178 SkASSERT(fActiveRenderPass);
179 GR_VK_CALL(gpu->vkInterface(), CmdDrawIndexed(fCmdBuffer,
180 indexCount,
181 instanceCount,
182 firstIndex,
183 vertexOffset,
184 firstInstance));
185 }
186
187 void GrVkCommandBuffer::draw(const GrVkGpu* gpu,
188 uint32_t vertexCount,
189 uint32_t instanceCount,
190 uint32_t firstVertex,
191 uint32_t firstInstance) const {
192 SkASSERT(fIsActive);
193 SkASSERT(fActiveRenderPass);
194 GR_VK_CALL(gpu->vkInterface(), CmdDraw(fCmdBuffer,
195 vertexCount,
196 instanceCount,
197 firstVertex,
198 firstInstance));
199 }
200
201 void GrVkCommandBuffer::setViewport(const GrVkGpu* gpu,
202 uint32_t firstViewport,
203 uint32_t viewportCount,
204 const VkViewport* viewports) {
205 SkASSERT(fIsActive);
206 SkASSERT(1 == viewportCount);
207 if (memcmp(viewports, &fCachedViewport, sizeof(VkViewport))) {
208 GR_VK_CALL(gpu->vkInterface(), CmdSetViewport(fCmdBuffer,
209 firstViewport,
210 viewportCount,
211 viewports));
212 fCachedViewport = viewports[0];
213 }
214 }
215
216 void GrVkCommandBuffer::setScissor(const GrVkGpu* gpu,
217 uint32_t firstScissor,
218 uint32_t scissorCount,
219 const VkRect2D* scissors) {
220 SkASSERT(fIsActive);
221 SkASSERT(1 == scissorCount);
222 if (memcmp(scissors, &fCachedScissor, sizeof(VkRect2D))) {
223 GR_VK_CALL(gpu->vkInterface(), CmdSetScissor(fCmdBuffer,
224 firstScissor,
225 scissorCount,
226 scissors));
227 fCachedScissor = scissors[0];
228 }
229 }
230
231 void GrVkCommandBuffer::setBlendConstants(const GrVkGpu* gpu,
232 const float blendConstants[4]) {
233 SkASSERT(fIsActive);
234 if (memcmp(blendConstants, fCachedBlendConstant, 4 * sizeof(float))) {
235 GR_VK_CALL(gpu->vkInterface(), CmdSetBlendConstants(fCmdBuffer, blendCon stants));
236 memcpy(fCachedBlendConstant, blendConstants, 4 * sizeof(float));
237 }
238 }
239
240 ///////////////////////////////////////////////////////////////////////////////
241 // PrimaryCommandBuffer
242 ////////////////////////////////////////////////////////////////////////////////
243 GrVkPrimaryCommandBuffer* GrVkPrimaryCommandBuffer::Create(const GrVkGpu* gpu,
244 VkCommandPool cmdPool ) {
245 const VkCommandBufferAllocateInfo cmdInfo = {
246 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
247 NULL, // pNext
248 cmdPool, // commandPool
249 VK_COMMAND_BUFFER_LEVEL_PRIMARY, // level
250 1 // bufferCount
251 };
252
253 VkCommandBuffer cmdBuffer;
254 VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateCommandBuffers(gpu->de vice(),
255 &cmdInf o,
256 &cmdBuf fer));
257 if (err) {
258 return nullptr;
259 }
260 return new GrVkPrimaryCommandBuffer(cmdBuffer);
261 }
262
263 void GrVkPrimaryCommandBuffer::begin(const GrVkGpu* gpu) {
83 SkASSERT(!fIsActive); 264 SkASSERT(!fIsActive);
84 VkCommandBufferBeginInfo cmdBufferBeginInfo; 265 VkCommandBufferBeginInfo cmdBufferBeginInfo;
85 memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo)); 266 memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
86 cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 267 cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
87 cmdBufferBeginInfo.pNext = nullptr; 268 cmdBufferBeginInfo.pNext = nullptr;
88 cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; 269 cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
89 cmdBufferBeginInfo.pInheritanceInfo = nullptr; 270 cmdBufferBeginInfo.pInheritanceInfo = nullptr;
90 271
91 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), BeginCommandBuffer(fCmdBuffer, 272 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), BeginCommandBuffer(fCmdBuffer,
92 &cmdBufferBeginIn fo)); 273 &cmdBufferBeginIn fo));
93 fIsActive = true; 274 fIsActive = true;
94 } 275 }
95 276
96 void GrVkCommandBuffer::end(const GrVkGpu* gpu) { 277 void GrVkPrimaryCommandBuffer::end(const GrVkGpu* gpu) {
97 SkASSERT(fIsActive); 278 SkASSERT(fIsActive);
98 SkASSERT(!fActiveRenderPass); 279 SkASSERT(!fActiveRenderPass);
99 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), EndCommandBuffer(fCmdBuffer)); 280 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), EndCommandBuffer(fCmdBuffer));
100 this->invalidateState(); 281 this->invalidateState();
101 fIsActive = false; 282 fIsActive = false;
102 } 283 }
103 284
104 /////////////////////////////////////////////////////////////////////////////// 285 void GrVkPrimaryCommandBuffer::beginRenderPass(const GrVkGpu* gpu,
105
106 void GrVkCommandBuffer::beginRenderPass(const GrVkGpu* gpu,
107 const GrVkRenderPass* renderPass, 286 const GrVkRenderPass* renderPass,
108 const GrVkRenderTarget& target) { 287 const GrVkRenderTarget& target) {
109 SkASSERT(fIsActive); 288 SkASSERT(fIsActive);
110 SkASSERT(!fActiveRenderPass); 289 SkASSERT(!fActiveRenderPass);
111 VkRenderPassBeginInfo beginInfo; 290 VkRenderPassBeginInfo beginInfo;
112 VkSubpassContents contents; 291 VkSubpassContents contents;
113 renderPass->getBeginInfo(target, &beginInfo, &contents); 292 renderPass->getBeginInfo(target, &beginInfo, &contents);
114 GR_VK_CALL(gpu->vkInterface(), CmdBeginRenderPass(fCmdBuffer, &beginInfo, co ntents)); 293 GR_VK_CALL(gpu->vkInterface(), CmdBeginRenderPass(fCmdBuffer, &beginInfo, co ntents));
115 fActiveRenderPass = renderPass; 294 fActiveRenderPass = renderPass;
116 this->addResource(renderPass); 295 this->addResource(renderPass);
117 target.addResources(*this); 296 target.addResources(*this);
118 } 297 }
119 298
120 void GrVkCommandBuffer::endRenderPass(const GrVkGpu* gpu) { 299 void GrVkPrimaryCommandBuffer::endRenderPass(const GrVkGpu* gpu) {
121 SkASSERT(fIsActive); 300 SkASSERT(fIsActive);
122 SkASSERT(fActiveRenderPass); 301 SkASSERT(fActiveRenderPass);
123 GR_VK_CALL(gpu->vkInterface(), CmdEndRenderPass(fCmdBuffer)); 302 GR_VK_CALL(gpu->vkInterface(), CmdEndRenderPass(fCmdBuffer));
124 fActiveRenderPass = nullptr; 303 fActiveRenderPass = nullptr;
125 } 304 }
126 305
127 void GrVkCommandBuffer::submitToQueue(const GrVkGpu* gpu, VkQueue queue, GrVkGpu ::SyncQueue sync) { 306 void GrVkPrimaryCommandBuffer::executeCommands(const GrVkGpu* gpu,
307 const GrVkSecondaryCommandBuffer* buffer) {
308 SkASSERT(fIsActive);
309 SkASSERT(fActiveRenderPass);
310 SkASSERT(fActiveRenderPass->isCompatible(*buffer->fActiveRenderPass));
311
312 GR_VK_CALL(gpu->vkInterface(), CmdExecuteCommands(fCmdBuffer, 1, &buffer->fC mdBuffer));
313 this->addResource(buffer);
314 }
315
316 void GrVkPrimaryCommandBuffer::submitToQueue(const GrVkGpu* gpu,
317 VkQueue queue,
318 GrVkGpu::SyncQueue sync) {
128 SkASSERT(!fIsActive); 319 SkASSERT(!fIsActive);
129 320
130 VkResult err; 321 VkResult err;
131 VkFenceCreateInfo fenceInfo; 322 VkFenceCreateInfo fenceInfo;
132 memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo)); 323 memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
133 fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 324 fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
134 err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr, 325 err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr,
135 &fSubmitFence)); 326 &fSubmitFence));
136 SkASSERT(!err); 327 SkASSERT(!err);
137 328
(...skipping 18 matching lines...) Expand all
156 SkFAIL("failing"); 347 SkFAIL("failing");
157 } 348 }
158 SkASSERT(!err); 349 SkASSERT(!err);
159 350
160 // Destroy the fence 351 // Destroy the fence
161 GR_VK_CALL(gpu->vkInterface(), DestroyFence(gpu->device(), fSubmitFence, nullptr)); 352 GR_VK_CALL(gpu->vkInterface(), DestroyFence(gpu->device(), fSubmitFence, nullptr));
162 fSubmitFence = VK_NULL_HANDLE; 353 fSubmitFence = VK_NULL_HANDLE;
163 } 354 }
164 } 355 }
165 356
166 bool GrVkCommandBuffer::finished(const GrVkGpu* gpu) const { 357 bool GrVkPrimaryCommandBuffer::finished(const GrVkGpu* gpu) const {
167 if (VK_NULL_HANDLE == fSubmitFence) { 358 if (VK_NULL_HANDLE == fSubmitFence) {
168 return true; 359 return true;
169 } 360 }
170 361
171 VkResult err = GR_VK_CALL(gpu->vkInterface(), GetFenceStatus(gpu->device(), fSubmitFence)); 362 VkResult err = GR_VK_CALL(gpu->vkInterface(), GetFenceStatus(gpu->device(), fSubmitFence));
172 switch (err) { 363 switch (err) {
173 case VK_SUCCESS: 364 case VK_SUCCESS:
174 return true; 365 return true;
175 366
176 case VK_NOT_READY: 367 case VK_NOT_READY:
177 return false; 368 return false;
178 369
179 default: 370 default:
180 SkDebugf("Error getting fence status: %d\n", err); 371 SkDebugf("Error getting fence status: %d\n", err);
181 SkFAIL("failing"); 372 SkFAIL("failing");
182 break; 373 break;
183 } 374 }
184 375
185 return false; 376 return false;
186 } 377 }
187 378
188 //////////////////////////////////////////////////////////////////////////////// 379 void GrVkPrimaryCommandBuffer::copyImage(const GrVkGpu* gpu,
189 // CommandBuffer commands 380 GrVkImage* srcImage,
190 //////////////////////////////////////////////////////////////////////////////// 381 VkImageLayout srcLayout,
191 382 GrVkImage* dstImage,
192 void GrVkCommandBuffer::pipelineBarrier(const GrVkGpu* gpu, 383 VkImageLayout dstLayout,
193 VkPipelineStageFlags srcStageMask, 384 uint32_t copyRegionCount,
194 VkPipelineStageFlags dstStageMask, 385 const VkImageCopy* copyRegions) {
195 bool byRegion,
196 BarrierType barrierType,
197 void* barrier) const {
198 SkASSERT(fIsActive);
199 // For images we can have barriers inside of render passes but they require us to add more
200 // support in subpasses which need self dependencies to have barriers inside them. Also, we can
201 // never have buffer barriers inside of a render pass. For now we will just assert that we are
202 // not in a render pass.
203 SkASSERT(!fActiveRenderPass);
204 VkDependencyFlags dependencyFlags = byRegion ? VK_DEPENDENCY_BY_REGION_BIT : 0;
205
206 switch (barrierType) {
207 case kMemory_BarrierType: {
208 const VkMemoryBarrier* barrierPtr = reinterpret_cast<VkMemoryBarrier *>(barrier);
209 GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcSta geMask,
210 dstStageMask, depe ndencyFlags,
211 1, barrierPtr,
212 0, nullptr,
213 0, nullptr));
214 break;
215 }
216
217 case kBufferMemory_BarrierType: {
218 const VkBufferMemoryBarrier* barrierPtr =
219 reinterpret_cast<VkBufferMemory Barrier*>(barrier);
220 GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcSta geMask,
221 dstStageMask, depe ndencyFlags,
222 0, nullptr,
223 1, barrierPtr,
224 0, nullptr));
225 break;
226 }
227
228 case kImageMemory_BarrierType: {
229 const VkImageMemoryBarrier* barrierPtr =
230 reinterpret_cast<VkImageMemory Barrier*>(barrier);
231 GR_VK_CALL(gpu->vkInterface(), CmdPipelineBarrier(fCmdBuffer, srcSta geMask,
232 dstStageMask, depe ndencyFlags,
233 0, nullptr,
234 0, nullptr,
235 1, barrierPtr));
236 break;
237 }
238 }
239
240 }
241
242 void GrVkCommandBuffer::copyImage(const GrVkGpu* gpu,
243 GrVkImage* srcImage,
244 VkImageLayout srcLayout,
245 GrVkImage* dstImage,
246 VkImageLayout dstLayout,
247 uint32_t copyRegionCount,
248 const VkImageCopy* copyRegions) {
249 SkASSERT(fIsActive); 386 SkASSERT(fIsActive);
250 SkASSERT(!fActiveRenderPass); 387 SkASSERT(!fActiveRenderPass);
251 this->addResource(srcImage->resource()); 388 this->addResource(srcImage->resource());
252 this->addResource(dstImage->resource()); 389 this->addResource(dstImage->resource());
253 GR_VK_CALL(gpu->vkInterface(), CmdCopyImage(fCmdBuffer, 390 GR_VK_CALL(gpu->vkInterface(), CmdCopyImage(fCmdBuffer,
254 srcImage->image(), 391 srcImage->image(),
255 srcLayout, 392 srcLayout,
256 dstImage->image(), 393 dstImage->image(),
257 dstLayout, 394 dstLayout,
258 copyRegionCount, 395 copyRegionCount,
259 copyRegions)); 396 copyRegions));
260 } 397 }
261 398
262 void GrVkCommandBuffer::blitImage(const GrVkGpu* gpu, 399 void GrVkPrimaryCommandBuffer::blitImage(const GrVkGpu* gpu,
263 const GrVkResource* srcResource, 400 const GrVkResource* srcResource,
264 VkImage srcImage, 401 VkImage srcImage,
265 VkImageLayout srcLayout, 402 VkImageLayout srcLayout,
266 const GrVkResource* dstResource, 403 const GrVkResource* dstResource,
267 VkImage dstImage, 404 VkImage dstImage,
268 VkImageLayout dstLayout, 405 VkImageLayout dstLayout,
269 uint32_t blitRegionCount, 406 uint32_t blitRegionCount,
270 const VkImageBlit* blitRegions, 407 const VkImageBlit* blitRegions,
271 VkFilter filter) { 408 VkFilter filter) {
272 SkASSERT(fIsActive); 409 SkASSERT(fIsActive);
273 SkASSERT(!fActiveRenderPass); 410 SkASSERT(!fActiveRenderPass);
274 this->addResource(srcResource); 411 this->addResource(srcResource);
275 this->addResource(dstResource); 412 this->addResource(dstResource);
276 GR_VK_CALL(gpu->vkInterface(), CmdBlitImage(fCmdBuffer, 413 GR_VK_CALL(gpu->vkInterface(), CmdBlitImage(fCmdBuffer,
277 srcImage, 414 srcImage,
278 srcLayout, 415 srcLayout,
279 dstImage, 416 dstImage,
280 dstLayout, 417 dstLayout,
281 blitRegionCount, 418 blitRegionCount,
282 blitRegions, 419 blitRegions,
283 filter)); 420 filter));
284 } 421 }
285 422
286 void GrVkCommandBuffer::copyImageToBuffer(const GrVkGpu* gpu, 423 void GrVkPrimaryCommandBuffer::copyImageToBuffer(const GrVkGpu* gpu,
287 GrVkImage* srcImage, 424 GrVkImage* srcImage,
288 VkImageLayout srcLayout, 425 VkImageLayout srcLayout,
289 GrVkTransferBuffer* dstBuffer, 426 GrVkTransferBuffer* dstBuffer,
290 uint32_t copyRegionCount, 427 uint32_t copyRegionCount,
291 const VkBufferImageCopy* copyRegions) { 428 const VkBufferImageCopy* copyRe gions) {
292 SkASSERT(fIsActive); 429 SkASSERT(fIsActive);
293 SkASSERT(!fActiveRenderPass); 430 SkASSERT(!fActiveRenderPass);
294 this->addResource(srcImage->resource()); 431 this->addResource(srcImage->resource());
295 this->addResource(dstBuffer->resource()); 432 this->addResource(dstBuffer->resource());
296 GR_VK_CALL(gpu->vkInterface(), CmdCopyImageToBuffer(fCmdBuffer, 433 GR_VK_CALL(gpu->vkInterface(), CmdCopyImageToBuffer(fCmdBuffer,
297 srcImage->image(), 434 srcImage->image(),
298 srcLayout, 435 srcLayout,
299 dstBuffer->buffer(), 436 dstBuffer->buffer(),
300 copyRegionCount, 437 copyRegionCount,
301 copyRegions)); 438 copyRegions));
302 } 439 }
303 440
304 void GrVkCommandBuffer::copyBufferToImage(const GrVkGpu* gpu, 441 void GrVkPrimaryCommandBuffer::copyBufferToImage(const GrVkGpu* gpu,
305 GrVkTransferBuffer* srcBuffer, 442 GrVkTransferBuffer* srcBuffer,
306 GrVkImage* dstImage, 443 GrVkImage* dstImage,
307 VkImageLayout dstLayout, 444 VkImageLayout dstLayout,
308 uint32_t copyRegionCount, 445 uint32_t copyRegionCount,
309 const VkBufferImageCopy* copyRegions) { 446 const VkBufferImageCopy* copyRe gions) {
310 SkASSERT(fIsActive); 447 SkASSERT(fIsActive);
311 SkASSERT(!fActiveRenderPass); 448 SkASSERT(!fActiveRenderPass);
312 this->addResource(srcBuffer->resource()); 449 this->addResource(srcBuffer->resource());
313 this->addResource(dstImage->resource()); 450 this->addResource(dstImage->resource());
314 GR_VK_CALL(gpu->vkInterface(), CmdCopyBufferToImage(fCmdBuffer, 451 GR_VK_CALL(gpu->vkInterface(), CmdCopyBufferToImage(fCmdBuffer,
315 srcBuffer->buffer(), 452 srcBuffer->buffer(),
316 dstImage->image(), 453 dstImage->image(),
317 dstLayout, 454 dstLayout,
318 copyRegionCount, 455 copyRegionCount,
319 copyRegions)); 456 copyRegions));
320 } 457 }
321 458
322 void GrVkCommandBuffer::clearColorImage(const GrVkGpu* gpu, 459 void GrVkPrimaryCommandBuffer::clearColorImage(const GrVkGpu* gpu,
323 GrVkImage* image, 460 GrVkImage* image,
324 const VkClearColorValue* color, 461 const VkClearColorValue* color,
325 uint32_t subRangeCount, 462 uint32_t subRangeCount,
326 const VkImageSubresourceRange* subRanges ) { 463 const VkImageSubresourceRange* su bRanges) {
327 SkASSERT(fIsActive); 464 SkASSERT(fIsActive);
328 SkASSERT(!fActiveRenderPass); 465 SkASSERT(!fActiveRenderPass);
329 this->addResource(image->resource()); 466 this->addResource(image->resource());
330 GR_VK_CALL(gpu->vkInterface(), CmdClearColorImage(fCmdBuffer, 467 GR_VK_CALL(gpu->vkInterface(), CmdClearColorImage(fCmdBuffer,
331 image->image(), 468 image->image(),
332 image->currentLayout(), 469 image->currentLayout(),
333 color, 470 color,
334 subRangeCount, 471 subRangeCount,
335 subRanges)); 472 subRanges));
336 } 473 }
337 474
338 void GrVkCommandBuffer::clearDepthStencilImage(const GrVkGpu* gpu, 475 void GrVkPrimaryCommandBuffer::clearDepthStencilImage(const GrVkGpu* gpu,
339 GrVkImage* image, 476 GrVkImage* image,
340 const VkClearDepthStencilValue* c olor, 477 const VkClearDepthStencilV alue* color,
341 uint32_t subRangeCount, 478 uint32_t subRangeCount,
342 const VkImageSubresourceRange* su bRanges) { 479 const VkImageSubresourceRa nge* subRanges) {
343 SkASSERT(fIsActive); 480 SkASSERT(fIsActive);
344 SkASSERT(!fActiveRenderPass); 481 SkASSERT(!fActiveRenderPass);
345 this->addResource(image->resource()); 482 this->addResource(image->resource());
346 GR_VK_CALL(gpu->vkInterface(), CmdClearDepthStencilImage(fCmdBuffer, 483 GR_VK_CALL(gpu->vkInterface(), CmdClearDepthStencilImage(fCmdBuffer,
347 image->image(), 484 image->image(),
348 image->currentLayou t(), 485 image->currentLayou t(),
349 color, 486 color,
350 subRangeCount, 487 subRangeCount,
351 subRanges)); 488 subRanges));
352 } 489 }
353 490
354 void GrVkCommandBuffer::clearAttachments(const GrVkGpu* gpu, 491 ///////////////////////////////////////////////////////////////////////////////
355 int numAttachments, 492 // SecondaryCommandBuffer
356 const VkClearAttachment* attachments, 493 ////////////////////////////////////////////////////////////////////////////////
357 int numRects, 494
358 const VkClearRect* clearRects) const { 495 GrVkSecondaryCommandBuffer* GrVkSecondaryCommandBuffer::Create(
359 SkASSERT(fIsActive); 496 const GrVkGpu* gpu,
360 SkASSERT(fActiveRenderPass); 497 VkCommandPool cmdPool,
361 SkASSERT(numAttachments > 0); 498 const GrVkRenderPass* com patibleRenderPass) {
362 SkASSERT(numRects > 0); 499 const VkCommandBufferAllocateInfo cmdInfo = {
363 #ifdef SK_DEBUG 500 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
364 for (int i = 0; i < numAttachments; ++i) { 501 NULL, // pNext
365 if (attachments[i].aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) { 502 cmdPool, // commandPool
366 uint32_t testIndex; 503 VK_COMMAND_BUFFER_LEVEL_SECONDARY, // level
367 SkAssertResult(fActiveRenderPass->colorAttachmentIndex(&testIndex)); 504 1 // bufferCount
368 SkASSERT(testIndex == attachments[i].colorAttachment); 505 };
369 } 506
507 VkCommandBuffer cmdBuffer;
508 VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateCommandBuffers(gpu->de vice(),
509 &cmdInf o,
510 &cmdBuf fer));
511 if (err) {
512 return nullptr;
370 } 513 }
371 #endif 514 return new GrVkSecondaryCommandBuffer(cmdBuffer, compatibleRenderPass);
372 GR_VK_CALL(gpu->vkInterface(), CmdClearAttachments(fCmdBuffer,
373 numAttachments,
374 attachments,
375 numRects,
376 clearRects));
377 } 515 }
378 516
379 void GrVkCommandBuffer::bindDescriptorSets(const GrVkGpu* gpu, 517
380 GrVkPipelineState* pipelineState, 518 void GrVkSecondaryCommandBuffer::begin(const GrVkGpu* gpu, const GrVkFramebuffer * framebuffer) {
381 VkPipelineLayout layout, 519 SkASSERT(!fIsActive);
382 uint32_t firstSet, 520 SkASSERT(fActiveRenderPass);
383 uint32_t setCount, 521
384 const VkDescriptorSet* descriptorSets , 522 VkCommandBufferInheritanceInfo inheritanceInfo;
385 uint32_t dynamicOffsetCount, 523 memset(&inheritanceInfo, 0, sizeof(VkCommandBufferInheritanceInfo));
386 const uint32_t* dynamicOffsets) { 524 inheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
387 SkASSERT(fIsActive); 525 inheritanceInfo.pNext = nullptr;
388 GR_VK_CALL(gpu->vkInterface(), CmdBindDescriptorSets(fCmdBuffer, 526 inheritanceInfo.renderPass = fActiveRenderPass->vkRenderPass();
389 VK_PIPELINE_BIND_POINT_ GRAPHICS, 527 inheritanceInfo.subpass = 0; // Currently only using 1 subpass for each rend er pass
390 layout, 528 inheritanceInfo.framebuffer = framebuffer ? framebuffer->framebuffer() : VK_ NULL_HANDLE;
391 firstSet, 529 inheritanceInfo.occlusionQueryEnable = false;
392 setCount, 530 inheritanceInfo.queryFlags = 0;
393 descriptorSets, 531 inheritanceInfo.pipelineStatistics = 0;
394 dynamicOffsetCount, 532
395 dynamicOffsets)); 533 VkCommandBufferBeginInfo cmdBufferBeginInfo;
396 pipelineState->addUniformResources(*this); 534 memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
535 cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
536 cmdBufferBeginInfo.pNext = nullptr;
537 cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
538 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
539 cmdBufferBeginInfo.pInheritanceInfo = &inheritanceInfo;
540
541 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), BeginCommandBuffer(fCmdBuffer,
542 &cmdBufferBeginIn fo));
543 fIsActive = true;
397 } 544 }
398 545
399 void GrVkCommandBuffer::bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pip eline) { 546 void GrVkSecondaryCommandBuffer::end(const GrVkGpu* gpu) {
400 SkASSERT(fIsActive); 547 SkASSERT(fIsActive);
401 GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer, 548 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), EndCommandBuffer(fCmdBuffer));
402 VK_PIPELINE_BIND_POINT_GRAPHI CS, 549 this->invalidateState();
403 pipeline->pipeline())); 550 fIsActive = false;
404 addResource(pipeline);
405 } 551 }
406 552
407 void GrVkCommandBuffer::drawIndexed(const GrVkGpu* gpu,
408 uint32_t indexCount,
409 uint32_t instanceCount,
410 uint32_t firstIndex,
411 int32_t vertexOffset,
412 uint32_t firstInstance) const {
413 SkASSERT(fIsActive);
414 SkASSERT(fActiveRenderPass);
415 GR_VK_CALL(gpu->vkInterface(), CmdDrawIndexed(fCmdBuffer,
416 indexCount,
417 instanceCount,
418 firstIndex,
419 vertexOffset,
420 firstInstance));
421 }
422
423 void GrVkCommandBuffer::draw(const GrVkGpu* gpu,
424 uint32_t vertexCount,
425 uint32_t instanceCount,
426 uint32_t firstVertex,
427 uint32_t firstInstance) const {
428 SkASSERT(fIsActive);
429 SkASSERT(fActiveRenderPass);
430 GR_VK_CALL(gpu->vkInterface(), CmdDraw(fCmdBuffer,
431 vertexCount,
432 instanceCount,
433 firstVertex,
434 firstInstance));
435 }
436
437 void GrVkCommandBuffer::setViewport(const GrVkGpu* gpu,
438 uint32_t firstViewport,
439 uint32_t viewportCount,
440 const VkViewport* viewports) {
441 SkASSERT(fIsActive);
442 SkASSERT(1 == viewportCount);
443 if (memcmp(viewports, &fCachedViewport, sizeof(VkViewport))) {
444 GR_VK_CALL(gpu->vkInterface(), CmdSetViewport(fCmdBuffer,
445 firstViewport,
446 viewportCount,
447 viewports));
448 fCachedViewport = viewports[0];
449 }
450 }
451
452 void GrVkCommandBuffer::setScissor(const GrVkGpu* gpu,
453 uint32_t firstScissor,
454 uint32_t scissorCount,
455 const VkRect2D* scissors) {
456 SkASSERT(fIsActive);
457 SkASSERT(1 == scissorCount);
458 if (memcmp(scissors, &fCachedScissor, sizeof(VkRect2D))) {
459 GR_VK_CALL(gpu->vkInterface(), CmdSetScissor(fCmdBuffer,
460 firstScissor,
461 scissorCount,
462 scissors));
463 fCachedScissor = scissors[0];
464 }
465 }
466
467 void GrVkCommandBuffer::setBlendConstants(const GrVkGpu* gpu,
468 const float blendConstants[4]) {
469 SkASSERT(fIsActive);
470 if (memcmp(blendConstants, fCachedBlendConstant, 4 * sizeof(float))) {
471 GR_VK_CALL(gpu->vkInterface(), CmdSetBlendConstants(fCmdBuffer, blendCon stants));
472 memcpy(fCachedBlendConstant, blendConstants, 4 * sizeof(float));
473 }
474 }
OLDNEW
« no previous file with comments | « src/gpu/vk/GrVkCommandBuffer.h ('k') | src/gpu/vk/GrVkGpu.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698