this->initClassID<DCFP>();
}
- GrGLFragmentProcessor* createGLInstance() const override {
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
class DCGLFP : public GrGLFragmentProcessor {
void emitCode(EmitArgs& args) override {
GrGLFragmentBuilder* fpb = args.fBuilder->getFragmentShaderBuilder();
"%s = color * %s;",
args.fOutputColor, GrGLSLExpr4(args.fInputColor).c_str());
}
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override {}
};
return SkNEW(DCGLFP);
}
'<(skia_src_path)/gpu/gl/GrGLGpu.h',
'<(skia_src_path)/gpu/gl/GrGLGpuProgramCache.cpp',
'<(skia_src_path)/gpu/gl/GrGLExtensions.cpp',
+ '<(skia_src_path)/gpu/gl/GrGLFragmentProcessor.cpp',
+ '<(skia_src_path)/gpu/gl/GrGLFragmentProcessor.h',
'<(skia_src_path)/gpu/gl/GrGLIndexBuffer.cpp',
'<(skia_src_path)/gpu/gl/GrGLIndexBuffer.h',
'<(skia_src_path)/gpu/gl/GrGLInterface.cpp',
: INHERITED()
, fUsesLocalCoords(false) {}
- /** Returns a new instance of the appropriate *GL* implementation class
- for the given GrFragmentProcessor; caller is responsible for deleting
- the object. */
- virtual GrGLFragmentProcessor* createGLInstance() const = 0;
+ GrGLFragmentProcessor* createGLInstance() const;
/** Human-meaningful string to identify this GrFragmentProcessor; may be embedded
in generated shader code. */
virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const = 0;
private:
+ /** Returns a new instance of the appropriate *GL* implementation class
+ for the given GrFragmentProcessor; caller is responsible for deleting
+ the object. */
+ virtual GrGLFragmentProcessor* onCreateGLInstance() const = 0;
+
/** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const = 0;
const char* name() const override { return "Color"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
GrColor color() const { return fColor; }
InputMode inputMode() const { return fMode; }
this->initClassID<GrConstColorProcessor>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
float innerThreshold() const { return fInnerThreshold; }
float outerThreshold() const { return fOuterThreshold; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
AlphaThresholdEffect(GrProcessorDataManager*,
GrTexture* texture,
this->addTextureAccess(&fMaskTextureAccess);
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
(GrGLSLExpr4(args.fInputColor) * GrGLSLExpr4("color")).c_str());
}
-void GrGLAlphaThresholdEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLAlphaThresholdEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const AlphaThresholdEffect& alpha_threshold = proc.cast<AlphaThresholdEffect>();
pdman.set1f(fInnerThresholdVar, alpha_threshold.innerThreshold());
GrGLAlphaThresholdEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* AlphaThresholdEffect::createGLInstance() const {
+GrGLFragmentProcessor* AlphaThresholdEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLAlphaThresholdEffect, (*this));
}
fEnforcePMColor);
}
- void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
- const GrArithmeticFP& arith = proc.cast<GrArithmeticFP>();
- pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
- fEnforcePMColor = arith.enforcePMColor();
- }
-
static void GenKey(const GrProcessor& proc, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) {
const GrArithmeticFP& arith = proc.cast<GrArithmeticFP>();
uint32_t key = arith.enforcePMColor() ? 1 : 0;
b->add32(key);
}
+protected:
+ void onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
+ const GrArithmeticFP& arith = proc.cast<GrArithmeticFP>();
+ pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
+ fEnforcePMColor = arith.enforcePMColor();
+ }
+
private:
GrGLProgramDataManager::UniformHandle fKUni;
bool fEnforcePMColor;
GLArithmeticFP::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrArithmeticFP::createGLInstance() const {
+GrGLFragmentProcessor* GrArithmeticFP::onCreateGLInstance() const {
return SkNEW_ARGS(GLArithmeticFP, (*this));
}
const char* name() const override { return "Arithmetic"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
float k1() const { return fK1; }
float k2() const { return fK2; }
float k3() const { return fK3; }
bool enforcePMColor() const { return fEnforcePMColor; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
const char* name() const override { return "RectBlur"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
/**
* Create a simple filter effect with custom bicubic coefficients.
*/
float getSigma() const { return fSigma; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
GrRectBlurEffect(const SkRect& rect, float sigma, GrTexture *blur_profile);
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrGLRectBlurEffect(const GrProcessor&) {}
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
fsBuilder->codeAppendf("\t%s = src * final;\n", args.fOutputColor );
}
-void GrGLRectBlurEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLRectBlurEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrRectBlurEffect& rbe = proc.cast<GrRectBlurEffect>();
SkRect rect = rbe.getRect();
GrGLRectBlurEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrRectBlurEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrRectBlurEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLRectBlurEffect, (*this));
}
const SkRRect& getRRect() const { return fRRect; }
float getSigma() const { return fSigma; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fProxyRectUniform;
fsBuilder->codeAppend(";\n");
}
-void GrGLRRectBlurEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLRRectBlurEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrRRectBlurEffect& brre = proc.cast<GrRRectBlurEffect>();
SkRRect rrect = brre.getRRect();
GrGLRRectBlurEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrRRectBlurEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrRRectBlurEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLRRectBlurEffect, (*this));
}
const char* name() const override { return "ColorCube"; }
- GrGLFragmentProcessor* createGLInstance() const override;
int colorCubeSize() const { return fColorCubeAccess.getTexture()->width(); }
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+ protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fColorCubeSizeUni;
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override;
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
GrColorCubeEffect(GrTexture* colorCube);
GLProcessor::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrColorCubeEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrColorCubeEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLProcessor, (*this));
}
cubeIdx, nonZeroAlpha, args.fInputColor);
}
-void GrColorCubeEffect::GLProcessor::setData(const GrGLProgramDataManager& pdman,
+void GrColorCubeEffect::GLProcessor::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrColorCubeEffect& colorCube = proc.cast<GrColorCubeEffect>();
SkScalar size = SkIntToScalar(colorCube.colorCubeSize());
return true;
}
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GLProcessor, (*this));
- }
-
const char* name() const override { return "ModeColorFilterEffect"; }
SkXfermode::Mode mode() const { return fMode; }
b->add32(colorModeFilter.mode());
}
- virtual void setData(const GrGLProgramDataManager& pdman,
+ protected:
+ virtual void onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& fp) override {
if (fFilterColorUni.isValid()) {
const ModeColorFilterEffect& colorModeFilter = fp.cast<ModeColorFilterEffect>();
this->initClassID<ModeColorFilterEffect>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GLProcessor, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
const char* name() const override { return "Color Matrix"; }
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GLProcessor, (*this));
- }
-
-
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
class GLProcessor : public GrGLFragmentProcessor {
fsBuilder->codeAppendf("\t%s.rgb *= %s.a;\n", args.fOutputColor, args.fOutputColor);
}
- virtual void setData(const GrGLProgramDataManager& uniManager,
+ protected:
+ virtual void onSetData(const GrGLProgramDataManager& uniManager,
const GrProcessor& proc) override {
const ColorMatrixEffect& cme = proc.cast<ColorMatrixEffect>();
const float* m = cme.fMatrix.fMat;
this->initClassID<ColorMatrixEffect>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GLProcessor, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
const GrTextureDomain::GLDomain& glDomain() const { return fGLDomain; }
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
private:
SkDisplacementMapEffect::ChannelSelectorType fXChannelSelector;
SkDisplacementMapEffect::ChannelSelectorType fYChannelSelector;
virtual ~GrDisplacementMapEffect();
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GrGLDisplacementMapEffect, (*this));
- }
-
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector() const
{ return fXChannelSelector; }
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector() const
const GrTextureDomain& domain() const { return fDomain; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GrGLDisplacementMapEffect, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GrGLDisplacementMapEffect::GenKey(*this, caps, b);
fsBuilder->codeAppend(";\n");
}
-void GrGLDisplacementMapEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLDisplacementMapEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrDisplacementMapEffect& displacementMap = proc.cast<GrDisplacementMapEffect>();
GrTexture* colorTex = displacementMap.texture(1);
const char* name() const override { return "DiffuseLighting"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
SkScalar kd() const { return fKD; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
const char* name() const override { return "SpecularLighting"; }
- GrGLFragmentProcessor* createGLInstance() const override;
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
SkScalar ks() const { return fKS; }
SkScalar shininess() const { return fShininess; }
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
+protected:
/**
- * Subclasses of GrGLLightingEffect must call INHERITED::setData();
+ * Subclasses of GrGLLightingEffect must call INHERITED::onSetData();
*/
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
-protected:
virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) = 0;
private:
public:
GrGLDiffuseLightingEffect(const GrProcessor&);
void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLLightingEffect INHERITED;
public:
GrGLSpecularLightingEffect(const GrProcessor&);
void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLLightingEffect INHERITED;
GrGLDiffuseLightingEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrDiffuseLightingEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLDiffuseLightingEffect, (*this));
}
b->add32(lighting.boundaryMode() << 2 | lighting.light()->type());
}
-void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrLightingEffect& lighting = proc.cast<GrLightingEffect>();
GrTexture* texture = lighting.texture(0);
funcName);
}
-void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLDiffuseLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
- INHERITED::setData(pdman, proc);
+ INHERITED::onSetData(pdman, proc);
const GrDiffuseLightingEffect& diffuse = proc.cast<GrDiffuseLightingEffect>();
pdman.set1f(fKDUni, diffuse.kd());
}
GrGLSpecularLightingEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrSpecularLightingEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLSpecularLightingEffect, (*this));
}
funcName);
}
-void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLSpecularLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& effect) {
- INHERITED::setData(pdman, effect);
+ INHERITED::onSetData(pdman, effect);
const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>();
pdman.set1f(fKSUni, spec.ks());
pdman.set1f(fShininessUni, spec.shininess());
fpb->codeAppendf("%s = vec4(result.rgb, diffuseColor.a);", args.fOutputColor);
}
- void setData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
+ static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
+ GrProcessorKeyBuilder* b) {
+// const LightingFP& lightingFP = proc.cast<LightingFP>();
+ // only one shader generated currently
+ b->add32(0x0);
+ }
+
+ protected:
+ void onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& proc) override {
const LightingFP& lightingFP = proc.cast<LightingFP>();
const SkVector3& lightDir = lightingFP.lightDir();
}
}
- static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
- GrProcessorKeyBuilder* b) {
-// const LightingFP& lightingFP = proc.cast<LightingFP>();
- // only one shader generated currently
- b->add32(0x0);
- }
-
private:
SkVector3 fLightDir;
GrGLProgramDataManager::UniformHandle fLightDirUni;
GrGLProgramDataManager::UniformHandle fAmbientColorUni;
};
- GrGLFragmentProcessor* createGLInstance() const override { return SkNEW(LightingGLFP); }
-
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
LightingGLFP::GenKey(*this, caps, b);
}
const SkColor3f& ambientColor() const { return fAmbientColor; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override { return SkNEW(LightingGLFP); }
+
bool onIsEqual(const GrFragmentProcessor& proc) const override {
const LightingFP& lightingFP = proc.cast<LightingFP>();
return fDeviceTransform == lightingFP.fDeviceTransform &&
const char* name() const override { return "Luminance-to-Alpha"; }
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GLProcessor, (*this));
- }
-
class GLProcessor : public GrGLFragmentProcessor {
public:
GLProcessor(const GrProcessor&) {}
this->initClassID<LumaColorFilterEffect>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GLProcessor, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
const char* name() const override { return "Magnifier"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const SkRect& bounds() const { return fBounds; } // Bounds of source image.
// Offset to apply to zoomed pixels, (srcRect position / texture size).
float x_offset() const { return fXOffset; }
this->initClassID<GrMagnifierEffect>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
UniformHandle fOffsetVar;
fsBuilder->codeAppend(modulate.c_str());
}
-void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLMagnifierEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& effect) {
const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>();
pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset());
GrGLMagnifierEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrMagnifierEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrMagnifierEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLMagnifierEffect, (*this));
}
const char* name() const override { return "Morphology"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
protected:
MorphologyType fType;
float fRange[2];
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
b->add32(key);
}
-void GrGLMorphologyEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLMorphologyEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& proc) {
const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
GrTexture& texture = *m.texture(0);
GrGLMorphologyEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrMorphologyEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrMorphologyEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLMorphologyEffect, (*this));
}
bool GrMorphologyEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
-
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
private:
GrGLProgramDataManager::UniformHandle fStitchDataUni;
const char* name() const override { return "PerlinNoise"; }
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GrGLPerlinNoise, (*this));
- }
-
const SkPerlinNoiseShader::StitchData& stitchData() const { return fPaintingData->fStitchDataInit; }
SkPerlinNoiseShader::Type type() const { return fType; }
uint8_t alpha() const { return fAlpha; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GrGLPerlinNoise, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GrGLPerlinNoise::GenKey(*this, caps, b);
b->add32(key);
}
-void GrGLPerlinNoise::setData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) {
- INHERITED::setData(pdman, processor);
+void GrGLPerlinNoise::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) {
+ INHERITED::onSetData(pdman, processor);
const GrPerlinNoiseEffect& turbulence = processor.cast<GrPerlinNoiseEffect>();
const char* name() const override { return "ColorTable"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const GrTextureStripAtlas* atlas() const { return fAtlas; }
int atlasRow() const { return fRow; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
-
static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {}
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
private:
UniformHandle fRGBAYValuesUni;
typedef GrGLFragmentProcessor INHERITED;
GLColorTableEffect::GLColorTableEffect(const GrProcessor&) {
}
-void GLColorTableEffect::setData(const GrGLProgramDataManager& pdm, const GrProcessor& proc) {
+void GLColorTableEffect::onSetData(const GrGLProgramDataManager& pdm, const GrProcessor& proc) {
// The textures are organized in a strip where the rows are ordered a, r, g, b.
float rgbaYValues[4];
const ColorTableEffect& cte = proc.cast<ColorTableEffect>();
GLColorTableEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* ColorTableEffect::createGLInstance() const {
+GrGLFragmentProcessor* ColorTableEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLColorTableEffect, (*this));
}
a);
}
-void GrGLGradientEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLGradientEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrGradientEffect& e = processor.cast<GrGradientEffect>();
GrGLGradientEffect();
virtual ~GrGLGradientEffect();
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
protected:
/**
const char* name() const override { return "Linear Gradient"; }
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GrGLLinearGradient, (*this));
- }
-
private:
GrLinearGradient(GrContext* ctx,
GrProcessorDataManager* procDataManager,
this->initClassID<GrLinearGradient>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GrGLLinearGradient, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GrGLLinearGradient::GenKey(*this, caps, b);
const char* name() const override { return "Radial Gradient"; }
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GrGLRadialGradient, (*this));
- }
-
private:
GrRadialGradient(GrContext* ctx,
GrProcessorDataManager* procDataManager,
this->initClassID<GrRadialGradient>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GrGLRadialGradient, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GrGLRadialGradient::GenKey(*this, caps, b);
const char* name() const override { return "Sweep Gradient"; }
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GrGLSweepGradient, (*this));
- }
-
private:
GrSweepGradient(GrContext* ctx,
GrProcessorDataManager* procDataManager,
this->initClassID<GrSweepGradient>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GrGLSweepGradient, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GrGLSweepGradient::GenKey(*this, caps, b);
return "Two-Point Conical Gradient Edge Touching";
}
- GrGLFragmentProcessor* createGLInstance() const override;
-
// The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
SkScalar center() const { return fCenterX1; }
SkScalar diffRadius() const { return fDiffRadius; }
SkScalar radius() const { return fRadius0; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& sBase) const override {
virtual ~GLEdge2PtConicalEffect() { }
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
UniformHandle fParamUni;
const char* fVSVaryingName;
GLEdge2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* Edge2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* Edge2PtConicalEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLEdge2PtConicalEffect, (*this));
}
fsBuilder->codeAppend("\t}\n");
}
-void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLEdge2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
- INHERITED::setData(pdman, processor);
+ INHERITED::onSetData(pdman, processor);
const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
SkScalar radius0 = data.radius();
SkScalar diffRadius = data.diffRadius();
return "Two-Point Conical Gradient Focal Outside";
}
- GrGLFragmentProcessor* createGLInstance() const override;
-
bool isFlipped() const { return fIsFlipped; }
SkScalar focal() const { return fFocalX; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& sBase) const override {
virtual ~GLFocalOutside2PtConicalEffect() { }
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
UniformHandle fParamUni;
const char* fVSVaryingName;
GLFocalOutside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* FocalOutside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* FocalOutside2PtConicalEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLFocalOutside2PtConicalEffect, (*this));
}
fsBuilder->codeAppend("\t}\n");
}
-void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLFocalOutside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
- INHERITED::setData(pdman, processor);
+ INHERITED::onSetData(pdman, processor);
const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
SkScalar focal = data.focal();
return "Two-Point Conical Gradient Focal Inside";
}
- GrGLFragmentProcessor* createGLInstance() const override;
-
SkScalar focal() const { return fFocalX; }
typedef GLFocalInside2PtConicalEffect GLProcessor;
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& sBase) const override {
virtual ~GLFocalInside2PtConicalEffect() {}
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
UniformHandle fFocalUni;
const char* fVSVaryingName;
GLFocalInside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* FocalInside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* FocalInside2PtConicalEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLFocalInside2PtConicalEffect, (*this));
}
args.fSamplers);
}
-void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLFocalInside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
- INHERITED::setData(pdman, processor);
+ INHERITED::onSetData(pdman, processor);
const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
SkScalar focal = data.focal();
const char* name() const override { return "Two-Point Conical Gradient Inside"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
SkScalar A() const { return fInfo.fA; }
SkScalar C() const { return fInfo.fC; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override;
virtual ~GLCircleInside2PtConicalEffect() {}
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
UniformHandle fCenterUni;
UniformHandle fParamUni;
GLCircleInside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircleInside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* CircleInside2PtConicalEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLCircleInside2PtConicalEffect, (*this));
}
args.fSamplers);
}
-void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLCircleInside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
- INHERITED::setData(pdman, processor);
+ INHERITED::onSetData(pdman, processor);
const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
SkScalar centerX = data.centerX();
SkScalar centerY = data.centerY();
const char* name() const override { return "Two-Point Conical Gradient Outside"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
SkScalar A() const { return fInfo.fA; }
bool isFlipped() const { return fIsFlipped; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& sBase) const override {
virtual ~GLCircleOutside2PtConicalEffect() {}
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
UniformHandle fCenterUni;
UniformHandle fParamUni;
GLCircleOutside2PtConicalEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircleOutside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* CircleOutside2PtConicalEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLCircleOutside2PtConicalEffect, (*this));
}
fsBuilder->codeAppend("\t}\n");
}
-void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLCircleOutside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
- INHERITED::setData(pdman, processor);
+ INHERITED::onSetData(pdman, processor);
const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
SkScalar centerX = data.centerX();
#include "GrMemoryPool.h"
#include "GrXferProcessor.h"
#include "SkSpinlock.h"
+#include "gl/GrGLFragmentProcessor.h"
#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
return true;
}
+GrGLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
+ GrGLFragmentProcessor* glFragProc = this->onCreateGLInstance();
+ glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
+ for (int i = 0; i < fChildProcessors.count(); ++i) {
+ glFragProc->fChildProcessors[i] = fChildProcessors[i].processor()->createGLInstance();
+ }
+ return glFragProc;
+}
+
void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
fCoordTransforms.push_back(transform);
fUsesLocalCoords = fUsesLocalCoords || transform->sourceCoords() == kLocal_GrCoordSet;
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
-
static inline void GenKey(const GrProcessor& effect, const GrGLSLCaps&,
GrProcessorKeyBuilder* b) {
const GrTextureDomain& domain = effect.cast<GrBicubicEffect>().domain();
b->add32(GrTextureDomain::GLDomain::DomainKey(domain));
}
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
GrGLSLExpr4(args.fInputColor)).c_str());
}
-void GrGLBicubicEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLBicubicEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrBicubicEffect& bicubicEffect = processor.cast<GrBicubicEffect>();
const GrTexture& texture = *processor.texture(0);
GrGLBicubicEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrBicubicEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrBicubicEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLBicubicEffect, (*this));
}
const char* name() const override { return "Bicubic"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const GrTextureDomain& domain() const { return fDomain; }
/**
GrBicubicEffect(GrProcessorDataManager*, GrTexture*, const SkScalar coefficients[16],
const SkMatrix &matrix, const SkRect& domain);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
GrGLConfigConversionEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrConfigConversionEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrConfigConversionEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLConfigConversionEffect, (*this));
}
const char* name() const override { return "Config Conversion"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
bool swapsRedAndBlue() const { return fSwapRedAndBlue; }
PMConversion pmConversion() const { return fPMConversion; }
PMConversion pmConversion,
const SkMatrix& matrix);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
}
}
- void setData(const GrGLProgramDataManager& pdm, const GrProcessor& processor) override {
+protected:
+ void onSetData(const GrGLProgramDataManager& pdm, const GrProcessor& processor) override {
GrColor color = processor.cast<GrConstColorProcessor>().color();
// We use the "illegal" color value as an uninit sentinel. However, ut isn't inherently
// illegal to use this processor with unpremul colors. So we correctly handle the case
b->add32(fMode);
}
-GrGLFragmentProcessor* GrConstColorProcessor::createGLInstance() const {
+GrGLFragmentProcessor* GrConstColorProcessor::onCreateGLInstance() const {
return SkNEW(GLConstColorProcessor);
}
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
AARectEffect(GrPrimitiveEdgeType edgeType, const SkRect& rect)
: fRect(rect), fEdgeType(edgeType) {
this->setWillReadFragmentPosition();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
bool onIsEqual(const GrFragmentProcessor& other) const override {
const AARectEffect& aare = other.cast<AARectEffect>();
return fRect == aare.fRect;
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fRectUniform;
(GrGLSLExpr4(args.fInputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLAARectEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) {
+void GLAARectEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) {
const AARectEffect& aare = processor.cast<AARectEffect>();
const SkRect& rect = aare.getRect();
if (rect != fPrevRect) {
GLAARectEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* AARectEffect::createGLInstance() const {
+GrGLFragmentProcessor* AARectEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLAARectEffect, (*this));
}
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fEdgeUniform;
(GrGLSLExpr4(args.fInputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GrGLConvexPolyEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) {
+void GrGLConvexPolyEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) {
const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>();
size_t byteSize = 3 * cpe.getEdgeCount() * sizeof(SkScalar);
if (0 != memcmp(fPrevEdges, cpe.getEdges(), byteSize)) {
GrGLConvexPolyEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrConvexPolyEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrConvexPolyEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLConvexPolyEffect, (*this));
}
const SkScalar* getEdges() const { return fEdges; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
GrConvexPolyEffect(GrPrimitiveEdgeType edgeType, int n, const SkScalar edges[]);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& other) const override;
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager& pdman, const GrProcessor&) override;
-
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
+protected:
+ void onSetData(const GrGLProgramDataManager& pdman, const GrProcessor&) override;
+
private:
int width() const { return Gr1DKernelEffect::WidthFromRadius(fRadius); }
bool useBounds() const { return fUseBounds; }
fsBuilder->codeAppend(modulate.c_str());
}
-void GrGLConvolutionEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLConvolutionEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrConvolutionEffect& conv = processor.cast<GrConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
GrGLConvolutionEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrConvolutionEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrConvolutionEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLConvolutionEffect, (*this));
}
const char* name() const override { return "Convolution"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
enum {
// This was decided based on the min allowed value for the max texture
// samples per fragment program run in DX9SM2 (32). A sigma param of 4.0
bool useBounds,
float bounds[2]);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
emit_custom_xfermode_code(mode, fsBuilder, args.fOutputColor, args.fInputColor, dstColor);
}
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override {}
-
static void GenKey(const GrFragmentProcessor& proc, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
// The background may come from the dst or from a texture.
uint32_t key = proc.numTextures();
b->add32(key);
}
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override {}
+
private:
typedef GrGLFragmentProcessor INHERITED;
};
GLCustomXferFP::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrCustomXferFP::createGLInstance() const {
+GrGLFragmentProcessor* GrCustomXferFP::onCreateGLInstance() const {
return SkNEW_ARGS(GLCustomXferFP, (*this));
}
void onSetData(const GrGLProgramDataManager&, const GrXferProcessor&) override {}
- typedef GrGLFragmentProcessor INHERITED;
+ typedef GrGLXferProcessor INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
public:
GrCustomXferFP(GrProcessorDataManager*, SkXfermode::Mode mode, GrTexture* background);
- GrGLFragmentProcessor* createGLInstance() const override;
-
const char* name() const override { return "Custom Xfermode"; }
SkXfermode::Mode mode() const { return fMode; }
const GrTextureAccess& backgroundAccess() const { return fBackgroundAccess; }
private:
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
bool onIsEqual(const GrFragmentProcessor& other) const override;
const char* name() const override { return "Dither"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
DitherEffect() {
this->initClassID<DitherEffect>();
this->setWillReadFragmentPosition();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
// All dither effects are equal
GLDitherEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* DitherEffect::createGLInstance() const {
+GrGLFragmentProcessor* DitherEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLDitherEffect, (*this));
}
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
b->add32(GrTextureDomain::GLDomain::DomainKey(m.domain()));
}
-void GrGLMatrixConvolutionEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLMatrixConvolutionEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrMatrixConvolutionEffect& conv = processor.cast<GrMatrixConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
GrGLMatrixConvolutionEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrMatrixConvolutionEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrMatrixConvolutionEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLMatrixConvolutionEffect, (*this));
}
const char* name() const override { return "MatrixConvolution"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
GrMatrixConvolutionEffect(GrProcessorDataManager*,
GrTexture*,
GrTextureDomain::Mode tileMode,
bool convolveAlpha);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
const char* name() const override { return "Circle"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const SkPoint& getCenter() const { return fCenter; }
SkScalar getRadius() const { return fRadius; }
private:
CircleEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar radius);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fCircleUniform;
b->add32(ce.getEdgeType());
}
-void GLCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) {
+void GLCircleEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& processor) {
const CircleEffect& ce = processor.cast<CircleEffect>();
if (ce.getRadius() != fPrevRadius || ce.getCenter() != fPrevCenter) {
SkScalar radius = ce.getRadius();
GLCircleEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircleEffect::createGLInstance() const {
+GrGLFragmentProcessor* CircleEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLCircleEffect, (*this));
}
const char* name() const override { return "Ellipse"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const SkPoint& getCenter() const { return fCenter; }
SkVector getRadii() const { return fRadii; }
private:
EllipseEffect(GrPrimitiveEdgeType, const SkPoint& center, SkScalar rx, SkScalar ry);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fEllipseUniform;
b->add32(ee.getEdgeType());
}
-void GLEllipseEffect::setData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) {
+void GLEllipseEffect::onSetData(const GrGLProgramDataManager& pdman, const GrProcessor& effect) {
const EllipseEffect& ee = effect.cast<EllipseEffect>();
if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) {
SkScalar invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX);
GLEllipseEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* EllipseEffect::createGLInstance() const {
+GrGLFragmentProcessor* EllipseEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLEllipseEffect, (*this));
}
const char* name() const override { return "CircularRRect"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const SkRRect& getRRect() const { return fRRect; }
uint32_t getCircularCornerFlags() const { return fCircularCornerFlags; }
private:
CircularRRectEffect(GrPrimitiveEdgeType, uint32_t circularCornerFlags, const SkRRect&);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& other) const override;
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fInnerRectUniform;
b->add32((crre.getCircularCornerFlags() << 3) | crre.getEdgeType());
}
-void GLCircularRRectEffect::setData(const GrGLProgramDataManager& pdman,
+void GLCircularRRectEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
const CircularRRectEffect& crre = processor.cast<CircularRRectEffect>();
const SkRRect& rrect = crre.getRRect();
GLCircularRRectEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* CircularRRectEffect::createGLInstance() const {
+GrGLFragmentProcessor* CircularRRectEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLCircularRRectEffect, (*this));
}
const char* name() const override { return "EllipticalRRect"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const SkRRect& getRRect() const { return fRRect; }
GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
private:
EllipticalRRectEffect(GrPrimitiveEdgeType, const SkRRect&);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& other) const override;
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
private:
GrGLProgramDataManager::UniformHandle fInnerRectUniform;
b->add32(erre.getRRect().getType() | erre.getEdgeType() << 3);
}
-void GLEllipticalRRectEffect::setData(const GrGLProgramDataManager& pdman,
+void GLEllipticalRRectEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& effect) {
const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
const SkRRect& rrect = erre.getRRect();
GLEllipticalRRectEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* EllipticalRRectEffect::createGLInstance() const {
+GrGLFragmentProcessor* EllipticalRRectEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GLEllipticalRRectEffect, (*this));
}
GrGLSimpleTextureEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrSimpleTextureEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrSimpleTextureEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLSimpleTextureEffect, (*this));
}
const char* name() const override { return "SimpleTexture"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
private:
GrSimpleTextureEffect(GrProcessorDataManager* procDataManager,
GrTexture* texture,
this->initClassID<GrSimpleTextureEffect>();
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor& other) const override { return true; }
virtual void emitCode(EmitArgs&) override;
- void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
-
static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*);
+protected:
+ void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
private:
GrTextureDomain::GLDomain fGLDomain;
typedef GrGLFragmentProcessor INHERITED;
args.fInputColor);
}
-void GrGLTextureDomainEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLTextureDomainEffect::onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) {
const GrTextureDomainEffect& textureDomainEffect = processor.cast<GrTextureDomainEffect>();
const GrTextureDomain& domain = textureDomainEffect.textureDomain();
GrGLTextureDomainEffect::GenKey(*this, caps, b);
}
-GrGLFragmentProcessor* GrTextureDomainEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrTextureDomainEffect::onCreateGLInstance() const {
return SkNEW_ARGS(GrGLTextureDomainEffect, (*this));
}
const char* name() const override { return "TextureDomain"; }
- GrGLFragmentProcessor* createGLInstance() const override;
-
const GrTextureDomain& textureDomain() const { return fTextureDomain; }
protected:
GrTextureParams::FilterMode,
GrCoordSet);
+ GrGLFragmentProcessor* onCreateGLInstance() const override;
+
void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
bool onIsEqual(const GrFragmentProcessor&) const override;
fsBuilder->codeAppendf(".r,\n\t\t1.0) * %s;\n", yuvMatrix);
}
- virtual void setData(const GrGLProgramDataManager& pdman,
+ protected:
+ virtual void onSetData(const GrGLProgramDataManager& pdman,
const GrProcessor& processor) override {
const YUVtoRGBEffect& yuvEffect = processor.cast<YUVtoRGBEffect>();
switch (yuvEffect.getColorSpace()) {
typedef GrGLFragmentProcessor INHERITED;
};
- GrGLFragmentProcessor* createGLInstance() const override {
- return SkNEW_ARGS(GLProcessor, (*this));
- }
-
private:
YUVtoRGBEffect(GrProcessorDataManager*, GrTexture* yTexture, GrTexture* uTexture,
GrTexture* vTexture, const SkMatrix yuvMatrix[3],
this->addTextureAccess(&fVAccess);
}
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
+ return SkNEW_ARGS(GLProcessor, (*this));
+ }
+
virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
GrProcessorKeyBuilder* b) const override {
GLProcessor::GenKey(*this, caps, b);
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrGLFragmentProcessor.h"
+#include "GrFragmentProcessor.h"
+
+void GrGLFragmentProcessor::setData(const GrGLProgramDataManager& pdman,
+ const GrFragmentProcessor& processor) {
+ this->onSetData(pdman, processor);
+ SkASSERT(fChildProcessors.count() == processor.numChildProcessors());
+ for (int i = 0; i < fChildProcessors.count(); ++i) {
+ fChildProcessors[i]->setData(pdman, processor.childProcessor(i));
+ }
+}
public:
GrGLFragmentProcessor() {}
- virtual ~GrGLFragmentProcessor() {}
+ virtual ~GrGLFragmentProcessor() {
+ for (int i = 0; i < fChildProcessors.count(); ++i) {
+ SkDELETE(fChildProcessors[i]);
+ }
+ }
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
typedef GrGLProcessor::TransformedCoordsArray TransformedCoordsArray;
virtual void emitCode(EmitArgs&) = 0;
- /** A GrGLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces
- the same stage key; this function reads data from a GrFragmentProcessor and uploads any
- uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor
- parameter is guaranteed to be of the same type that created this GrGLFragmentProcessor and
- to have an identical processor key as the one that created this GrGLFragmentProcessor. */
- // TODO update this to pass in GrFragmentProcessor
- virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) {}
+ void setData(const GrGLProgramDataManager& pdman, const GrFragmentProcessor& processor);
static void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder*) {}
+ int numChildProcessors() const { return fChildProcessors.count(); }
+
+ GrGLFragmentProcessor* childProcessor(int index) const {
+ return fChildProcessors[index];
+ }
+
+protected:
+ /** A GrGLFragmentProcessor instance can be reused with any GrFragmentProcessor that produces
+ the same stage key; this function reads data from a GrFragmentProcessor and uploads any
+ uniform variables required by the shaders created in emitCode(). The GrFragmentProcessor
+ parameter is guaranteed to be of the same type that created this GrGLFragmentProcessor and
+ to have an identical processor key as the one that created this GrGLFragmentProcessor. */
+ // TODO update this to pass in GrFragmentProcessor
+ virtual void onSetData(const GrGLProgramDataManager&, const GrProcessor&) {}
+
private:
+ SkTArray<GrGLFragmentProcessor*, true> fChildProcessors;
+
+ friend class GrFragmentProcessor;
typedef GrGLProcessor INHERITED;
};
int numProcessors = fFragmentProcessors->fProcs.count();
for (int e = 0; e < numProcessors; ++e) {
const GrPendingFragmentStage& stage = pipeline.getFragmentStage(e);
- const GrProcessor& processor = *stage.processor();
+ const GrFragmentProcessor& processor = *stage.processor();
fFragmentProcessors->fProcs[e]->fGLProc->setData(fProgramDataManager, processor);
this->setTransformData(primProc,
stage,
const char* name() const override { return "Big Ole Key"; }
- GrGLFragmentProcessor* createGLInstance() const override {
+ GrGLFragmentProcessor* onCreateGLInstance() const override {
return SkNEW_ARGS(GLBigKeyProcessor, (*this));
}
projects / platform / upstream / libSkiaSharp.git / commitdiff