Default geometry processor

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrGpu.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "GrTBackendProcessorFactory.h"
 #include "SkColorPriv.h"
 #include "GrGeometryProcessor.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 class GrGLAlignedRectEffect;
 
 // Axis Aligned special case
 class GrAlignedRectEffect : public GrGeometryProcessor {

[bsalomon, 2014/10/27 13:43:43]

Why don't we just delete these unused effects (separately) rather than modifying
them. We aren't testing them, they are slower in too many cases, they don't
actually draw correctly, and if go back to this approach we base it off the
other analytic rect processors that are currently used for clipping.

 public:
     static GrGeometryProcessor* Create() {
         GR_CREATE_STATIC_PROCESSOR(gAlignedRectEffect, GrAlignedRectEffect, ());
         gAlignedRectEffect->ref();
         return gAlignedRectEffect;
     }
 
     virtual ~GrAlignedRectEffect() {}
 
     static const char* Name() { return "AlignedRectEdge"; }
@@ skipping 13 matching lines @@
             // setup the varying for the Axis aligned rect effect
             //      xy -> interpolated offset
             //      zw -> w/2+0.5, h/2+0.5
             GrGLVertToFrag v(kVec4f_GrSLType);
             args.fPB->addVarying("Rect", &v);
 
             const GrShaderVar& inRect = args.fGP.cast<GrAlignedRectEffect>().inRect();
             GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
             vsBuilder->codeAppendf("\t%s = %s;\n", v.fsIn(), inRect.c_str());
 
+            // setup position varying
+            vsBuilder->codeAppendf("vec3 pos3 = %s * vec3(%s, 1);", args.fGP.uViewM(),
+                                   args.fGP.inPosition());
+            vsBuilder->transformPositionToDeviceSpace("pos3");
+
             GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
             // TODO: compute all these offsets, spans, and scales in the VS
             fsBuilder->codeAppendf("\tfloat insetW = min(1.0, %s.z) - 0.5;\n", v.fsIn());
             fsBuilder->codeAppendf("\tfloat insetH = min(1.0, %s.w) - 0.5;\n", v.fsIn());
             fsBuilder->codeAppend("\tfloat outset = 0.5;\n");
             // For rects > 1 pixel wide and tall the span's are noops (i.e., 1.0). For rects
             // < 1 pixel wide or tall they serve to normalize the < 1 ramp to a 0 .. 1 range.
             fsBuilder->codeAppend("\tfloat spanW = insetW + outset;\n");
             fsBuilder->codeAppend("\tfloat spanH = insetH + outset;\n");
             // For rects < 1 pixel wide or tall, these scale factors are used to cap the maximum
@@ skipping 105 matching lines @@
             GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
             vsBuilder->codeAppendf("%s = %s;", rectEdge.vsOut(), rectEffect.inRectEdge().c_str());
 
             // setup the varying for width/2+.5 and height/2+.5
             GrGLVertToFrag widthHeight(kVec2f_GrSLType);
             args.fPB->addVarying("WidthHeight", &widthHeight);
             vsBuilder->codeAppendf("%s = %s;",
                                    widthHeight.vsOut(),
                                    rectEffect.inWidthHeight().c_str());
 
+            // setup position varying
+            vsBuilder->codeAppendf("vec3 pos3 = %s * vec3(%s, 1);", args.fGP.uViewM(),
+                                   args.fGP.inPosition());
+            vsBuilder->transformPositionToDeviceSpace("pos3");
+
             GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
             // TODO: compute all these offsets, spans, and scales in the VS
             fsBuilder->codeAppendf("\tfloat insetW = min(1.0, %s.x) - 0.5;\n", widthHeight.fsIn());
             fsBuilder->codeAppendf("\tfloat insetH = min(1.0, %s.y) - 0.5;\n", widthHeight.fsIn());
             fsBuilder->codeAppend("\tfloat outset = 0.5;\n");
             // For rects > 1 pixel wide and tall the span's are noops (i.e., 1.0). For rects
             // < 1 pixel wide or tall they serve to normalize the < 1 ramp to a 0 .. 1 range.
             fsBuilder->codeAppend("\tfloat spanW = insetW + outset;\n");
             fsBuilder->codeAppend("\tfloat spanH = insetH + outset;\n");
             // For rects < 1 pixel wide or tall, these scale factors are used to cap the maximum
@@ skipping 726 matching lines @@
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
 }