| /* |
| * Copyright 2018 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "GrMtlPipelineStateBuilder.h" |
| |
| #include "GrContext.h" |
| #include "GrContextPriv.h" |
| |
| #include "GrMtlGpu.h" |
| #include "GrMtlPipelineState.h" |
| #include "GrMtlUtil.h" |
| |
| #include "GrRenderTargetPriv.h" |
| |
| #import <simd/simd.h> |
| |
| GrMtlPipelineState* GrMtlPipelineStateBuilder::CreatePipelineState( |
| GrMtlGpu* gpu, |
| GrRenderTarget* renderTarget, GrSurfaceOrigin origin, |
| const GrPrimitiveProcessor& primProc, |
| const GrTextureProxy* const primProcProxies[], |
| const GrPipeline& pipeline, |
| Desc* desc) { |
| GrMtlPipelineStateBuilder builder(gpu, renderTarget, origin, pipeline, primProc, |
| primProcProxies, desc); |
| |
| if (!builder.emitAndInstallProcs()) { |
| return nullptr; |
| } |
| return builder.finalize(renderTarget, primProc, pipeline, desc); |
| } |
| |
| GrMtlPipelineStateBuilder::GrMtlPipelineStateBuilder(GrMtlGpu* gpu, |
| GrRenderTarget* renderTarget, |
| GrSurfaceOrigin origin, |
| const GrPipeline& pipeline, |
| const GrPrimitiveProcessor& primProc, |
| const GrTextureProxy* const primProcProxies[], |
| GrProgramDesc* desc) |
| : INHERITED(renderTarget, origin, primProc, primProcProxies, pipeline, desc) |
| , fGpu(gpu) |
| , fUniformHandler(this) |
| , fVaryingHandler(this) { |
| } |
| |
| const GrCaps* GrMtlPipelineStateBuilder::caps() const { |
| return fGpu->caps(); |
| } |
| |
| void GrMtlPipelineStateBuilder::finalizeFragmentOutputColor(GrShaderVar& outputColor) { |
| outputColor.addLayoutQualifier("location = 0, index = 0"); |
| } |
| |
| void GrMtlPipelineStateBuilder::finalizeFragmentSecondaryColor(GrShaderVar& outputColor) { |
| outputColor.addLayoutQualifier("location = 0, index = 1"); |
| } |
| |
| id<MTLLibrary> GrMtlPipelineStateBuilder::createMtlShaderLibrary( |
| const GrGLSLShaderBuilder& builder, |
| SkSL::Program::Kind kind, |
| const SkSL::Program::Settings& settings, |
| GrProgramDesc* desc) { |
| SkString shaderString; |
| for (int i = 0; i < builder.fCompilerStrings.count(); ++i) { |
| if (builder.fCompilerStrings[i]) { |
| shaderString.append(builder.fCompilerStrings[i]); |
| shaderString.append("\n"); |
| } |
| } |
| |
| SkSL::Program::Inputs inputs; |
| id<MTLLibrary> shaderLibrary = GrCompileMtlShaderLibrary(fGpu, shaderString.c_str(), |
| kind, settings, &inputs); |
| if (shaderLibrary == nil) { |
| return nil; |
| } |
| if (inputs.fRTHeight) { |
| this->addRTHeightUniform(SKSL_RTHEIGHT_NAME); |
| } |
| if (inputs.fFlipY) { |
| desc->setSurfaceOriginKey(GrGLSLFragmentShaderBuilder::KeyForSurfaceOrigin(this->origin())); |
| } |
| return shaderLibrary; |
| } |
| |
| static inline MTLVertexFormat attribute_type_to_mtlformat(GrVertexAttribType type) { |
| // All half types will actually be float types. We are currently not using half types with |
| // metal to avoid an issue with narrow type coercions (float->half) http://skbug.com/8221 |
| switch (type) { |
| case kFloat_GrVertexAttribType: |
| return MTLVertexFormatFloat; |
| case kFloat2_GrVertexAttribType: |
| return MTLVertexFormatFloat2; |
| case kFloat3_GrVertexAttribType: |
| return MTLVertexFormatFloat3; |
| case kFloat4_GrVertexAttribType: |
| return MTLVertexFormatFloat4; |
| case kHalf_GrVertexAttribType: |
| return MTLVertexFormatHalf; |
| case kHalf2_GrVertexAttribType: |
| return MTLVertexFormatHalf2; |
| case kHalf3_GrVertexAttribType: |
| return MTLVertexFormatHalf3; |
| case kHalf4_GrVertexAttribType: |
| return MTLVertexFormatHalf4; |
| case kInt2_GrVertexAttribType: |
| return MTLVertexFormatInt2; |
| case kInt3_GrVertexAttribType: |
| return MTLVertexFormatInt3; |
| case kInt4_GrVertexAttribType: |
| return MTLVertexFormatInt4; |
| case kByte_GrVertexAttribType: |
| return MTLVertexFormatChar; |
| case kByte2_GrVertexAttribType: |
| return MTLVertexFormatChar2; |
| case kByte3_GrVertexAttribType: |
| return MTLVertexFormatChar3; |
| case kByte4_GrVertexAttribType: |
| return MTLVertexFormatChar4; |
| case kUByte_GrVertexAttribType: |
| return MTLVertexFormatUChar; |
| case kUByte2_GrVertexAttribType: |
| return MTLVertexFormatUChar2; |
| case kUByte3_GrVertexAttribType: |
| return MTLVertexFormatUChar3; |
| case kUByte4_GrVertexAttribType: |
| return MTLVertexFormatUChar4; |
| case kUByte_norm_GrVertexAttribType: |
| return MTLVertexFormatUCharNormalized; |
| case kUByte4_norm_GrVertexAttribType: |
| return MTLVertexFormatUChar4Normalized; |
| case kShort2_GrVertexAttribType: |
| return MTLVertexFormatShort2; |
| case kShort4_GrVertexAttribType: |
| return MTLVertexFormatShort4; |
| case kUShort2_GrVertexAttribType: |
| return MTLVertexFormatUShort2; |
| case kUShort2_norm_GrVertexAttribType: |
| return MTLVertexFormatUShort2Normalized; |
| case kInt_GrVertexAttribType: |
| return MTLVertexFormatInt; |
| case kUint_GrVertexAttribType: |
| return MTLVertexFormatUInt; |
| } |
| SK_ABORT("Unknown vertex attribute type"); |
| return MTLVertexFormatInvalid; |
| } |
| |
| static MTLVertexDescriptor* create_vertex_descriptor(const GrPrimitiveProcessor& primProc) { |
| uint32_t vertexBinding = 0, instanceBinding = 0; |
| |
| int nextBinding = GrMtlUniformHandler::kLastUniformBinding + 1; |
| if (primProc.hasVertexAttributes()) { |
| vertexBinding = nextBinding++; |
| } |
| |
| if (primProc.hasInstanceAttributes()) { |
| instanceBinding = nextBinding; |
| } |
| |
| auto vertexDescriptor = [[MTLVertexDescriptor alloc] init]; |
| int attributeIndex = 0; |
| |
| int vertexAttributeCount = primProc.numVertexAttributes(); |
| size_t vertexAttributeOffset = 0; |
| for (const auto& attribute : primProc.vertexAttributes()) { |
| MTLVertexAttributeDescriptor* mtlAttribute = vertexDescriptor.attributes[attributeIndex]; |
| mtlAttribute.format = attribute_type_to_mtlformat(attribute.cpuType()); |
| mtlAttribute.offset = vertexAttributeOffset; |
| mtlAttribute.bufferIndex = vertexBinding; |
| |
| vertexAttributeOffset += attribute.sizeAlign4(); |
| attributeIndex++; |
| } |
| SkASSERT(vertexAttributeOffset == primProc.vertexStride()); |
| |
| if (vertexAttributeCount) { |
| MTLVertexBufferLayoutDescriptor* vertexBufferLayout = |
| vertexDescriptor.layouts[vertexBinding]; |
| vertexBufferLayout.stepFunction = MTLVertexStepFunctionPerVertex; |
| vertexBufferLayout.stepRate = 1; |
| vertexBufferLayout.stride = vertexAttributeOffset; |
| } |
| |
| int instanceAttributeCount = primProc.numInstanceAttributes(); |
| size_t instanceAttributeOffset = 0; |
| for (const auto& attribute : primProc.instanceAttributes()) { |
| MTLVertexAttributeDescriptor* mtlAttribute = vertexDescriptor.attributes[attributeIndex]; |
| mtlAttribute.format = attribute_type_to_mtlformat(attribute.cpuType()); |
| mtlAttribute.offset = instanceAttributeOffset; |
| mtlAttribute.bufferIndex = instanceBinding; |
| |
| instanceAttributeOffset += attribute.sizeAlign4(); |
| attributeIndex++; |
| } |
| SkASSERT(instanceAttributeOffset == primProc.instanceStride()); |
| |
| if (instanceAttributeCount) { |
| MTLVertexBufferLayoutDescriptor* instanceBufferLayout = |
| vertexDescriptor.layouts[instanceBinding]; |
| instanceBufferLayout.stepFunction = MTLVertexStepFunctionPerInstance; |
| instanceBufferLayout.stepRate = 1; |
| instanceBufferLayout.stride = instanceAttributeOffset; |
| } |
| return vertexDescriptor; |
| } |
| |
| static MTLBlendFactor blend_coeff_to_mtl_blend(GrBlendCoeff coeff) { |
| static const MTLBlendFactor gTable[] = { |
| MTLBlendFactorZero, // kZero_GrBlendCoeff |
| MTLBlendFactorOne, // kOne_GrBlendCoeff |
| MTLBlendFactorSourceColor, // kSC_GrBlendCoeff |
| MTLBlendFactorOneMinusSourceColor, // kISC_GrBlendCoeff |
| MTLBlendFactorDestinationColor, // kDC_GrBlendCoeff |
| MTLBlendFactorOneMinusDestinationColor, // kIDC_GrBlendCoeff |
| MTLBlendFactorSourceAlpha, // kSA_GrBlendCoeff |
| MTLBlendFactorOneMinusSourceAlpha, // kISA_GrBlendCoeff |
| MTLBlendFactorDestinationAlpha, // kDA_GrBlendCoeff |
| MTLBlendFactorOneMinusDestinationAlpha, // kIDA_GrBlendCoeff |
| MTLBlendFactorBlendColor, // kConstC_GrBlendCoeff |
| MTLBlendFactorOneMinusBlendColor, // kIConstC_GrBlendCoeff |
| MTLBlendFactorBlendAlpha, // kConstA_GrBlendCoeff |
| MTLBlendFactorOneMinusBlendAlpha, // kIConstA_GrBlendCoeff |
| MTLBlendFactorSource1Color, // kS2C_GrBlendCoeff |
| MTLBlendFactorOneMinusSource1Color, // kIS2C_GrBlendCoeff |
| MTLBlendFactorSource1Alpha, // kS2A_GrBlendCoeff |
| MTLBlendFactorOneMinusSource1Alpha, // kIS2A_GrBlendCoeff |
| MTLBlendFactorZero, // kIllegal_GrBlendCoeff |
| }; |
| GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kGrBlendCoeffCnt); |
| GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff); |
| GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff); |
| GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff); |
| GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff); |
| GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff); |
| GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff); |
| GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff); |
| GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff); |
| GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff); |
| GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff); |
| GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff); |
| GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff); |
| GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff); |
| GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff); |
| GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff); |
| GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff); |
| GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff); |
| GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff); |
| |
| SkASSERT((unsigned)coeff < kGrBlendCoeffCnt); |
| return gTable[coeff]; |
| } |
| |
| static MTLBlendOperation blend_equation_to_mtl_blend_op(GrBlendEquation equation) { |
| static const MTLBlendOperation gTable[] = { |
| MTLBlendOperationAdd, // kAdd_GrBlendEquation |
| MTLBlendOperationSubtract, // kSubtract_GrBlendEquation |
| MTLBlendOperationReverseSubtract, // kReverseSubtract_GrBlendEquation |
| }; |
| GR_STATIC_ASSERT(SK_ARRAY_COUNT(gTable) == kFirstAdvancedGrBlendEquation); |
| GR_STATIC_ASSERT(0 == kAdd_GrBlendEquation); |
| GR_STATIC_ASSERT(1 == kSubtract_GrBlendEquation); |
| GR_STATIC_ASSERT(2 == kReverseSubtract_GrBlendEquation); |
| |
| SkASSERT((unsigned)equation < kGrBlendEquationCnt); |
| return gTable[equation]; |
| } |
| |
| static MTLRenderPipelineColorAttachmentDescriptor* create_color_attachment( |
| GrPixelConfig config, const GrPipeline& pipeline) { |
| auto mtlColorAttachment = [[MTLRenderPipelineColorAttachmentDescriptor alloc] init]; |
| |
| // pixel format |
| MTLPixelFormat format; |
| SkAssertResult(GrPixelConfigToMTLFormat(config, &format)); |
| mtlColorAttachment.pixelFormat = format; |
| |
| // blending |
| GrXferProcessor::BlendInfo blendInfo; |
| pipeline.getXferProcessor().getBlendInfo(&blendInfo); |
| |
| GrBlendEquation equation = blendInfo.fEquation; |
| GrBlendCoeff srcCoeff = blendInfo.fSrcBlend; |
| GrBlendCoeff dstCoeff = blendInfo.fDstBlend; |
| bool blendOff = (kAdd_GrBlendEquation == equation || kSubtract_GrBlendEquation == equation) && |
| kOne_GrBlendCoeff == srcCoeff && kZero_GrBlendCoeff == dstCoeff; |
| |
| mtlColorAttachment.blendingEnabled = !blendOff; |
| if (!blendOff) { |
| mtlColorAttachment.sourceRGBBlendFactor = blend_coeff_to_mtl_blend(srcCoeff); |
| mtlColorAttachment.destinationRGBBlendFactor = blend_coeff_to_mtl_blend(dstCoeff); |
| mtlColorAttachment.rgbBlendOperation = blend_equation_to_mtl_blend_op(equation); |
| mtlColorAttachment.sourceAlphaBlendFactor = blend_coeff_to_mtl_blend(srcCoeff); |
| mtlColorAttachment.destinationAlphaBlendFactor = blend_coeff_to_mtl_blend(dstCoeff); |
| mtlColorAttachment.alphaBlendOperation = blend_equation_to_mtl_blend_op(equation); |
| } |
| |
| if (!blendInfo.fWriteColor) { |
| mtlColorAttachment.writeMask = MTLColorWriteMaskNone; |
| } else { |
| mtlColorAttachment.writeMask = MTLColorWriteMaskAll; |
| } |
| return mtlColorAttachment; |
| } |
| |
| uint32_t buffer_size(uint32_t offset, uint32_t maxAlignment) { |
| // Metal expects the buffer to be padded at the end according to the alignment |
| // of the largest element in the buffer. |
| uint32_t offsetDiff = offset & maxAlignment; |
| if (offsetDiff != 0) { |
| offsetDiff = maxAlignment - offsetDiff + 1; |
| } |
| return offset + offsetDiff; |
| } |
| |
| GrMtlPipelineState* GrMtlPipelineStateBuilder::finalize(GrRenderTarget* renderTarget, |
| const GrPrimitiveProcessor& primProc, |
| const GrPipeline& pipeline, |
| Desc* desc) { |
| auto pipelineDescriptor = [MTLRenderPipelineDescriptor new]; |
| |
| fVS.extensions().appendf("#extension GL_ARB_separate_shader_objects : enable\n"); |
| fFS.extensions().appendf("#extension GL_ARB_separate_shader_objects : enable\n"); |
| fVS.extensions().appendf("#extension GL_ARB_shading_language_420pack : enable\n"); |
| fFS.extensions().appendf("#extension GL_ARB_shading_language_420pack : enable\n"); |
| |
| this->finalizeShaders(); |
| |
| SkSL::Program::Settings settings; |
| settings.fCaps = this->caps()->shaderCaps(); |
| settings.fFlipY = this->origin() != kTopLeft_GrSurfaceOrigin; |
| settings.fSharpenTextures = fGpu->getContext()->priv().options().fSharpenMipmappedTextures; |
| SkASSERT(!this->fragColorIsInOut()); |
| |
| // TODO: Store shaders in cache |
| id<MTLLibrary> vertexLibrary = nil; |
| id<MTLLibrary> fragmentLibrary = nil; |
| vertexLibrary = this->createMtlShaderLibrary(fVS, |
| SkSL::Program::kVertex_Kind, |
| settings, |
| desc); |
| fragmentLibrary = this->createMtlShaderLibrary(fFS, |
| SkSL::Program::kFragment_Kind, |
| settings, |
| desc); |
| SkASSERT(!this->primitiveProcessor().willUseGeoShader()); |
| |
| SkASSERT(vertexLibrary); |
| SkASSERT(fragmentLibrary); |
| |
| id<MTLFunction> vertexFunction = [vertexLibrary newFunctionWithName: @"vertexMain"]; |
| id<MTLFunction> fragmentFunction = [fragmentLibrary newFunctionWithName: @"fragmentMain"]; |
| |
| pipelineDescriptor.vertexFunction = vertexFunction; |
| pipelineDescriptor.fragmentFunction = fragmentFunction; |
| pipelineDescriptor.vertexDescriptor = create_vertex_descriptor(primProc); |
| pipelineDescriptor.colorAttachments[0] = create_color_attachment(this->config(), pipeline); |
| bool hasStencilAttachment = SkToBool(renderTarget->renderTargetPriv().getStencilAttachment()); |
| GrMtlCaps* mtlCaps = (GrMtlCaps*)this->caps(); |
| pipelineDescriptor.stencilAttachmentPixelFormat = |
| hasStencilAttachment ? mtlCaps->preferredStencilFormat().fInternalFormat |
| : MTLPixelFormatInvalid; |
| |
| SkASSERT(pipelineDescriptor.vertexFunction); |
| SkASSERT(pipelineDescriptor.fragmentFunction); |
| SkASSERT(pipelineDescriptor.vertexDescriptor); |
| SkASSERT(pipelineDescriptor.colorAttachments[0]); |
| |
| NSError* error = nil; |
| id<MTLRenderPipelineState> pipelineState = |
| [fGpu->device() newRenderPipelineStateWithDescriptor: pipelineDescriptor |
| error: &error]; |
| if (error) { |
| SkDebugf("Error creating pipeline: %s\n", |
| [[error localizedDescription] cStringUsingEncoding: NSASCIIStringEncoding]); |
| return nullptr; |
| } |
| uint32_t geomBufferSize = buffer_size(fUniformHandler.fCurrentGeometryUBOOffset, |
| fUniformHandler.fCurrentGeometryUBOMaxAlignment); |
| uint32_t fragBufferSize = buffer_size(fUniformHandler.fCurrentFragmentUBOOffset, |
| fUniformHandler.fCurrentFragmentUBOMaxAlignment); |
| return new GrMtlPipelineState(fGpu, |
| pipelineState, |
| pipelineDescriptor.colorAttachments[0].pixelFormat, |
| fUniformHandles, |
| fUniformHandler.fUniforms, |
| GrMtlBuffer::Make(fGpu, |
| geomBufferSize, |
| GrGpuBufferType::kVertex, |
| kStatic_GrAccessPattern), |
| GrMtlBuffer::Make(fGpu, |
| fragBufferSize, |
| GrGpuBufferType::kVertex, |
| kStatic_GrAccessPattern), |
| (uint32_t)fUniformHandler.numSamplers(), |
| std::move(fGeometryProcessor), |
| std::move(fXferProcessor), |
| std::move(fFragmentProcessors), |
| fFragmentProcessorCnt); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| bool GrMtlPipelineStateBuilder::Desc::Build(Desc* desc, |
| GrRenderTarget* renderTarget, |
| const GrPrimitiveProcessor& primProc, |
| const GrPipeline& pipeline, |
| GrPrimitiveType primitiveType, |
| GrMtlGpu* gpu) { |
| if (!INHERITED::Build(desc, renderTarget, primProc, |
| GrPrimitiveType::kLines == primitiveType, pipeline, gpu)) { |
| return false; |
| } |
| |
| GrProcessorKeyBuilder b(&desc->key()); |
| |
| int keyLength = desc->key().count(); |
| SkASSERT(0 == (keyLength % 4)); |
| desc->fShaderKeyLength = SkToU32(keyLength); |
| |
| b.add32(renderTarget->config()); |
| b.add32(renderTarget->numColorSamples()); |
| bool hasStencilAttachment = SkToBool(renderTarget->renderTargetPriv().getStencilAttachment()); |
| b.add32(hasStencilAttachment ? gpu->mtlCaps().preferredStencilFormat().fInternalFormat |
| : MTLPixelFormatInvalid); |
| b.add32((uint32_t)pipeline.isStencilEnabled()); |
| // Stencil samples don't seem to be tracked in the MTLRenderPipeline |
| |
| b.add32(pipeline.getBlendInfoKey()); |
| |
| b.add32((uint32_t)primitiveType); |
| |
| return true; |
| } |
