1 /*
2 * Copyright 2016 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 #include "GrVkPipeline.h"
9 #include "GrGeometryProcessor.h"
10 #include "GrPipeline.h"
11 #include "GrStencilSettings.h"
12 #include "GrVkCommandBuffer.h"
13 #include "GrVkGpu.h"
14 #include "GrVkRenderTarget.h"
15 #include "GrVkUtil.h"
16
attrib_type_to_vkformat(GrVertexAttribType type)17 static inline VkFormat attrib_type_to_vkformat(GrVertexAttribType type) {
18 switch (type) {
19 case kFloat_GrVertexAttribType:
20 return VK_FORMAT_R32_SFLOAT;
21 case kFloat2_GrVertexAttribType:
22 return VK_FORMAT_R32G32_SFLOAT;
23 case kFloat3_GrVertexAttribType:
24 return VK_FORMAT_R32G32B32_SFLOAT;
25 case kFloat4_GrVertexAttribType:
26 return VK_FORMAT_R32G32B32A32_SFLOAT;
27 case kHalf_GrVertexAttribType:
28 return VK_FORMAT_R16_SFLOAT;
29 case kHalf2_GrVertexAttribType:
30 return VK_FORMAT_R16G16_SFLOAT;
31 case kHalf3_GrVertexAttribType:
32 return VK_FORMAT_R16G16B16_SFLOAT;
33 case kHalf4_GrVertexAttribType:
34 return VK_FORMAT_R16G16B16A16_SFLOAT;
35 case kInt2_GrVertexAttribType:
36 return VK_FORMAT_R32G32_SINT;
37 case kInt3_GrVertexAttribType:
38 return VK_FORMAT_R32G32B32_SINT;
39 case kInt4_GrVertexAttribType:
40 return VK_FORMAT_R32G32B32A32_SINT;
41 case kByte_GrVertexAttribType:
42 return VK_FORMAT_R8_SINT;
43 case kByte2_GrVertexAttribType:
44 return VK_FORMAT_R8G8_SINT;
45 case kByte3_GrVertexAttribType:
46 return VK_FORMAT_R8G8B8_SINT;
47 case kByte4_GrVertexAttribType:
48 return VK_FORMAT_R8G8B8A8_SINT;
49 case kUByte_GrVertexAttribType:
50 return VK_FORMAT_R8_UINT;
51 case kUByte2_GrVertexAttribType:
52 return VK_FORMAT_R8G8_UINT;
53 case kUByte3_GrVertexAttribType:
54 return VK_FORMAT_R8G8B8_UINT;
55 case kUByte4_GrVertexAttribType:
56 return VK_FORMAT_R8G8B8A8_UINT;
57 case kUByte_norm_GrVertexAttribType:
58 return VK_FORMAT_R8_UNORM;
59 case kUByte4_norm_GrVertexAttribType:
60 return VK_FORMAT_R8G8B8A8_UNORM;
61 case kShort2_GrVertexAttribType:
62 return VK_FORMAT_R16G16_SINT;
63 case kShort4_GrVertexAttribType:
64 return VK_FORMAT_R16G16B16A16_SINT;
65 case kUShort2_GrVertexAttribType:
66 return VK_FORMAT_R16G16_UINT;
67 case kUShort2_norm_GrVertexAttribType:
68 return VK_FORMAT_R16G16_UNORM;
69 case kInt_GrVertexAttribType:
70 return VK_FORMAT_R32_SINT;
71 case kUint_GrVertexAttribType:
72 return VK_FORMAT_R32_UINT;
73 }
74 SK_ABORT("Unknown vertex attrib type");
75 return VK_FORMAT_UNDEFINED;
76 }
77
setup_vertex_input_state(const GrPrimitiveProcessor & primProc,VkPipelineVertexInputStateCreateInfo * vertexInputInfo,SkSTArray<2,VkVertexInputBindingDescription,true> * bindingDescs,VkVertexInputAttributeDescription * attributeDesc)78 static void setup_vertex_input_state(const GrPrimitiveProcessor& primProc,
79 VkPipelineVertexInputStateCreateInfo* vertexInputInfo,
80 SkSTArray<2, VkVertexInputBindingDescription, true>* bindingDescs,
81 VkVertexInputAttributeDescription* attributeDesc) {
82 uint32_t vertexBinding = 0, instanceBinding = 0;
83
84 int nextBinding = bindingDescs->count();
85 if (primProc.hasVertexAttributes()) {
86 vertexBinding = nextBinding++;
87 }
88
89 if (primProc.hasInstanceAttributes()) {
90 instanceBinding = nextBinding;
91 }
92
93 // setup attribute descriptions
94 int vaCount = primProc.numVertexAttributes();
95 int attribIndex = 0;
96 size_t vertexAttributeOffset = 0;
97 for (const auto& attrib : primProc.vertexAttributes()) {
98 VkVertexInputAttributeDescription& vkAttrib = attributeDesc[attribIndex];
99 vkAttrib.location = attribIndex++; // for now assume location = attribIndex
100 vkAttrib.binding = vertexBinding;
101 vkAttrib.format = attrib_type_to_vkformat(attrib.cpuType());
102 vkAttrib.offset = vertexAttributeOffset;
103 vertexAttributeOffset += attrib.sizeAlign4();
104 }
105 SkASSERT(vertexAttributeOffset == primProc.vertexStride());
106
107 int iaCount = primProc.numInstanceAttributes();
108 size_t instanceAttributeOffset = 0;
109 for (const auto& attrib : primProc.instanceAttributes()) {
110 VkVertexInputAttributeDescription& vkAttrib = attributeDesc[attribIndex];
111 vkAttrib.location = attribIndex++; // for now assume location = attribIndex
112 vkAttrib.binding = instanceBinding;
113 vkAttrib.format = attrib_type_to_vkformat(attrib.cpuType());
114 vkAttrib.offset = instanceAttributeOffset;
115 instanceAttributeOffset += attrib.sizeAlign4();
116 }
117 SkASSERT(instanceAttributeOffset == primProc.instanceStride());
118
119 if (primProc.hasVertexAttributes()) {
120 bindingDescs->push_back() = {
121 vertexBinding,
122 (uint32_t) vertexAttributeOffset,
123 VK_VERTEX_INPUT_RATE_VERTEX
124 };
125 }
126 if (primProc.hasInstanceAttributes()) {
127 bindingDescs->push_back() = {
128 instanceBinding,
129 (uint32_t) instanceAttributeOffset,
130 VK_VERTEX_INPUT_RATE_INSTANCE
131 };
132 }
133
134 memset(vertexInputInfo, 0, sizeof(VkPipelineVertexInputStateCreateInfo));
135 vertexInputInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
136 vertexInputInfo->pNext = nullptr;
137 vertexInputInfo->flags = 0;
138 vertexInputInfo->vertexBindingDescriptionCount = bindingDescs->count();
139 vertexInputInfo->pVertexBindingDescriptions = bindingDescs->begin();
140 vertexInputInfo->vertexAttributeDescriptionCount = vaCount + iaCount;
141 vertexInputInfo->pVertexAttributeDescriptions = attributeDesc;
142 }
143
gr_primitive_type_to_vk_topology(GrPrimitiveType primitiveType)144 static VkPrimitiveTopology gr_primitive_type_to_vk_topology(GrPrimitiveType primitiveType) {
145 switch (primitiveType) {
146 case GrPrimitiveType::kTriangles:
147 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
148 case GrPrimitiveType::kTriangleStrip:
149 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
150 case GrPrimitiveType::kPoints:
151 return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
152 case GrPrimitiveType::kLines:
153 return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
154 case GrPrimitiveType::kLineStrip:
155 return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
156 case GrPrimitiveType::kLinesAdjacency:
157 return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
158 }
159 SK_ABORT("invalid GrPrimitiveType");
160 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
161 }
162
setup_input_assembly_state(GrPrimitiveType primitiveType,VkPipelineInputAssemblyStateCreateInfo * inputAssemblyInfo)163 static void setup_input_assembly_state(GrPrimitiveType primitiveType,
164 VkPipelineInputAssemblyStateCreateInfo* inputAssemblyInfo) {
165 memset(inputAssemblyInfo, 0, sizeof(VkPipelineInputAssemblyStateCreateInfo));
166 inputAssemblyInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
167 inputAssemblyInfo->pNext = nullptr;
168 inputAssemblyInfo->flags = 0;
169 inputAssemblyInfo->primitiveRestartEnable = false;
170 inputAssemblyInfo->topology = gr_primitive_type_to_vk_topology(primitiveType);
171 }
172
173
stencil_op_to_vk_stencil_op(GrStencilOp op)174 static VkStencilOp stencil_op_to_vk_stencil_op(GrStencilOp op) {
175 static const VkStencilOp gTable[] = {
176 VK_STENCIL_OP_KEEP, // kKeep
177 VK_STENCIL_OP_ZERO, // kZero
178 VK_STENCIL_OP_REPLACE, // kReplace
179 VK_STENCIL_OP_INVERT, // kInvert
180 VK_STENCIL_OP_INCREMENT_AND_WRAP, // kIncWrap
181 VK_STENCIL_OP_DECREMENT_AND_WRAP, // kDecWrap
182 VK_STENCIL_OP_INCREMENT_AND_CLAMP, // kIncClamp
183 VK_STENCIL_OP_DECREMENT_AND_CLAMP, // kDecClamp
184 };
185 GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrStencilOpCount);
186 GR_STATIC_ASSERT(0 == (int)GrStencilOp::kKeep);
187 GR_STATIC_ASSERT(1 == (int)GrStencilOp::kZero);
188 GR_STATIC_ASSERT(2 == (int)GrStencilOp::kReplace);
189 GR_STATIC_ASSERT(3 == (int)GrStencilOp::kInvert);
190 GR_STATIC_ASSERT(4 == (int)GrStencilOp::kIncWrap);
191 GR_STATIC_ASSERT(5 == (int)GrStencilOp::kDecWrap);
192 GR_STATIC_ASSERT(6 == (int)GrStencilOp::kIncClamp);
193 GR_STATIC_ASSERT(7 == (int)GrStencilOp::kDecClamp);
194 SkASSERT(op < (GrStencilOp)kGrStencilOpCount);
195 return gTable[(int)op];
196 }
197
stencil_func_to_vk_compare_op(GrStencilTest test)198 static VkCompareOp stencil_func_to_vk_compare_op(GrStencilTest test) {
199 static const VkCompareOp gTable[] = {
200 VK_COMPARE_OP_ALWAYS, // kAlways
201 VK_COMPARE_OP_NEVER, // kNever
202 VK_COMPARE_OP_GREATER, // kGreater
203 VK_COMPARE_OP_GREATER_OR_EQUAL, // kGEqual
204 VK_COMPARE_OP_LESS, // kLess
205 VK_COMPARE_OP_LESS_OR_EQUAL, // kLEqual
206 VK_COMPARE_OP_EQUAL, // kEqual
207 VK_COMPARE_OP_NOT_EQUAL, // kNotEqual
208 };
209 GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrStencilTestCount);
210 GR_STATIC_ASSERT(0 == (int)GrStencilTest::kAlways);
211 GR_STATIC_ASSERT(1 == (int)GrStencilTest::kNever);
212 GR_STATIC_ASSERT(2 == (int)GrStencilTest::kGreater);
213 GR_STATIC_ASSERT(3 == (int)GrStencilTest::kGEqual);
214 GR_STATIC_ASSERT(4 == (int)GrStencilTest::kLess);
215 GR_STATIC_ASSERT(5 == (int)GrStencilTest::kLEqual);
216 GR_STATIC_ASSERT(6 == (int)GrStencilTest::kEqual);
217 GR_STATIC_ASSERT(7 == (int)GrStencilTest::kNotEqual);
218 SkASSERT(test < (GrStencilTest)kGrStencilTestCount);
219
220 return gTable[(int)test];
221 }
222
setup_depth_stencil_state(const GrStencilSettings & stencilSettings,VkPipelineDepthStencilStateCreateInfo * stencilInfo)223 static void setup_depth_stencil_state(const GrStencilSettings& stencilSettings,
224 VkPipelineDepthStencilStateCreateInfo* stencilInfo) {
225 memset(stencilInfo, 0, sizeof(VkPipelineDepthStencilStateCreateInfo));
226 stencilInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
227 stencilInfo->pNext = nullptr;
228 stencilInfo->flags = 0;
229 // set depth testing defaults
230 stencilInfo->depthTestEnable = VK_FALSE;
231 stencilInfo->depthWriteEnable = VK_FALSE;
232 stencilInfo->depthCompareOp = VK_COMPARE_OP_ALWAYS;
233 stencilInfo->depthBoundsTestEnable = VK_FALSE;
234 stencilInfo->stencilTestEnable = !stencilSettings.isDisabled();
235 if (!stencilSettings.isDisabled()) {
236 // Set front face
237 const GrStencilSettings::Face& front = stencilSettings.front();
238 stencilInfo->front.failOp = stencil_op_to_vk_stencil_op(front.fFailOp);
239 stencilInfo->front.passOp = stencil_op_to_vk_stencil_op(front.fPassOp);
240 stencilInfo->front.depthFailOp = stencilInfo->front.failOp;
241 stencilInfo->front.compareOp = stencil_func_to_vk_compare_op(front.fTest);
242 stencilInfo->front.compareMask = front.fTestMask;
243 stencilInfo->front.writeMask = front.fWriteMask;
244 stencilInfo->front.reference = front.fRef;
245
246 // Set back face
247 if (!stencilSettings.isTwoSided()) {
248 stencilInfo->back = stencilInfo->front;
249 } else {
250 const GrStencilSettings::Face& back = stencilSettings.back();
251 stencilInfo->back.failOp = stencil_op_to_vk_stencil_op(back.fFailOp);
252 stencilInfo->back.passOp = stencil_op_to_vk_stencil_op(back.fPassOp);
253 stencilInfo->back.depthFailOp = stencilInfo->front.failOp;
254 stencilInfo->back.compareOp = stencil_func_to_vk_compare_op(back.fTest);
255 stencilInfo->back.compareMask = back.fTestMask;
256 stencilInfo->back.writeMask = back.fWriteMask;
257 stencilInfo->back.reference = back.fRef;
258 }
259 }
260 stencilInfo->minDepthBounds = 0.0f;
261 stencilInfo->maxDepthBounds = 1.0f;
262 }
263
setup_viewport_scissor_state(VkPipelineViewportStateCreateInfo * viewportInfo)264 static void setup_viewport_scissor_state(VkPipelineViewportStateCreateInfo* viewportInfo) {
265 memset(viewportInfo, 0, sizeof(VkPipelineViewportStateCreateInfo));
266 viewportInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
267 viewportInfo->pNext = nullptr;
268 viewportInfo->flags = 0;
269
270 viewportInfo->viewportCount = 1;
271 viewportInfo->pViewports = nullptr; // This is set dynamically
272
273 viewportInfo->scissorCount = 1;
274 viewportInfo->pScissors = nullptr; // This is set dynamically
275
276 SkASSERT(viewportInfo->viewportCount == viewportInfo->scissorCount);
277 }
278
setup_multisample_state(int numColorSamples,const GrPrimitiveProcessor & primProc,const GrPipeline & pipeline,const GrCaps * caps,VkPipelineMultisampleStateCreateInfo * multisampleInfo)279 static void setup_multisample_state(int numColorSamples,
280 const GrPrimitiveProcessor& primProc,
281 const GrPipeline& pipeline,
282 const GrCaps* caps,
283 VkPipelineMultisampleStateCreateInfo* multisampleInfo) {
284 memset(multisampleInfo, 0, sizeof(VkPipelineMultisampleStateCreateInfo));
285 multisampleInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
286 multisampleInfo->pNext = nullptr;
287 multisampleInfo->flags = 0;
288 SkAssertResult(GrSampleCountToVkSampleCount(numColorSamples,
289 &multisampleInfo->rasterizationSamples));
290 multisampleInfo->sampleShadingEnable = VK_FALSE;
291 multisampleInfo->minSampleShading = 0.0f;
292 multisampleInfo->pSampleMask = nullptr;
293 multisampleInfo->alphaToCoverageEnable = VK_FALSE;
294 multisampleInfo->alphaToOneEnable = VK_FALSE;
295 }
296
blend_coeff_to_vk_blend(GrBlendCoeff coeff)297 static VkBlendFactor blend_coeff_to_vk_blend(GrBlendCoeff coeff) {
298 static const VkBlendFactor gTable[] = {
299 VK_BLEND_FACTOR_ZERO, // kZero_GrBlendCoeff
300 VK_BLEND_FACTOR_ONE, // kOne_GrBlendCoeff
301 VK_BLEND_FACTOR_SRC_COLOR, // kSC_GrBlendCoeff
302 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, // kISC_GrBlendCoeff
303 VK_BLEND_FACTOR_DST_COLOR, // kDC_GrBlendCoeff
304 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, // kIDC_GrBlendCoeff
305 VK_BLEND_FACTOR_SRC_ALPHA, // kSA_GrBlendCoeff
306 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, // kISA_GrBlendCoeff
307 VK_BLEND_FACTOR_DST_ALPHA, // kDA_GrBlendCoeff
308 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, // kIDA_GrBlendCoeff
309 VK_BLEND_FACTOR_CONSTANT_COLOR, // kConstC_GrBlendCoeff
310 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, // kIConstC_GrBlendCoeff
311 VK_BLEND_FACTOR_CONSTANT_ALPHA, // kConstA_GrBlendCoeff
312 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, // kIConstA_GrBlendCoeff
313 VK_BLEND_FACTOR_SRC1_COLOR, // kS2C_GrBlendCoeff
314 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, // kIS2C_GrBlendCoeff
315 VK_BLEND_FACTOR_SRC1_ALPHA, // kS2A_GrBlendCoeff
316 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, // kIS2A_GrBlendCoeff
317 VK_BLEND_FACTOR_ZERO, // kIllegal_GrBlendCoeff
318 };
319 GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrBlendCoeffCnt);
320 GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff);
321 GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff);
322 GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff);
323 GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff);
324 GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff);
325 GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff);
326 GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff);
327 GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff);
328 GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff);
329 GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff);
330 GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff);
331 GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff);
332 GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff);
333 GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff);
334 GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
335 GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
336 GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
337 GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
338
339 SkASSERT((unsigned)coeff < kGrBlendCoeffCnt);
340 return gTable[coeff];
341 }
342
343
blend_equation_to_vk_blend_op(GrBlendEquation equation)344 static VkBlendOp blend_equation_to_vk_blend_op(GrBlendEquation equation) {
345 static const VkBlendOp gTable[] = {
346 // Basic blend ops
347 VK_BLEND_OP_ADD,
348 VK_BLEND_OP_SUBTRACT,
349 VK_BLEND_OP_REVERSE_SUBTRACT,
350
351 // Advanced blend ops
352 VK_BLEND_OP_SCREEN_EXT,
353 VK_BLEND_OP_OVERLAY_EXT,
354 VK_BLEND_OP_DARKEN_EXT,
355 VK_BLEND_OP_LIGHTEN_EXT,
356 VK_BLEND_OP_COLORDODGE_EXT,
357 VK_BLEND_OP_COLORBURN_EXT,
358 VK_BLEND_OP_HARDLIGHT_EXT,
359 VK_BLEND_OP_SOFTLIGHT_EXT,
360 VK_BLEND_OP_DIFFERENCE_EXT,
361 VK_BLEND_OP_EXCLUSION_EXT,
362 VK_BLEND_OP_MULTIPLY_EXT,
363 VK_BLEND_OP_HSL_HUE_EXT,
364 VK_BLEND_OP_HSL_SATURATION_EXT,
365 VK_BLEND_OP_HSL_COLOR_EXT,
366 VK_BLEND_OP_HSL_LUMINOSITY_EXT,
367
368 // Illegal.
369 VK_BLEND_OP_ADD,
370 };
371 GR_STATIC_ASSERT(0 == kAdd_GrBlendEquation);
372 GR_STATIC_ASSERT(1 == kSubtract_GrBlendEquation);
373 GR_STATIC_ASSERT(2 == kReverseSubtract_GrBlendEquation);
374 GR_STATIC_ASSERT(3 == kScreen_GrBlendEquation);
375 GR_STATIC_ASSERT(4 == kOverlay_GrBlendEquation);
376 GR_STATIC_ASSERT(5 == kDarken_GrBlendEquation);
377 GR_STATIC_ASSERT(6 == kLighten_GrBlendEquation);
378 GR_STATIC_ASSERT(7 == kColorDodge_GrBlendEquation);
379 GR_STATIC_ASSERT(8 == kColorBurn_GrBlendEquation);
380 GR_STATIC_ASSERT(9 == kHardLight_GrBlendEquation);
381 GR_STATIC_ASSERT(10 == kSoftLight_GrBlendEquation);
382 GR_STATIC_ASSERT(11 == kDifference_GrBlendEquation);
383 GR_STATIC_ASSERT(12 == kExclusion_GrBlendEquation);
384 GR_STATIC_ASSERT(13 == kMultiply_GrBlendEquation);
385 GR_STATIC_ASSERT(14 == kHSLHue_GrBlendEquation);
386 GR_STATIC_ASSERT(15 == kHSLSaturation_GrBlendEquation);
387 GR_STATIC_ASSERT(16 == kHSLColor_GrBlendEquation);
388 GR_STATIC_ASSERT(17 == kHSLLuminosity_GrBlendEquation);
389 GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrBlendEquationCnt);
390
391 SkASSERT((unsigned)equation < kGrBlendCoeffCnt);
392 return gTable[equation];
393 }
394
blend_coeff_refs_constant(GrBlendCoeff coeff)395 static bool blend_coeff_refs_constant(GrBlendCoeff coeff) {
396 static const bool gCoeffReferencesBlendConst[] = {
397 false,
398 false,
399 false,
400 false,
401 false,
402 false,
403 false,
404 false,
405 false,
406 false,
407 true,
408 true,
409 true,
410 true,
411
412 // extended blend coeffs
413 false,
414 false,
415 false,
416 false,
417
418 // Illegal
419 false,
420 };
421 return gCoeffReferencesBlendConst[coeff];
422 GR_STATIC_ASSERT(kGrBlendCoeffCnt == SK_ARRAY_COUNT(gCoeffReferencesBlendConst));
423 // Individual enum asserts already made in blend_coeff_to_vk_blend
424 }
425
setup_color_blend_state(const GrPipeline & pipeline,VkPipelineColorBlendStateCreateInfo * colorBlendInfo,VkPipelineColorBlendAttachmentState * attachmentState)426 static void setup_color_blend_state(const GrPipeline& pipeline,
427 VkPipelineColorBlendStateCreateInfo* colorBlendInfo,
428 VkPipelineColorBlendAttachmentState* attachmentState) {
429 GrXferProcessor::BlendInfo blendInfo;
430 pipeline.getXferProcessor().getBlendInfo(&blendInfo);
431
432 GrBlendEquation equation = blendInfo.fEquation;
433 GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
434 GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
435 bool blendOff = (kAdd_GrBlendEquation == equation || kSubtract_GrBlendEquation == equation) &&
436 kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff;
437
438 memset(attachmentState, 0, sizeof(VkPipelineColorBlendAttachmentState));
439 attachmentState->blendEnable = !blendOff;
440 if (!blendOff) {
441 attachmentState->srcColorBlendFactor = blend_coeff_to_vk_blend(srcCoeff);
442 attachmentState->dstColorBlendFactor = blend_coeff_to_vk_blend(dstCoeff);
443 attachmentState->colorBlendOp = blend_equation_to_vk_blend_op(equation);
444 attachmentState->srcAlphaBlendFactor = blend_coeff_to_vk_blend(srcCoeff);
445 attachmentState->dstAlphaBlendFactor = blend_coeff_to_vk_blend(dstCoeff);
446 attachmentState->alphaBlendOp = blend_equation_to_vk_blend_op(equation);
447 }
448
449 if (!blendInfo.fWriteColor) {
450 attachmentState->colorWriteMask = 0;
451 } else {
452 attachmentState->colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
453 VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
454 }
455
456 memset(colorBlendInfo, 0, sizeof(VkPipelineColorBlendStateCreateInfo));
457 colorBlendInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
458 colorBlendInfo->pNext = nullptr;
459 colorBlendInfo->flags = 0;
460 colorBlendInfo->logicOpEnable = VK_FALSE;
461 colorBlendInfo->attachmentCount = 1;
462 colorBlendInfo->pAttachments = attachmentState;
463 // colorBlendInfo->blendConstants is set dynamically
464 }
465
setup_raster_state(const GrPipeline & pipeline,const GrCaps * caps,VkPipelineRasterizationStateCreateInfo * rasterInfo)466 static void setup_raster_state(const GrPipeline& pipeline,
467 const GrCaps* caps,
468 VkPipelineRasterizationStateCreateInfo* rasterInfo) {
469 memset(rasterInfo, 0, sizeof(VkPipelineRasterizationStateCreateInfo));
470 rasterInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
471 rasterInfo->pNext = nullptr;
472 rasterInfo->flags = 0;
473 rasterInfo->depthClampEnable = VK_FALSE;
474 rasterInfo->rasterizerDiscardEnable = VK_FALSE;
475 rasterInfo->polygonMode = caps->wireframeMode() ? VK_POLYGON_MODE_LINE
476 : VK_POLYGON_MODE_FILL;
477 rasterInfo->cullMode = VK_CULL_MODE_NONE;
478 rasterInfo->frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
479 rasterInfo->depthBiasEnable = VK_FALSE;
480 rasterInfo->depthBiasConstantFactor = 0.0f;
481 rasterInfo->depthBiasClamp = 0.0f;
482 rasterInfo->depthBiasSlopeFactor = 0.0f;
483 rasterInfo->lineWidth = 1.0f;
484 }
485
setup_dynamic_state(VkPipelineDynamicStateCreateInfo * dynamicInfo,VkDynamicState * dynamicStates)486 static void setup_dynamic_state(VkPipelineDynamicStateCreateInfo* dynamicInfo,
487 VkDynamicState* dynamicStates) {
488 memset(dynamicInfo, 0, sizeof(VkPipelineDynamicStateCreateInfo));
489 dynamicInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
490 dynamicInfo->pNext = VK_NULL_HANDLE;
491 dynamicInfo->flags = 0;
492 dynamicStates[0] = VK_DYNAMIC_STATE_VIEWPORT;
493 dynamicStates[1] = VK_DYNAMIC_STATE_SCISSOR;
494 dynamicStates[2] = VK_DYNAMIC_STATE_BLEND_CONSTANTS;
495 dynamicInfo->dynamicStateCount = 3;
496 dynamicInfo->pDynamicStates = dynamicStates;
497 }
498
Create(GrVkGpu * gpu,int numColorSamples,const GrPrimitiveProcessor & primProc,const GrPipeline & pipeline,const GrStencilSettings & stencil,VkPipelineShaderStageCreateInfo * shaderStageInfo,int shaderStageCount,GrPrimitiveType primitiveType,VkRenderPass compatibleRenderPass,VkPipelineLayout layout,VkPipelineCache cache)499 GrVkPipeline* GrVkPipeline::Create(GrVkGpu* gpu, int numColorSamples,
500 const GrPrimitiveProcessor& primProc,
501 const GrPipeline& pipeline, const GrStencilSettings& stencil,
502 VkPipelineShaderStageCreateInfo* shaderStageInfo,
503 int shaderStageCount, GrPrimitiveType primitiveType,
504 VkRenderPass compatibleRenderPass, VkPipelineLayout layout,
505 VkPipelineCache cache) {
506 VkPipelineVertexInputStateCreateInfo vertexInputInfo;
507 SkSTArray<2, VkVertexInputBindingDescription, true> bindingDescs;
508 SkSTArray<16, VkVertexInputAttributeDescription> attributeDesc;
509 int totalAttributeCnt = primProc.numVertexAttributes() + primProc.numInstanceAttributes();
510 SkASSERT(totalAttributeCnt <= gpu->vkCaps().maxVertexAttributes());
511 VkVertexInputAttributeDescription* pAttribs = attributeDesc.push_back_n(totalAttributeCnt);
512 setup_vertex_input_state(primProc, &vertexInputInfo, &bindingDescs, pAttribs);
513
514 VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo;
515 setup_input_assembly_state(primitiveType, &inputAssemblyInfo);
516
517 VkPipelineDepthStencilStateCreateInfo depthStencilInfo;
518 setup_depth_stencil_state(stencil, &depthStencilInfo);
519
520 VkPipelineViewportStateCreateInfo viewportInfo;
521 setup_viewport_scissor_state(&viewportInfo);
522
523 VkPipelineMultisampleStateCreateInfo multisampleInfo;
524 setup_multisample_state(numColorSamples, primProc, pipeline, gpu->caps(), &multisampleInfo);
525
526 // We will only have one color attachment per pipeline.
527 VkPipelineColorBlendAttachmentState attachmentStates[1];
528 VkPipelineColorBlendStateCreateInfo colorBlendInfo;
529 setup_color_blend_state(pipeline, &colorBlendInfo, attachmentStates);
530
531 VkPipelineRasterizationStateCreateInfo rasterInfo;
532 setup_raster_state(pipeline, gpu->caps(), &rasterInfo);
533
534 VkDynamicState dynamicStates[3];
535 VkPipelineDynamicStateCreateInfo dynamicInfo;
536 setup_dynamic_state(&dynamicInfo, dynamicStates);
537
538 VkGraphicsPipelineCreateInfo pipelineCreateInfo;
539 memset(&pipelineCreateInfo, 0, sizeof(VkGraphicsPipelineCreateInfo));
540 pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
541 pipelineCreateInfo.pNext = nullptr;
542 pipelineCreateInfo.flags = 0;
543 pipelineCreateInfo.stageCount = shaderStageCount;
544 pipelineCreateInfo.pStages = shaderStageInfo;
545 pipelineCreateInfo.pVertexInputState = &vertexInputInfo;
546 pipelineCreateInfo.pInputAssemblyState = &inputAssemblyInfo;
547 pipelineCreateInfo.pTessellationState = nullptr;
548 pipelineCreateInfo.pViewportState = &viewportInfo;
549 pipelineCreateInfo.pRasterizationState = &rasterInfo;
550 pipelineCreateInfo.pMultisampleState = &multisampleInfo;
551 pipelineCreateInfo.pDepthStencilState = &depthStencilInfo;
552 pipelineCreateInfo.pColorBlendState = &colorBlendInfo;
553 pipelineCreateInfo.pDynamicState = &dynamicInfo;
554 pipelineCreateInfo.layout = layout;
555 pipelineCreateInfo.renderPass = compatibleRenderPass;
556 pipelineCreateInfo.subpass = 0;
557 pipelineCreateInfo.basePipelineHandle = VK_NULL_HANDLE;
558 pipelineCreateInfo.basePipelineIndex = -1;
559
560 VkPipeline vkPipeline;
561 VkResult err = GR_VK_CALL(gpu->vkInterface(), CreateGraphicsPipelines(gpu->device(),
562 cache, 1,
563 &pipelineCreateInfo,
564 nullptr, &vkPipeline));
565 if (err) {
566 SkDebugf("Failed to create pipeline. Error: %d\n", err);
567 return nullptr;
568 }
569
570 return new GrVkPipeline(vkPipeline);
571 }
572
freeGPUData(GrVkGpu * gpu) const573 void GrVkPipeline::freeGPUData(GrVkGpu* gpu) const {
574 GR_VK_CALL(gpu->vkInterface(), DestroyPipeline(gpu->device(), fPipeline, nullptr));
575 }
576
SetDynamicScissorRectState(GrVkGpu * gpu,GrVkCommandBuffer * cmdBuffer,const GrRenderTarget * renderTarget,GrSurfaceOrigin rtOrigin,SkIRect scissorRect)577 void GrVkPipeline::SetDynamicScissorRectState(GrVkGpu* gpu,
578 GrVkCommandBuffer* cmdBuffer,
579 const GrRenderTarget* renderTarget,
580 GrSurfaceOrigin rtOrigin,
581 SkIRect scissorRect) {
582 if (!scissorRect.intersect(SkIRect::MakeWH(renderTarget->width(), renderTarget->height()))) {
583 scissorRect.setEmpty();
584 }
585
586 VkRect2D scissor;
587 scissor.offset.x = scissorRect.fLeft;
588 scissor.extent.width = scissorRect.width();
589 if (kTopLeft_GrSurfaceOrigin == rtOrigin) {
590 scissor.offset.y = scissorRect.fTop;
591 } else {
592 SkASSERT(kBottomLeft_GrSurfaceOrigin == rtOrigin);
593 scissor.offset.y = renderTarget->height() - scissorRect.fBottom;
594 }
595 scissor.extent.height = scissorRect.height();
596
597 SkASSERT(scissor.offset.x >= 0);
598 SkASSERT(scissor.offset.y >= 0);
599 cmdBuffer->setScissor(gpu, 0, 1, &scissor);
600 }
601
SetDynamicViewportState(GrVkGpu * gpu,GrVkCommandBuffer * cmdBuffer,const GrRenderTarget * renderTarget)602 void GrVkPipeline::SetDynamicViewportState(GrVkGpu* gpu,
603 GrVkCommandBuffer* cmdBuffer,
604 const GrRenderTarget* renderTarget) {
605 // We always use one viewport the size of the RT
606 VkViewport viewport;
607 viewport.x = 0.0f;
608 viewport.y = 0.0f;
609 viewport.width = SkIntToScalar(renderTarget->width());
610 viewport.height = SkIntToScalar(renderTarget->height());
611 viewport.minDepth = 0.0f;
612 viewport.maxDepth = 1.0f;
613 cmdBuffer->setViewport(gpu, 0, 1, &viewport);
614 }
615
SetDynamicBlendConstantState(GrVkGpu * gpu,GrVkCommandBuffer * cmdBuffer,GrPixelConfig pixelConfig,const GrXferProcessor & xferProcessor)616 void GrVkPipeline::SetDynamicBlendConstantState(GrVkGpu* gpu,
617 GrVkCommandBuffer* cmdBuffer,
618 GrPixelConfig pixelConfig,
619 const GrXferProcessor& xferProcessor) {
620 GrXferProcessor::BlendInfo blendInfo;
621 xferProcessor.getBlendInfo(&blendInfo);
622 GrBlendCoeff srcCoeff = blendInfo.fSrcBlend;
623 GrBlendCoeff dstCoeff = blendInfo.fDstBlend;
624 float floatColors[4];
625 if (blend_coeff_refs_constant(srcCoeff) || blend_coeff_refs_constant(dstCoeff)) {
626 // Swizzle the blend to match what the shader will output.
627 const GrSwizzle& swizzle = gpu->caps()->shaderCaps()->configOutputSwizzle(pixelConfig);
628 SkPMColor4f blendConst = swizzle.applyTo(blendInfo.fBlendConstant);
629 floatColors[0] = blendConst.fR;
630 floatColors[1] = blendConst.fG;
631 floatColors[2] = blendConst.fB;
632 floatColors[3] = blendConst.fA;
633 } else {
634 memset(floatColors, 0, 4 * sizeof(float));
635 }
636 cmdBuffer->setBlendConstants(gpu, floatColors);
637 }
638