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

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: nit 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
« src/gpu/vk/GrVkCommandBuffer.h ('K') | « 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::submitToQueue(const GrVkGpu* gpu,
307 VkQueue queue,
308 GrVkGpu::SyncQueue sync) {
128 SkASSERT(!fIsActive); 309 SkASSERT(!fIsActive);
129 310
130 VkResult err; 311 VkResult err;
131 VkFenceCreateInfo fenceInfo; 312 VkFenceCreateInfo fenceInfo;
132 memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo)); 313 memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
133 fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 314 fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
134 err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr, 315 err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr,
135 &fSubmitFence)); 316 &fSubmitFence));
136 SkASSERT(!err); 317 SkASSERT(!err);
137 318
(...skipping 18 matching lines...) Expand all
156 SkFAIL("failing"); 337 SkFAIL("failing");
157 } 338 }
158 SkASSERT(!err); 339 SkASSERT(!err);
159 340
160 // Destroy the fence 341 // Destroy the fence
161 GR_VK_CALL(gpu->vkInterface(), DestroyFence(gpu->device(), fSubmitFence, nullptr)); 342 GR_VK_CALL(gpu->vkInterface(), DestroyFence(gpu->device(), fSubmitFence, nullptr));
162 fSubmitFence = VK_NULL_HANDLE; 343 fSubmitFence = VK_NULL_HANDLE;
163 } 344 }
164 } 345 }
165 346
166 bool GrVkCommandBuffer::finished(const GrVkGpu* gpu) const { 347 bool GrVkPrimaryCommandBuffer::finished(const GrVkGpu* gpu) const {
167 if (VK_NULL_HANDLE == fSubmitFence) { 348 if (VK_NULL_HANDLE == fSubmitFence) {
168 return true; 349 return true;
169 } 350 }
170 351
171 VkResult err = GR_VK_CALL(gpu->vkInterface(), GetFenceStatus(gpu->device(), fSubmitFence)); 352 VkResult err = GR_VK_CALL(gpu->vkInterface(), GetFenceStatus(gpu->device(), fSubmitFence));
172 switch (err) { 353 switch (err) {
173 case VK_SUCCESS: 354 case VK_SUCCESS:
174 return true; 355 return true;
175 356
176 case VK_NOT_READY: 357 case VK_NOT_READY:
177 return false; 358 return false;
178 359
179 default: 360 default:
180 SkDebugf("Error getting fence status: %d\n", err); 361 SkDebugf("Error getting fence status: %d\n", err);
181 SkFAIL("failing"); 362 SkFAIL("failing");
182 break; 363 break;
183 } 364 }
184 365
185 return false; 366 return false;
186 } 367 }
187 368
188 //////////////////////////////////////////////////////////////////////////////// 369 void GrVkPrimaryCommandBuffer::copyImage(const GrVkGpu* gpu,
189 // CommandBuffer commands 370 GrVkImage* srcImage,
190 //////////////////////////////////////////////////////////////////////////////// 371 VkImageLayout srcLayout,
191 372 GrVkImage* dstImage,
192 void GrVkCommandBuffer::pipelineBarrier(const GrVkGpu* gpu, 373 VkImageLayout dstLayout,
193 VkPipelineStageFlags srcStageMask, 374 uint32_t copyRegionCount,
194 VkPipelineStageFlags dstStageMask, 375 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); 376 SkASSERT(fIsActive);
250 SkASSERT(!fActiveRenderPass); 377 SkASSERT(!fActiveRenderPass);
251 this->addResource(srcImage->resource()); 378 this->addResource(srcImage->resource());
252 this->addResource(dstImage->resource()); 379 this->addResource(dstImage->resource());
253 GR_VK_CALL(gpu->vkInterface(), CmdCopyImage(fCmdBuffer, 380 GR_VK_CALL(gpu->vkInterface(), CmdCopyImage(fCmdBuffer,
254 srcImage->image(), 381 srcImage->image(),
255 srcLayout, 382 srcLayout,
256 dstImage->image(), 383 dstImage->image(),
257 dstLayout, 384 dstLayout,
258 copyRegionCount, 385 copyRegionCount,
259 copyRegions)); 386 copyRegions));
260 } 387 }
261 388
262 void GrVkCommandBuffer::blitImage(const GrVkGpu* gpu, 389 void GrVkPrimaryCommandBuffer::blitImage(const GrVkGpu* gpu,
263 const GrVkResource* srcResource, 390 const GrVkResource* srcResource,
264 VkImage srcImage, 391 VkImage srcImage,
265 VkImageLayout srcLayout, 392 VkImageLayout srcLayout,
266 const GrVkResource* dstResource, 393 const GrVkResource* dstResource,
267 VkImage dstImage, 394 VkImage dstImage,
268 VkImageLayout dstLayout, 395 VkImageLayout dstLayout,
269 uint32_t blitRegionCount, 396 uint32_t blitRegionCount,
270 const VkImageBlit* blitRegions, 397 const VkImageBlit* blitRegions,
271 VkFilter filter) { 398 VkFilter filter) {
272 SkASSERT(fIsActive); 399 SkASSERT(fIsActive);
273 SkASSERT(!fActiveRenderPass); 400 SkASSERT(!fActiveRenderPass);
274 this->addResource(srcResource); 401 this->addResource(srcResource);
275 this->addResource(dstResource); 402 this->addResource(dstResource);
276 GR_VK_CALL(gpu->vkInterface(), CmdBlitImage(fCmdBuffer, 403 GR_VK_CALL(gpu->vkInterface(), CmdBlitImage(fCmdBuffer,
277 srcImage, 404 srcImage,
278 srcLayout, 405 srcLayout,
279 dstImage, 406 dstImage,
280 dstLayout, 407 dstLayout,
281 blitRegionCount, 408 blitRegionCount,
282 blitRegions, 409 blitRegions,
283 filter)); 410 filter));
284 } 411 }
285 412
286 void GrVkCommandBuffer::copyImageToBuffer(const GrVkGpu* gpu, 413 void GrVkPrimaryCommandBuffer::copyImageToBuffer(const GrVkGpu* gpu,
287 GrVkImage* srcImage, 414 GrVkImage* srcImage,
288 VkImageLayout srcLayout, 415 VkImageLayout srcLayout,
289 GrVkTransferBuffer* dstBuffer, 416 GrVkTransferBuffer* dstBuffer,
290 uint32_t copyRegionCount, 417 uint32_t copyRegionCount,
291 const VkBufferImageCopy* copyRegions) { 418 const VkBufferImageCopy* copyRe gions) {
292 SkASSERT(fIsActive); 419 SkASSERT(fIsActive);
293 SkASSERT(!fActiveRenderPass); 420 SkASSERT(!fActiveRenderPass);
294 this->addResource(srcImage->resource()); 421 this->addResource(srcImage->resource());
295 this->addResource(dstBuffer->resource()); 422 this->addResource(dstBuffer->resource());
296 GR_VK_CALL(gpu->vkInterface(), CmdCopyImageToBuffer(fCmdBuffer, 423 GR_VK_CALL(gpu->vkInterface(), CmdCopyImageToBuffer(fCmdBuffer,
297 srcImage->image(), 424 srcImage->image(),
298 srcLayout, 425 srcLayout,
299 dstBuffer->buffer(), 426 dstBuffer->buffer(),
300 copyRegionCount, 427 copyRegionCount,
301 copyRegions)); 428 copyRegions));
302 } 429 }
303 430
304 void GrVkCommandBuffer::copyBufferToImage(const GrVkGpu* gpu, 431 void GrVkPrimaryCommandBuffer::copyBufferToImage(const GrVkGpu* gpu,
305 GrVkTransferBuffer* srcBuffer, 432 GrVkTransferBuffer* srcBuffer,
306 GrVkImage* dstImage, 433 GrVkImage* dstImage,
307 VkImageLayout dstLayout, 434 VkImageLayout dstLayout,
308 uint32_t copyRegionCount, 435 uint32_t copyRegionCount,
309 const VkBufferImageCopy* copyRegions) { 436 const VkBufferImageCopy* copyRe gions) {
310 SkASSERT(fIsActive); 437 SkASSERT(fIsActive);
311 SkASSERT(!fActiveRenderPass); 438 SkASSERT(!fActiveRenderPass);
312 this->addResource(srcBuffer->resource()); 439 this->addResource(srcBuffer->resource());
313 this->addResource(dstImage->resource()); 440 this->addResource(dstImage->resource());
314 GR_VK_CALL(gpu->vkInterface(), CmdCopyBufferToImage(fCmdBuffer, 441 GR_VK_CALL(gpu->vkInterface(), CmdCopyBufferToImage(fCmdBuffer,
315 srcBuffer->buffer(), 442 srcBuffer->buffer(),
316 dstImage->image(), 443 dstImage->image(),
317 dstLayout, 444 dstLayout,
318 copyRegionCount, 445 copyRegionCount,
319 copyRegions)); 446 copyRegions));
320 } 447 }
321 448
322 void GrVkCommandBuffer::clearColorImage(const GrVkGpu* gpu, 449 void GrVkPrimaryCommandBuffer::clearColorImage(const GrVkGpu* gpu,
323 GrVkImage* image, 450 GrVkImage* image,
324 const VkClearColorValue* color, 451 const VkClearColorValue* color,
325 uint32_t subRangeCount, 452 uint32_t subRangeCount,
326 const VkImageSubresourceRange* subRanges ) { 453 const VkImageSubresourceRange* su bRanges) {
327 SkASSERT(fIsActive); 454 SkASSERT(fIsActive);
328 SkASSERT(!fActiveRenderPass); 455 SkASSERT(!fActiveRenderPass);
329 this->addResource(image->resource()); 456 this->addResource(image->resource());
330 GR_VK_CALL(gpu->vkInterface(), CmdClearColorImage(fCmdBuffer, 457 GR_VK_CALL(gpu->vkInterface(), CmdClearColorImage(fCmdBuffer,
331 image->image(), 458 image->image(),
332 image->currentLayout(), 459 image->currentLayout(),
333 color, 460 color,
334 subRangeCount, 461 subRangeCount,
335 subRanges)); 462 subRanges));
336 } 463 }
337 464
338 void GrVkCommandBuffer::clearDepthStencilImage(const GrVkGpu* gpu, 465 void GrVkPrimaryCommandBuffer::clearDepthStencilImage(const GrVkGpu* gpu,
339 GrVkImage* image, 466 GrVkImage* image,
340 const VkClearDepthStencilValue* c olor, 467 const VkClearDepthStencilV alue* color,
341 uint32_t subRangeCount, 468 uint32_t subRangeCount,
342 const VkImageSubresourceRange* su bRanges) { 469 const VkImageSubresourceRa nge* subRanges) {
343 SkASSERT(fIsActive); 470 SkASSERT(fIsActive);
344 SkASSERT(!fActiveRenderPass); 471 SkASSERT(!fActiveRenderPass);
345 this->addResource(image->resource()); 472 this->addResource(image->resource());
346 GR_VK_CALL(gpu->vkInterface(), CmdClearDepthStencilImage(fCmdBuffer, 473 GR_VK_CALL(gpu->vkInterface(), CmdClearDepthStencilImage(fCmdBuffer,
347 image->image(), 474 image->image(),
348 image->currentLayou t(), 475 image->currentLayou t(),
349 color, 476 color,
350 subRangeCount, 477 subRangeCount,
351 subRanges)); 478 subRanges));
352 } 479 }
353 480
354 void GrVkCommandBuffer::clearAttachments(const GrVkGpu* gpu, 481 ///////////////////////////////////////////////////////////////////////////////
355 int numAttachments, 482 // SecondaryCommandBuffer
356 const VkClearAttachment* attachments, 483 ////////////////////////////////////////////////////////////////////////////////
357 int numRects, 484
358 const VkClearRect* clearRects) const { 485 GrVkSecondaryCommandBuffer* GrVkSecondaryCommandBuffer::Create(
359 SkASSERT(fIsActive); 486 const GrVkGpu* gpu,
360 SkASSERT(fActiveRenderPass); 487 VkCommandPool cmdPool,
361 SkASSERT(numAttachments > 0); 488 const GrVkRenderPass* com patibleRenderPass) {
362 SkASSERT(numRects > 0); 489 const VkCommandBufferAllocateInfo cmdInfo = {
363 #ifdef SK_DEBUG 490 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // sType
364 for (int i = 0; i < numAttachments; ++i) { 491 NULL, // pNext
365 if (attachments[i].aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) { 492 cmdPool, // commandPool
366 uint32_t testIndex; 493 VK_COMMAND_BUFFER_LEVEL_SECONDARY, // level
367 SkAssertResult(fActiveRenderPass->colorAttachmentIndex(&testIndex)); 494 1 // bufferCount
368 SkASSERT(testIndex == attachments[i].colorAttachment); 495 };
369 } 496
497 VkCommandBuffer cmdBuffer;
498 VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateCommandBuffers(gpu->de vice(),
499 &cmdInf o,
500 &cmdBuf fer));
501 if (err) {
502 return nullptr;
370 } 503 }
371 #endif 504 return new GrVkSecondaryCommandBuffer(cmdBuffer, compatibleRenderPass);
372 GR_VK_CALL(gpu->vkInterface(), CmdClearAttachments(fCmdBuffer,
373 numAttachments,
374 attachments,
375 numRects,
376 clearRects));
377 } 505 }
378 506
379 void GrVkCommandBuffer::bindDescriptorSets(const GrVkGpu* gpu, 507
380 GrVkPipelineState* pipelineState, 508 void GrVkSecondaryCommandBuffer::begin(const GrVkGpu* gpu, const GrVkFramebuffer * framebuffer) {
381 VkPipelineLayout layout, 509 SkASSERT(!fIsActive);
382 uint32_t firstSet, 510 SkASSERT(fActiveRenderPass);
383 uint32_t setCount, 511
384 const VkDescriptorSet* descriptorSets , 512 VkCommandBufferInheritanceInfo inheritanceInfo;
385 uint32_t dynamicOffsetCount, 513 memset(&inheritanceInfo, 0, sizeof(VkCommandBufferInheritanceInfo));
386 const uint32_t* dynamicOffsets) { 514 inheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
387 SkASSERT(fIsActive); 515 inheritanceInfo.pNext = nullptr;
388 GR_VK_CALL(gpu->vkInterface(), CmdBindDescriptorSets(fCmdBuffer, 516 inheritanceInfo.renderPass = fActiveRenderPass->vkRenderPass();
389 VK_PIPELINE_BIND_POINT_ GRAPHICS, 517 inheritanceInfo.subpass = 0; // Currently only using 1 subpass for each rend er pass
390 layout, 518 inheritanceInfo.framebuffer = framebuffer ? framebuffer->framebuffer() : VK_ NULL_HANDLE;
391 firstSet, 519 inheritanceInfo.occlusionQueryEnable = false;
392 setCount, 520 inheritanceInfo.queryFlags = 0;
393 descriptorSets, 521 inheritanceInfo.pipelineStatistics = 0;
394 dynamicOffsetCount, 522
395 dynamicOffsets)); 523 VkCommandBufferBeginInfo cmdBufferBeginInfo;
396 pipelineState->addUniformResources(*this); 524 memset(&cmdBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));
525 cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
526 cmdBufferBeginInfo.pNext = nullptr;
527 cmdBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT |
528 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
529 cmdBufferBeginInfo.pInheritanceInfo = &inheritanceInfo;
530
531 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), BeginCommandBuffer(fCmdBuffer,
532 &cmdBufferBeginIn fo));
533 fIsActive = true;
397 } 534 }
398 535
399 void GrVkCommandBuffer::bindPipeline(const GrVkGpu* gpu, const GrVkPipeline* pip eline) { 536 void GrVkSecondaryCommandBuffer::end(const GrVkGpu* gpu) {
400 SkASSERT(fIsActive); 537 SkASSERT(fIsActive);
401 GR_VK_CALL(gpu->vkInterface(), CmdBindPipeline(fCmdBuffer, 538 GR_VK_CALL_ERRCHECK(gpu->vkInterface(), EndCommandBuffer(fCmdBuffer));
402 VK_PIPELINE_BIND_POINT_GRAPHI CS, 539 this->invalidateState();
403 pipeline->pipeline())); 540 fIsActive = false;
404 addResource(pipeline);
405 } 541 }
406 542
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
« src/gpu/vk/GrVkCommandBuffer.h ('K') | « 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