Add more specialized fragment builders

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 642 matching lines @@
 
     /**
      * These two functions are called from GrGLLightingEffect's emitCode() function.
      * emitSurfaceToLight places an expression in param out that is the vector from the surface to
      * the light. The expression will be used in the FS. emitLightColor writes an expression into
      * the FS that is the color of the light. Either function may add functions and/or uniforms to
      * the FS. The default of emitLightColor appends the name of the constant light color uniform
      * and so this function only needs to be overridden if the light color varies spatially.
      */
     virtual void emitSurfaceToLight(GrGLSLUniformHandler*,
-                                    GrGLSLFragmentBuilder*,
+                                    GrGLSLFPFragmentBuilder*,
                                     const char* z) = 0;
     virtual void emitLightColor(GrGLSLUniformHandler*,
-                                GrGLSLFragmentBuilder*,
+                                GrGLSLFPFragmentBuilder*,
                                 const char *surfaceToLight);
 
     // This is called from GrGLLightingEffect's setData(). Subclasses of GrGLLight must call
     // INHERITED::setData().
     virtual void setData(const GrGLSLProgramDataManager&, const SkImageFilterLight* light) const;
 
 protected:
     /**
      * Gets the constant light color uniform. Subclasses can use this in their emitLightColor
      * function.
      */
     UniformHandle lightColorUni() const { return fColorUni; }
 
 private:
     UniformHandle fColorUni;
 
     typedef SkRefCnt INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistantLight : public GrGLLight {
 public:
     virtual ~GrGLDistantLight() {}
     void setData(const GrGLSLProgramDataManager&, const SkImageFilterLight* light) const override;
-    void emitSurfaceToLight(GrGLSLUniformHandler*, GrGLSLFragmentBuilder*, const char* z) override;
+    void emitSurfaceToLight(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, const char* z) override;
 
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fDirectionUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLPointLight : public GrGLLight {
 public:
     virtual ~GrGLPointLight() {}
     void setData(const GrGLSLProgramDataManager&, const SkImageFilterLight* light) const override;
-    void emitSurfaceToLight(GrGLSLUniformHandler*, GrGLSLFragmentBuilder*, const char* z) override;
+    void emitSurfaceToLight(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, const char* z) override;
 
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fLocationUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpotLight : public GrGLLight {
 public:
     virtual ~GrGLSpotLight() {}
     void setData(const GrGLSLProgramDataManager&, const SkImageFilterLight* light) const override;
-    void emitSurfaceToLight(GrGLSLUniformHandler*, GrGLSLFragmentBuilder*, const char* z) override;
+    void emitSurfaceToLight(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, const char* z) override;
     void emitLightColor(GrGLSLUniformHandler*,
-                        GrGLSLFragmentBuilder*,
+                        GrGLSLFPFragmentBuilder*,
                         const char *surfaceToLight) override;
 
 private:
     typedef GrGLLight INHERITED;
 
     SkString        fLightColorFunc;
     UniformHandle   fLocationUni;
     UniformHandle   fExponentUni;
     UniformHandle   fCosOuterConeAngleUni;
     UniformHandle   fCosInnerConeAngleUni;
@@ skipping 846 matching lines @@
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
 
 protected:
     /**
      * Subclasses of GrGLLightingEffect must call INHERITED::onSetData();
      */
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
     virtual void emitLightFunc(GrGLSLUniformHandler*,
-                               GrGLSLFragmentBuilder*,
+                               GrGLSLFPFragmentBuilder*,
                                SkString* funcName) = 0;
 
 private:
     typedef GrGLSLFragmentProcessor INHERITED;
 
     UniformHandle              fImageIncrementUni;
     UniformHandle              fSurfaceScaleUni;
     GrTextureDomain::GLDomain  fDomain;
     GrGLLight*                 fLight;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
-    void emitLightFunc(GrGLSLUniformHandler*, GrGLSLFragmentBuilder*, SkString* funcName) override;
+    void emitLightFunc(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, SkString* funcName) override;
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKDUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpecularLightingEffect  : public GrGLLightingEffect {
 public:
-    void emitLightFunc(GrGLSLUniformHandler*, GrGLSLFragmentBuilder*, SkString* funcName) override;
+    void emitLightFunc(GrGLSLUniformHandler*, GrGLSLFPFragmentBuilder*, SkString* funcName) override;
 
 protected:
     void onSetData(const GrGLSLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKSUni;
     UniformHandle   fShininessUni;
 };
@@ skipping 101 matching lines @@
     }
 
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     fImageIncrementUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                     kVec2f_GrSLType, kDefault_GrSLPrecision,
                                                     "ImageIncrement");
     fSurfaceScaleUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                   kFloat_GrSLType, kDefault_GrSLPrecision,
                                                   "SurfaceScale");
     fLight->emitLightColorUniform(uniformHandler);
-    GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
+    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString lightFunc;
     this->emitLightFunc(uniformHandler, fragBuilder, &lightFunc);
     static const GrGLSLShaderVar gSobelArgs[] =  {
         GrGLSLShaderVar("a", kFloat_GrSLType),
         GrGLSLShaderVar("b", kFloat_GrSLType),
         GrGLSLShaderVar("c", kFloat_GrSLType),
         GrGLSLShaderVar("d", kFloat_GrSLType),
         GrGLSLShaderVar("e", kFloat_GrSLType),
         GrGLSLShaderVar("f", kFloat_GrSLType),
         GrGLSLShaderVar("scale", kFloat_GrSLType),
@@ skipping 96 matching lines @@
                                             lighting.light()->transform(lighting.filterMatrix()));
     fDomain.setData(pdman, lighting.domain(), texture->origin());
     fLight->setData(pdman, transformedLight);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLDiffuseLightingEffect::emitLightFunc(GrGLSLUniformHandler* uniformHandler,
-                                              GrGLSLFragmentBuilder* fragBuilder,
+                                              GrGLSLFPFragmentBuilder* fragBuilder,
                                               SkString* funcName) {
     const char* kd;
     fKDUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                  kFloat_GrSLType, kDefault_GrSLPrecision,
                                  "KD", &kd);
 
     static const GrGLSLShaderVar gLightArgs[] = {
         GrGLSLShaderVar("normal", kVec3f_GrSLType),
         GrGLSLShaderVar("surfaceToLight", kVec3f_GrSLType),
         GrGLSLShaderVar("lightColor", kVec3f_GrSLType)
@@ skipping 68 matching lines @@
                                           d->fRandom->nextRangeU(0, tex->width()),
                                           d->fRandom->nextRangeU(0, tex->height()));
     return GrSpecularLightingEffect::Create(d->fTextures[GrProcessorUnitTest::kAlphaTextureIdx],
                                             light, surfaceScale, matrix, ks, shininess, mode,
                                             &srcBounds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLSpecularLightingEffect::emitLightFunc(GrGLSLUniformHandler* uniformHandler,
-                                               GrGLSLFragmentBuilder* fragBuilder,
+                                               GrGLSLFPFragmentBuilder* fragBuilder,
                                                SkString* funcName) {
     const char* ks;
     const char* shininess;
 
     fKSUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                         kFloat_GrSLType, kDefault_GrSLPrecision, "KS", &ks);
     fShininessUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                kFloat_GrSLType,
                                                kDefault_GrSLPrecision,
                                                "Shininess",
@@ skipping 26 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 void GrGLLight::emitLightColorUniform(GrGLSLUniformHandler* uniformHandler) {
     fColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                            kVec3f_GrSLType, kDefault_GrSLPrecision,
                                            "LightColor");
 }
 
 void GrGLLight::emitLightColor(GrGLSLUniformHandler* uniformHandler,
-                               GrGLSLFragmentBuilder* fragBuilder,
+                               GrGLSLFPFragmentBuilder* fragBuilder,
                                const char *surfaceToLight) {
     fragBuilder->codeAppend(uniformHandler->getUniformCStr(this->lightColorUni()));
 }
 
 void GrGLLight::setData(const GrGLSLProgramDataManager& pdman,
                         const SkImageFilterLight* light) const {
     setUniformPoint3(pdman, fColorUni,
                      light->color().makeScale(SkScalarInvert(SkIntToScalar(255))));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLDistantLight::setData(const GrGLSLProgramDataManager& pdman,
                                const SkImageFilterLight* light) const {
     INHERITED::setData(pdman, light);
     SkASSERT(light->type() == SkImageFilterLight::kDistant_LightType);
     const SkDistantLight* distantLight = static_cast<const SkDistantLight*>(light);
     setUniformNormal3(pdman, fDirectionUni, distantLight->direction());
 }
 
 void GrGLDistantLight::emitSurfaceToLight(GrGLSLUniformHandler* uniformHandler,
-                                          GrGLSLFragmentBuilder* fragBuilder,
+                                          GrGLSLFPFragmentBuilder* fragBuilder,
                                           const char* z) {
     const char* dir;
     fDirectionUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                                kVec3f_GrSLType, kDefault_GrSLPrecision,
                                                "LightDirection", &dir);
     fragBuilder->codeAppend(dir);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLPointLight::setData(const GrGLSLProgramDataManager& pdman,
                              const SkImageFilterLight* light) const {
     INHERITED::setData(pdman, light);
     SkASSERT(light->type() == SkImageFilterLight::kPoint_LightType);
     const SkPointLight* pointLight = static_cast<const SkPointLight*>(light);
     setUniformPoint3(pdman, fLocationUni, pointLight->location());
 }
 
 void GrGLPointLight::emitSurfaceToLight(GrGLSLUniformHandler* uniformHandler,
-                                        GrGLSLFragmentBuilder* fragBuilder,
+                                        GrGLSLFPFragmentBuilder* fragBuilder,
                                         const char* z) {
     const char* loc;
     fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                               kVec3f_GrSLType, kDefault_GrSLPrecision,
                                               "LightLocation", &loc);
     fragBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))",
                              loc, fragBuilder->fragmentPosition(), z);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLSpotLight::setData(const GrGLSLProgramDataManager& pdman,
                             const SkImageFilterLight* light) const {
     INHERITED::setData(pdman, light);
     SkASSERT(light->type() == SkImageFilterLight::kSpot_LightType);
     const SkSpotLight* spotLight = static_cast<const SkSpotLight *>(light);
     setUniformPoint3(pdman, fLocationUni, spotLight->location());
     pdman.set1f(fExponentUni, spotLight->specularExponent());
     pdman.set1f(fCosInnerConeAngleUni, spotLight->cosInnerConeAngle());
     pdman.set1f(fCosOuterConeAngleUni, spotLight->cosOuterConeAngle());
     pdman.set1f(fConeScaleUni, spotLight->coneScale());
     setUniformNormal3(pdman, fSUni, spotLight->s());
 }
 
 void GrGLSpotLight::emitSurfaceToLight(GrGLSLUniformHandler* uniformHandler,
-                                       GrGLSLFragmentBuilder* fragBuilder,
+                                       GrGLSLFPFragmentBuilder* fragBuilder,
                                        const char* z) {
     const char* location;
     fLocationUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
                                               kVec3f_GrSLType, kDefault_GrSLPrecision,
                                               "LightLocation", &location);
 
     fragBuilder->codeAppendf("normalize(%s - vec3(%s.xy, %s))",
                              location, fragBuilder->fragmentPosition(), z);
 }
 
 void GrGLSpotLight::emitLightColor(GrGLSLUniformHandler* uniformHandler,
-                                   GrGLSLFragmentBuilder* fragBuilder,
+                                   GrGLSLFPFragmentBuilder* fragBuilder,
                                    const char *surfaceToLight) {
 
     const char* color = uniformHandler->getUniformCStr(this->lightColorUni()); // created by parent class.
 
     const char* exponent;
     const char* cosInner;
     const char* cosOuter;
     const char* coneScale;
     const char* s;
     fExponentUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
@@ skipping 34 matching lines @@
 
     fragBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END