Switch float arrays to vecs for conical gradients

src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTwoPointConicalGradient_gpu.h"
 
@@ skipping 209 matching lines @@
 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrProcessor&)
     : fVSVaryingName(nullptr)
     , fFSVaryingName(nullptr)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedDiffRadius(-SK_ScalarMax) {}
 
 void GLEdge2PtConicalEffect::emitCode(EmitArgs& args) {
     const Edge2PtConicalEffect& ge = args.fFp.cast<Edge2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
-    fParamUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag,
-                                                kFloat_GrSLType, kDefault_GrSLPrecision,
-                                                "Conical2FSParams", 3);
+    fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                           kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                           "Conical2FSParams");
 
     SkString cName("c");
     SkString tName("t");
     SkString p0; // start radius
     SkString p1; // start radius squared
     SkString p2; // difference in radii (r1 - r0)
 
-    uniformHandler->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
-    uniformHandler->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
-    uniformHandler->getUniformVariable(fParamUni).appendArrayAccess(2, &p2);
+
+    p0.appendf("%s.x", uniformHandler->getUniformVariable(fParamUni).getName().c_str());
+    p1.appendf("%s.y", uniformHandler->getUniformVariable(fParamUni).getName().c_str());
+    p2.appendf("%s.z", uniformHandler->getUniformVariable(fParamUni).getName().c_str());
 
     // We interpolate the linear component in coords[1].
     SkASSERT(args.fCoords[0].getType() == args.fCoords[1].getType());
     const char* coords2D;
     SkString bVar;
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     if (kVec3f_GrSLType == args.fCoords[0].getType()) {
         fragBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
                                args.fCoords[0].c_str(), args.fCoords[0].c_str(),
                                args.fCoords[1].c_str(), args.fCoords[1].c_str());
@@ skipping 34 matching lines @@
 void GLEdge2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
                                        const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
     SkScalar radius0 = data.radius();
     SkScalar diffRadius = data.diffRadius();
 
     if (fCachedRadius != radius0 ||
         fCachedDiffRadius != diffRadius) {
 
-        float values[3] = {
-            SkScalarToFloat(radius0),
-            SkScalarToFloat(SkScalarMul(radius0, radius0)),
-            SkScalarToFloat(diffRadius)
-        };
-
-        pdman.set1fv(fParamUni, 3, values);
+        pdman.set3f(fParamUni, SkScalarToFloat(radius0), 
+                    SkScalarToFloat(SkScalarMul(radius0, radius0)), SkScalarToFloat(diffRadius));
         fCachedRadius = radius0;
         fCachedDiffRadius = diffRadius;
     }
 }
 
 void GLEdge2PtConicalEffect::GenKey(const GrProcessor& processor,
                                     const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(GenBaseGradientKey(processor));
 }
 
@@ skipping 189 matching lines @@
     , fFSVaryingName(nullptr)
     , fCachedFocal(SK_ScalarMax) {
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
 }
 
 void GLFocalOutside2PtConicalEffect::emitCode(EmitArgs& args) {
     const FocalOutside2PtConicalEffect& ge = args.fFp.cast<FocalOutside2PtConicalEffect>();
     GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
     this->emitUniforms(uniformHandler, ge);
-    fParamUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag,
-                                                kFloat_GrSLType, kDefault_GrSLPrecision,
-                                                "Conical2FSParams", 2);
+    fParamUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                           kVec2f_GrSLType, kDefault_GrSLPrecision,
+                                           "Conical2FSParams");
     SkString tName("t");
     SkString p0; // focalX
     SkString p1; // 1 - focalX * focalX
 
-    uniformHandler->getUniformVariable(fParamUni).appendArrayAccess(0, &p0);
-    uniformHandler->getUniformVariable(fParamUni).appendArrayAccess(1, &p1);
+    p0.appendf("%s.x", uniformHandler->getUniformVariable(fParamUni).getName().c_str());
+    p1.appendf("%s.y", uniformHandler->getUniformVariable(fParamUni).getName().c_str());
 
     // if we have a vec3 from being in perspective, convert it to a vec2 first
     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
     SkString coords2DString = fragBuilder->ensureFSCoords2D(args.fCoords, 0);
     const char* coords2D = coords2DString.c_str();
 
     // t = p.x * focal.x +/- sqrt(p.x^2 + (1 - focal.x^2) * p.y^2)
 
     // output will default to transparent black (we simply won't write anything
     // else to it if invalid, instead of discarding or returning prematurely)
@@ skipping 29 matching lines @@
 void GLFocalOutside2PtConicalEffect::onSetData(const GrGLSLProgramDataManager& pdman,
                                                const GrProcessor& processor) {
     INHERITED::onSetData(pdman, processor);
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal);
 
-        float values[2] = {
-            SkScalarToFloat(focal),
-            SkScalarToFloat(oneMinus2F),
-        };
-
-        pdman.set1fv(fParamUni, 2, values);
+        pdman.set2f(fParamUni, SkScalarToFloat(focal), SkScalarToFloat(oneMinus2F));
         fCachedFocal = focal;
     }
 }
 
 void GLFocalOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
                                             const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
     key[0] = GenBaseGradientKey(processor);
     key[1] = processor.cast<FocalOutside2PtConicalEffect>().isFlipped();
 }
@@ skipping 755 matching lines @@
         return CircleInside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Create(ctx, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Create(ctx, shader, matrix, tm, info);
     }
 }
 
 #endif