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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 573 void GrVkPipeline::freeGPUData(GrVkGpu* gpu) const { 574 GR_VK_CALL(gpu->vkInterface(), DestroyPipeline(gpu->device(), fPipeline, nullptr)); 575 } 576 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 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 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
