Create GLSLUniformHandler class for gpu backend

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 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 "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
@@ skipping 11 matching lines @@
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrTexture.h"
 #include "GrFragmentProcessor.h"
 #include "GrInvariantOutput.h"
 #include "SkGrPixelRef.h"
 #include "SkDraw.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
-#include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLTextureSampler.h"
+#include "glsl/GrGLSLUniformHandler.h"
 #endif
 
 SkScalar SkBlurMaskFilter::ConvertRadiusToSigma(SkScalar radius) {
     return SkBlurMask::ConvertRadiusToSigma(radius);
 }
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
 public:
     SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, uint32_t flags);
 
@@ skipping 668 matching lines @@
     fragBuilder->codeAppendf("}");
 }
 
 
 void GrGLRectBlurEffect::GenKey(GrSLPrecision precision, GrProcessorKeyBuilder* b) {
     b->add32(precision);
 }
 
 
 void GrGLRectBlurEffect::emitCode(EmitArgs& args) {
+    GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
 
     const char *rectName;
     const char *profileSizeName;
 
     const char* precisionString = GrGLSLShaderVar::PrecisionString(args.fGLSLCaps, fPrecision);
-    fProxyRectUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                            kVec4f_GrSLType,
-                                            fPrecision,
-                                            "proxyRect",
-                                            &rectName);
-    fProfileSizeUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                            kFloat_GrSLType,
-                                            kDefault_GrSLPrecision,
-                                            "profileSize",
-                                            &profileSizeName);
+    fProxyRectUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                   kVec4f_GrSLType,
+                                                   fPrecision,
+                                                   "proxyRect",
+                                                   &rectName);
+    fProfileSizeUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                     kFloat_GrSLType,
+                                                     kDefault_GrSLPrecision,
+                                                     "profileSize",
+                                                     &profileSizeName);
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     const char *fragmentPos = fragBuilder->fragmentPosition();
 
     if (args.fInputColor) {
         fragBuilder->codeAppendf("vec4 src=%s;", args.fInputColor);
     } else {
         fragBuilder->codeAppendf("vec4 src=vec4(1);");
     }
 
@@ skipping 308 matching lines @@
     GrGLSLProgramDataManager::UniformHandle fCornerRadiusUniform;
     GrGLSLProgramDataManager::UniformHandle fBlurRadiusUniform;
     typedef GrGLSLFragmentProcessor INHERITED;
 };
 
 void GrGLRRectBlurEffect::emitCode(EmitArgs& args) {
     const char *rectName;
     const char *cornerRadiusName;
     const char *blurRadiusName;
 
+    GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     // The proxy rect has left, top, right, and bottom edges correspond to
     // components x, y, z, and w, respectively.
 
-    fProxyRectUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                                  kVec4f_GrSLType,
-                                                  kDefault_GrSLPrecision,
-                                                  "proxyRect",
-                                                  &rectName);
-    fCornerRadiusUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                                     kFloat_GrSLType,
-                                                     kDefault_GrSLPrecision,
-                                                     "cornerRadius",
-                                                     &cornerRadiusName);
-    fBlurRadiusUniform = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
-                                                   kFloat_GrSLType,
+    fProxyRectUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                   kVec4f_GrSLType,
                                                    kDefault_GrSLPrecision,
-                                                   "blurRadius",
-                                                   &blurRadiusName);
+                                                   "proxyRect",
+                                                   &rectName);
+    fCornerRadiusUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                      kFloat_GrSLType,
+                                                      kDefault_GrSLPrecision,
+                                                      "cornerRadius",
+                                                      &cornerRadiusName);
+    fBlurRadiusUniform = uniformHandler->addUniform(GrGLSLUniformHandler::kFragment_Visibility,
+                                                    kFloat_GrSLType,
+                                                    kDefault_GrSLPrecision,
+                                                    "blurRadius",
+                                                    &blurRadiusName);
 
     GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
     const char* fragmentPos = fragBuilder->fragmentPosition();
 
     // warp the fragment position to the appropriate part of the 9patch blur texture
 
     fragBuilder->codeAppendf("vec2 rectCenter = (%s.xy + %s.zw)/2.0;", rectName, rectName);
     fragBuilder->codeAppendf("vec2 translatedFragPos = %s.xy - %s.xy;", fragmentPos, rectName);
     fragBuilder->codeAppendf("float threshold = %s + 2.0*%s;", cornerRadiusName, blurRadiusName);
     fragBuilder->codeAppendf("vec2 middle = %s.zw - %s.xy - 2.0*threshold;", rectName, rectName);
@@ skipping 211 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END