| /* |
| * Copyright 2015 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef GrGLSLProgramBuilder_DEFINED |
| #define GrGLSLProgramBuilder_DEFINED |
| |
| #include "include/private/base/SkDebug.h" |
| #include "include/private/base/SkTArray.h" |
| #include "include/private/gpu/ganesh/GrTypesPriv.h" |
| #include "src/gpu/Swizzle.h" |
| #include "src/gpu/ganesh/GrCaps.h" |
| #include "src/gpu/ganesh/GrFragmentProcessor.h" |
| #include "src/gpu/ganesh/GrGeometryProcessor.h" |
| #include "src/gpu/ganesh/GrPipeline.h" |
| #include "src/gpu/ganesh/GrProgramInfo.h" |
| #include "src/gpu/ganesh/GrSamplerState.h" |
| #include "src/gpu/ganesh/GrShaderVar.h" |
| #include "src/gpu/ganesh/GrXferProcessor.h" |
| #include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h" |
| #include "src/gpu/ganesh/glsl/GrGLSLUniformHandler.h" |
| #include "src/gpu/ganesh/glsl/GrGLSLVertexGeoBuilder.h" |
| |
| #include <cstdint> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| class GrBackendFormat; |
| class GrGLSLVaryingHandler; |
| class GrProgramDesc; |
| class SkString; |
| enum GrSurfaceOrigin : int; |
| struct GrShaderCaps; |
| |
| class GrGLSLProgramBuilder { |
| public: |
| using UniformHandle = GrGLSLUniformHandler::UniformHandle; |
| using SamplerHandle = GrGLSLUniformHandler::SamplerHandle; |
| |
| virtual ~GrGLSLProgramBuilder(); |
| |
| virtual const GrCaps* caps() const = 0; |
| const GrShaderCaps* shaderCaps() const { return this->caps()->shaderCaps(); } |
| |
| GrSurfaceOrigin origin() const { return fProgramInfo.origin(); } |
| const GrPipeline& pipeline() const { return fProgramInfo.pipeline(); } |
| const GrGeometryProcessor& geometryProcessor() const { return fProgramInfo.geomProc(); } |
| bool snapVerticesToPixelCenters() const { |
| return fProgramInfo.pipeline().snapVerticesToPixelCenters(); |
| } |
| bool hasPointSize() const { return fProgramInfo.primitiveType() == GrPrimitiveType::kPoints; } |
| |
| const GrProgramDesc& desc() const { return fDesc; } |
| |
| void appendUniformDecls(GrShaderFlags visibility, SkString*) const; |
| |
| const char* samplerVariable(SamplerHandle handle) const { |
| return this->uniformHandler()->samplerVariable(handle); |
| } |
| |
| skgpu::Swizzle samplerSwizzle(SamplerHandle handle) const { |
| return this->uniformHandler()->samplerSwizzle(handle); |
| } |
| |
| const char* inputSamplerVariable(SamplerHandle handle) const { |
| return this->uniformHandler()->inputSamplerVariable(handle); |
| } |
| |
| skgpu::Swizzle inputSamplerSwizzle(SamplerHandle handle) const { |
| return this->uniformHandler()->inputSamplerSwizzle(handle); |
| } |
| |
| // Used to add a uniform for render target flip (used for dFdy, sk_Clockwise, and sk_FragCoord) |
| // without mangling the name of the uniform inside of a stage. |
| void addRTFlipUniform(const char* name); |
| |
| // Generates a name for a variable. The generated string will be name prefixed by the prefix |
| // char (unless the prefix is '\0'). It also will mangle the name to be stage-specific unless |
| // explicitly asked not to. `nameVariable` can also be used to generate names for functions or |
| // other types of symbols where unique names are important. |
| SkString nameVariable(char prefix, const char* name, bool mangle = true); |
| |
| /** |
| * Emits samplers for TextureEffect fragment processors as needed. `fp` can be a TextureEffect, |
| * or a tree containing zero or more TextureEffects. |
| */ |
| bool emitTextureSamplersForFPs(const GrFragmentProcessor& fp, |
| GrFragmentProcessor::ProgramImpl& impl, |
| int* samplerIndex); |
| |
| /** |
| * advanceStage is called by program creator between each processor's emit code. It increments |
| * the stage index for variable name mangling, and also ensures verification variables in the |
| * fragment shader are cleared. |
| */ |
| void advanceStage() { |
| fStageIndex++; |
| SkDEBUGCODE(fFS.debugOnly_resetPerStageVerification();) |
| fFS.nextStage(); |
| } |
| |
| /** Adds the SkSL function that implements an FP assuming its children are already written. */ |
| void writeFPFunction(const GrFragmentProcessor& fp, GrFragmentProcessor::ProgramImpl& impl); |
| |
| /** |
| * Returns a function-call invocation of `fp` in string form, passing the appropriate |
| * combination of `inputColor`, `destColor` and `fLocalCoordsVar` for the FP. |
| */ |
| std::string invokeFP(const GrFragmentProcessor& fp, |
| const GrFragmentProcessor::ProgramImpl& impl, |
| const char* inputColor, |
| const char* destColor, |
| const char* coords) const; |
| /** |
| * If the FP's coords are unused or all uses have been lifted to interpolated varyings then |
| * don't put coords in the FP's function signature or call sites. |
| */ |
| bool fragmentProcessorHasCoordsParam(const GrFragmentProcessor*) const; |
| |
| virtual GrGLSLUniformHandler* uniformHandler() = 0; |
| virtual const GrGLSLUniformHandler* uniformHandler() const = 0; |
| virtual GrGLSLVaryingHandler* varyingHandler() = 0; |
| |
| // Used for backend customization of the secondary color variable from the fragment processor. |
| // Only used if the output is explicitly declared in the shaders. |
| virtual void finalizeFragmentSecondaryColor(GrShaderVar& outputColor) {} |
| |
| // number of each input/output type in a single allocation block, used by many builders |
| static const int kVarsPerBlock; |
| |
| GrGLSLVertexBuilder fVS; |
| GrGLSLFragmentShaderBuilder fFS; |
| |
| const GrProgramDesc& fDesc; |
| const GrProgramInfo& fProgramInfo; |
| |
| GrGLSLBuiltinUniformHandles fUniformHandles; |
| |
| std::unique_ptr<GrGeometryProcessor::ProgramImpl> fGPImpl; |
| std::unique_ptr<GrXferProcessor::ProgramImpl> fXPImpl; |
| std::vector<std::unique_ptr<GrFragmentProcessor::ProgramImpl>> fFPImpls; |
| |
| SamplerHandle fDstTextureSamplerHandle; |
| GrSurfaceOrigin fDstTextureOrigin; |
| |
| protected: |
| explicit GrGLSLProgramBuilder(const GrProgramDesc&, const GrProgramInfo&); |
| |
| void addFeature(GrShaderFlags shaders, uint32_t featureBit, const char* extensionName); |
| |
| bool emitAndInstallProcs(); |
| |
| void finalizeShaders(); |
| |
| bool fragColorIsInOut() const { return fFS.primaryColorOutputIsInOut(); } |
| |
| private: |
| SkString getMangleSuffix() const; |
| |
| // Generates a possibly mangled name for a stage variable and writes it to the fragment shader. |
| void nameExpression(SkString*, const char* baseName); |
| |
| bool emitAndInstallPrimProc(SkString* outputColor, SkString* outputCoverage); |
| bool emitAndInstallDstTexture(); |
| /** Adds the root FPs */ |
| bool emitAndInstallFragProcs(SkString* colorInOut, SkString* coverageInOut); |
| /** Adds a single root FP tree. */ |
| SkString emitRootFragProc(const GrFragmentProcessor& fp, |
| GrFragmentProcessor::ProgramImpl& impl, |
| const SkString& input, |
| SkString output); |
| /** Recursive step to write out children FPs' functions before parent's. */ |
| void writeChildFPFunctions(const GrFragmentProcessor& fp, |
| GrFragmentProcessor::ProgramImpl& impl); |
| bool emitAndInstallXferProc(const SkString& colorIn, const SkString& coverageIn); |
| SamplerHandle emitSampler(const GrBackendFormat&, GrSamplerState, const skgpu::Swizzle&, |
| const char* name); |
| SamplerHandle emitInputSampler(const skgpu::Swizzle& swizzle, const char* name); |
| bool checkSamplerCounts(); |
| |
| #ifdef SK_DEBUG |
| void verify(const GrGeometryProcessor&); |
| void verify(const GrFragmentProcessor&); |
| void verify(const GrXferProcessor&); |
| #endif |
| |
| // This is used to check that we don't excede the allowable number of resources in a shader. |
| int fNumFragmentSamplers; |
| |
| GrGeometryProcessor::ProgramImpl::FPCoordsMap fFPCoordsMap; |
| GrShaderVar fLocalCoordsVar; |
| |
| /** |
| * Each root processor has an stage index. The GP is stage 0. The first root FP is stage 1, |
| * the second root FP is stage 2, etc. The XP's stage index is last and its value depends on |
| * how many root FPs there are. Names are mangled by appending _S<stage-index>. |
| */ |
| int fStageIndex = -1; |
| |
| /** |
| * When emitting FP stages we track the children FPs as "substages" and do additional name |
| * mangling based on where in the FP hierarchy we are. The first FP is stage index 1. It's first |
| * child would be substage 0 of stage 1. If that FP also has three children then its third child |
| * would be substage 2 of stubstage 0 of stage 1 and would be mangled as "_S1_c0_c2". |
| */ |
| skia_private::TArray<int> fSubstageIndices; |
| }; |
| |
| #endif |