1 /* 2 * Copyright 2013 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 #ifndef GrGLSLFragmentProcessor_DEFINED 9 #define GrGLSLFragmentProcessor_DEFINED 10 11 #include "GrFragmentProcessor.h" 12 #include "GrShaderVar.h" 13 #include "glsl/GrGLSLProgramDataManager.h" 14 #include "glsl/GrGLSLUniformHandler.h" 15 16 class GrProcessor; 17 class GrProcessorKeyBuilder; 18 class GrGLSLFPBuilder; 19 class GrGLSLFPFragmentBuilder; 20 21 class GrGLSLFragmentProcessor { 22 public: 23 GrGLSLFragmentProcessor() {} 24 25 virtual ~GrGLSLFragmentProcessor() { 26 for (int i = 0; i < fChildProcessors.count(); ++i) { 27 delete fChildProcessors[i]; 28 } 29 } 30 31 using UniformHandle = GrGLSLUniformHandler::UniformHandle; 32 using SamplerHandle = GrGLSLUniformHandler::SamplerHandle; 33 using TexelBufferHandle = GrGLSLUniformHandler::TexelBufferHandle; 34 35 private: 36 /** 37 * This class allows the shader builder to provide each GrGLSLFragmentProcesor with an array of 38 * generated variables where each generated variable corresponds to an element of an array on 39 * the GrFragmentProcessor that generated the GLSLFP. For example, this is used to provide a 40 * variable holding transformed coords for each GrCoordTransform owned by the FP. 41 */ 42 template <typename T, typename FPBASE, int (FPBASE::*COUNT)() const> 43 class BuilderInputProvider { 44 public: 45 BuilderInputProvider(const GrFragmentProcessor* fp, const T* ts) : fFP(fp) , fTs(ts) {} 46 47 const T& operator[] (int i) const { 48 SkASSERT(i >= 0 && i < (fFP->*COUNT)()); 49 return fTs[i]; 50 } 51 52 BuilderInputProvider childInputs(int childIdx) const { 53 const GrFragmentProcessor* child = &fFP->childProcessor(childIdx); 54 GrFragmentProcessor::Iter iter(fFP); 55 int numToSkip = 0; 56 while (true) { 57 const GrFragmentProcessor* fp = iter.next(); 58 if (fp == child) { 59 return BuilderInputProvider(child, fTs + numToSkip); 60 } 61 numToSkip += (fp->*COUNT)(); 62 } 63 } 64 65 private: 66 const GrFragmentProcessor* fFP; 67 const T* fTs; 68 }; 69 70 public: 71 using TransformedCoordVars = BuilderInputProvider<GrShaderVar, GrFragmentProcessor, 72 &GrFragmentProcessor::numCoordTransforms>; 73 using TextureSamplers = BuilderInputProvider<SamplerHandle, GrResourceIOProcessor, 74 &GrResourceIOProcessor::numTextureSamplers>; 75 using TexelBuffers = BuilderInputProvider<TexelBufferHandle, GrResourceIOProcessor, 76 &GrResourceIOProcessor::numBuffers>; 77 78 /** Called when the program stage should insert its code into the shaders. The code in each 79 shader will be in its own block ({}) and so locally scoped names will not collide across 80 stages. 81 82 @param fragBuilder Interface used to emit code in the shaders. 83 @param fp The processor that generated this program stage. 84 @param key The key that was computed by GenKey() from the generating 85 GrProcessor. 86 @param outputColor A predefined half4 in the FS in which the stage should place its 87 output color (or coverage). 88 @param inputColor A half4 that holds the input color to the stage in the FS. This may 89 be nullptr in which case the implied input is solid white (all 90 ones). TODO: Better system for communicating optimization info 91 (e.g. input color is solid white, trans black, known to be opaque, 92 etc.) that allows the processor to communicate back similar known 93 info about its output. 94 @param transformedCoords Fragment shader variables containing the coords computed using 95 each of the GrFragmentProcessor's GrCoordTransforms. 96 @param texSamplers Contains one entry for each TextureSampler of the GrProcessor. 97 These can be passed to the builder to emit texture reads in the 98 generated code. 99 @param bufferSamplers Contains one entry for each BufferAccess of the GrProcessor. These 100 can be passed to the builder to emit buffer reads in the generated 101 code. 102 */ 103 struct EmitArgs { 104 EmitArgs(GrGLSLFPFragmentBuilder* fragBuilder, 105 GrGLSLUniformHandler* uniformHandler, 106 const GrShaderCaps* caps, 107 const GrFragmentProcessor& fp, 108 const char* outputColor, 109 const char* inputColor, 110 const TransformedCoordVars& transformedCoordVars, 111 const TextureSamplers& textureSamplers, 112 const TexelBuffers& texelBuffers) 113 : fFragBuilder(fragBuilder) 114 , fUniformHandler(uniformHandler) 115 , fShaderCaps(caps) 116 , fFp(fp) 117 , fOutputColor(outputColor) 118 , fInputColor(inputColor) 119 , fTransformedCoords(transformedCoordVars) 120 , fTexSamplers(textureSamplers) 121 , fTexelBuffers(texelBuffers) {} 122 GrGLSLFPFragmentBuilder* fFragBuilder; 123 GrGLSLUniformHandler* fUniformHandler; 124 const GrShaderCaps* fShaderCaps; 125 const GrFragmentProcessor& fFp; 126 const char* fOutputColor; 127 const char* fInputColor; 128 const TransformedCoordVars& fTransformedCoords; 129 const TextureSamplers& fTexSamplers; 130 const TexelBuffers& fTexelBuffers; 131 }; 132 133 virtual void emitCode(EmitArgs&) = 0; 134 135 void setData(const GrGLSLProgramDataManager& pdman, const GrFragmentProcessor& processor); 136 137 int numChildProcessors() const { return fChildProcessors.count(); } 138 139 GrGLSLFragmentProcessor* childProcessor(int index) { 140 return fChildProcessors[index]; 141 } 142 143 inline void emitChild(int childIndex, SkString* outputColor, EmitArgs& parentArgs) { 144 this->emitChild(childIndex, "half4(1.0)", outputColor, parentArgs); 145 } 146 147 /** Will emit the code of a child proc in its own scope. Pass in the parent's EmitArgs and 148 * emitChild will automatically extract the coords and samplers of that child and pass them 149 * on to the child's emitCode(). Also, any uniforms or functions emitted by the child will 150 * have their names mangled to prevent redefinitions. The output color name is also mangled 151 * therefore in an in/out param. It will be declared in mangled form by emitChild(). It is 152 * legal to pass nullptr as inputColor, since all fragment processors are required to work 153 * without an input color. 154 */ 155 void emitChild(int childIndex, const char* inputColor, SkString* outputColor, 156 EmitArgs& parentArgs); 157 158 inline void emitChild(int childIndex, EmitArgs& args) { 159 this->emitChild(childIndex, "half4(1.0)", args); 160 } 161 162 /** Variation that uses the parent's output color variable to hold the child's output.*/ 163 void emitChild(int childIndex, const char* inputColor, EmitArgs& parentArgs); 164 165 /** 166 * Pre-order traversal of a GLSLFP hierarchy, or of multiple trees with roots in an array of 167 * GLSLFPS. This agrees with the traversal order of GrFragmentProcessor::Iter 168 */ 169 class Iter : public SkNoncopyable { 170 public: 171 explicit Iter(GrGLSLFragmentProcessor* fp) { fFPStack.push_back(fp); } 172 explicit Iter(GrGLSLFragmentProcessor* fps[], int cnt) { 173 for (int i = cnt - 1; i >= 0; --i) { 174 fFPStack.push_back(fps[i]); 175 } 176 } 177 GrGLSLFragmentProcessor* next(); 178 179 private: 180 SkSTArray<4, GrGLSLFragmentProcessor*, true> fFPStack; 181 }; 182 183 protected: 184 /** A GrGLSLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces 185 the same stage key; this function reads data from a GrFragmentProcessor and uploads any 186 uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor 187 parameter is guaranteed to be of the same type that created this GrGLSLFragmentProcessor and 188 to have an identical processor key as the one that created this GrGLSLFragmentProcessor. */ 189 virtual void onSetData(const GrGLSLProgramDataManager&, const GrFragmentProcessor&) {} 190 191 private: 192 void internalEmitChild(int, const char*, const char*, EmitArgs&); 193 194 SkTArray<GrGLSLFragmentProcessor*, true> fChildProcessors; 195 196 friend class GrFragmentProcessor; 197 }; 198 199 #endif 200
