Add alternative ambient shadow method to Android shadow sample

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 51 matching lines @@
 /**
  * The output of this effect is a modulation of the input color and coverage for a circle. It
  * operates in a space normalized by the circle radius (outer radius in the case of a stroke)
  * with origin at the circle center. Three vertex attributes are used:
  *    vec2f : position in device space of the bounding geometry vertices
  *    vec4ub: color
  *    vec4f : (p.xy, outerRad, innerRad)
  *             p is the position in the normalized space.
  *             outerRad is the outerRadius in device space.
  *             innerRad is the innerRadius in normalized space (ignored if not stroking).
+ * If fUsesDistanceVectorField is set in fragment processors in the same program, then 
+ * an additional vertex attribute is available via args.fFragBuilder->distanceVectorName():
+ *    vec4f : (v.xy, outerDistance, innerDistance)
+ *             v is a normalized vector pointing to the outer edge
+ *             outerDistance is the distance to the outer edge, < 0 if we are outside of the shape
+ *             if stroking, innerDistance is the distance to the inner edge, < 0 if outside
  */
 
 class CircleGeometryProcessor : public GrGeometryProcessor {
 public:
     CircleGeometryProcessor(bool stroke, const SkMatrix& localMatrix) : fLocalMatrix(localMatrix){
         this->initClassID<CircleGeometryProcessor>();
         fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType,
                                                        kHigh_GrSLPrecision));
         fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
         fInCircleEdge = &this->addVertexAttrib(Attribute("inCircleEdge",
@@ skipping 40 matching lines @@
             this->emitTransforms(vertBuilder,
                                  varyingHandler,
                                  uniformHandler,
                                  gpArgs->fPositionVar,
                                  cgp.inPosition()->fName,
                                  cgp.localMatrix(),
                                  args.fTransformsIn,
                                  args.fTransformsOut);
 
             fragBuilder->codeAppendf("float d = length(%s.xy);", v.fsIn());
-            fragBuilder->codeAppendf("float distanceToEdge = %s.z * (1.0 - d);", v.fsIn());
-            fragBuilder->codeAppendf("float edgeAlpha = clamp(distanceToEdge, 0.0, 1.0);");
+            fragBuilder->codeAppendf("float distanceToOuterEdge = %s.z * (1.0 - d);", v.fsIn());
+            fragBuilder->codeAppendf("float edgeAlpha = clamp(distanceToOuterEdge, 0.0, 1.0);");
             if (cgp.fStroke) {
-                fragBuilder->codeAppendf("float innerAlpha = clamp(%s.z * (d - %s.w), 0.0, 1.0);",
+                fragBuilder->codeAppendf("float distanceToInnerEdge = %s.z * (d - %s.w);",
                                          v.fsIn(), v.fsIn());
+                fragBuilder->codeAppend("float innerAlpha = clamp(distanceToInnerEdge, 0.0, 1.0);");
                 fragBuilder->codeAppend("edgeAlpha *= innerAlpha;");
+            } else {
+                fragBuilder->codeAppend("float distanceToInnerEdge = 0.0;");
             }
 
             if (args.fDistanceVectorName) {
                 fragBuilder->codeAppend ("if (d == 0.0) {"); // if on the center of the circle
-                fragBuilder->codeAppendf("    %s = vec3(1.0, 0.0, distanceToEdge);", // no normalize
+                fragBuilder->codeAppendf("    %s = vec4(1.0, 0.0, distanceToOuterEdge, "
+                                         "distanceToInnerEdge);", // no normalize
                                          args.fDistanceVectorName);
                 fragBuilder->codeAppend ("} else {");
-                fragBuilder->codeAppendf("    %s = vec3(normalize(%s.xy), distanceToEdge);",
+                fragBuilder->codeAppendf("    %s = vec4(normalize(%s.xy), distanceToOuterEdge, "
+                                         "distanceToInnerEdge);",
                                          args.fDistanceVectorName, v.fsIn());
                 fragBuilder->codeAppend ("}");
             }
 
             fragBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage);
         }
 
         static void GenKey(const GrGeometryProcessor& gp,
                            const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
@@ skipping 1550 matching lines @@
 }
 
 DRAW_BATCH_TEST_DEFINE(RRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrixRectStaysRect(random);
     GrColor color = GrRandomColor(random);
     const SkRRect& rrect = GrTest::TestRRectSimple(random);
     return create_rrect_batch(color, viewMatrix, rrect, GrTest::TestStrokeRec(random));
 }
 
 #endif