Solo gp

gm/beziereffects.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.
  */
 
 // This test only works with the GPU backend.
 
 #include "gm.h"
 
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
 #include "GrPathUtils.h"
 #include "GrTest.h"
 #include "SkColorPriv.h"
 #include "SkDevice.h"
 #include "SkGeometry.h"
 
 #include "effects/GrBezierEffect.h"
 
 // Position & KLM line eq values. These are the vertex attributes for Bezier curves. The last value
 // of the Vec4f is ignored.
 namespace {
 extern const GrVertexAttrib kAttribs[] = {
     {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding},
-    {kVec4f_GrVertexAttribType, sizeof(SkPoint), kEffect_GrVertexAttribBinding}
+    {kVec4f_GrVertexAttribType, sizeof(SkPoint), kGeometryProcessor_GrVertexAttribBinding}
 };
 }
 
 static inline SkScalar eval_line(const SkPoint& p, const SkScalar lineEq[3], SkScalar sign) {
     return sign * (lineEq[0] * p.fX + lineEq[1] * p.fY + lineEq[2]);
 }
 
 namespace skiagm {
 /**
  * This GM directly exercises effects that draw Bezier curves in the GPU backend.
@@ skipping 45 matching lines @@
         int row = 0;
         int col = 0;
 
         for (int i = 0; i < kNumCubics; ++i) {
             SkPoint baseControlPts[] = {
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
             };
-            for(int edgeType = 0; edgeType < kGrEffectEdgeTypeCnt; ++edgeType) {
-                SkAutoTUnref<GrEffect> effect;
+            for(int edgeType = 0; edgeType < kGrProcessorEdgeTypeCnt; ++edgeType) {
+                SkAutoTUnref<GrGeometryProcessor> gp;
                 {   // scope to contain GrTestTarget
                     GrTestTarget tt;
                     context->getTestTarget(&tt);
                     if (NULL == tt.target()) {
                         continue;
                     }
-                    GrEffectEdgeType et = (GrEffectEdgeType)edgeType;
-                    effect.reset(GrCubicEffect::Create(et, *tt.target()->caps()));
-                    if (!effect) {
+                    GrProcessorEdgeType et = (GrProcessorEdgeType)edgeType;
+                    gp.reset(GrCubicEffect::Create(et, *tt.target()->caps()));
+                    if (!gp) {
                         continue;
                     }
                 }
 
                 SkScalar x = SkScalarMul(col, w);
                 SkScalar y = SkScalarMul(row, h);
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
                     {x + baseControlPts[2].fX, y + baseControlPts[2].fY},
@@ skipping 47 matching lines @@
                         verts[v].fKLM[1] = eval_line(verts[v].fPosition, klmEqs + 3, klmSigns[c]);
                         verts[v].fKLM[2] = eval_line(verts[v].fPosition, klmEqs + 6, 1.f);
                     }
 
                     GrTestTarget tt;
                     context->getTestTarget(&tt);
                     SkASSERT(tt.target());
                     GrDrawState* drawState = tt.target()->drawState();
                     drawState->setVertexAttribs<kAttribs>(2, sizeof(Vertex));
 
-                    drawState->setGeometryProcessor(effect);
+                    drawState->setGeometryProcessor(gp);
                     drawState->setRenderTarget(rt);
                     drawState->setColor(0xff000000);
 
                     tt.target()->setVertexSourceToArray(verts, 4);
                     tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer());
                     tt.target()->drawIndexed(kTriangleFan_GrPrimitiveType, 0, 0, 4, 6);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
@@ skipping 59 matching lines @@
         int row = 0;
         int col = 0;
 
         for (int i = 0; i < kNumConics; ++i) {
             SkPoint baseControlPts[] = {
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
             };
             SkScalar weight = rand.nextRangeF(0.f, 2.f);
-            for(int edgeType = 0; edgeType < kGrEffectEdgeTypeCnt; ++edgeType) {
-                SkAutoTUnref<GrEffect> effect;
+            for(int edgeType = 0; edgeType < kGrProcessorEdgeTypeCnt; ++edgeType) {
+                SkAutoTUnref<GrGeometryProcessor> gp;
                 {   // scope to contain GrTestTarget
                     GrTestTarget tt;
                     context->getTestTarget(&tt);
                     if (NULL == tt.target()) {
                         continue;
                     }
-                    GrEffectEdgeType et = (GrEffectEdgeType)edgeType;
-                    effect.reset(GrConicEffect::Create(et, *tt.target()->caps()));
-                    if (!effect) {
+                    GrProcessorEdgeType et = (GrProcessorEdgeType)edgeType;
+                    gp.reset(GrConicEffect::Create(et, *tt.target()->caps()));
+                    if (!gp) {
                         continue;
                     }
                 }
 
                 SkScalar x = SkScalarMul(col, w);
                 SkScalar y = SkScalarMul(row, h);
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
                     {x + baseControlPts[2].fX, y + baseControlPts[2].fY}
@@ skipping 44 matching lines @@
                         verts[v].fKLM[1] = eval_line(verts[v].fPosition, klmEqs + 3, 1.f);
                         verts[v].fKLM[2] = eval_line(verts[v].fPosition, klmEqs + 6, 1.f);
                     }
 
                     GrTestTarget tt;
                     context->getTestTarget(&tt);
                     SkASSERT(tt.target());
                     GrDrawState* drawState = tt.target()->drawState();
                     drawState->setVertexAttribs<kAttribs>(2, sizeof(Vertex));
 
-                    drawState->setGeometryProcessor(effect);
+                    drawState->setGeometryProcessor(gp);
                     drawState->setRenderTarget(rt);
                     drawState->setColor(0xff000000);
 
                     tt.target()->setVertexSourceToArray(verts, 4);
                     tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer());
                     tt.target()->drawIndexed(kTriangleFan_GrPrimitiveType, 0, 0, 4, 6);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
@@ skipping 93 matching lines @@
         SkScalar h = SkIntToScalar(rt->height()) / numRows;
         int row = 0;
         int col = 0;
 
         for (int i = 0; i < kNumQuads; ++i) {
             SkPoint baseControlPts[] = {
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
                 {rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
             };
-            for(int edgeType = 0; edgeType < kGrEffectEdgeTypeCnt; ++edgeType) {
-                SkAutoTUnref<GrEffect> effect;
+            for(int edgeType = 0; edgeType < kGrProcessorEdgeTypeCnt; ++edgeType) {
+                SkAutoTUnref<GrGeometryProcessor> gp;
                 {   // scope to contain GrTestTarget
                     GrTestTarget tt;
                     context->getTestTarget(&tt);
                     if (NULL == tt.target()) {
                         continue;
                     }
-                    GrEffectEdgeType et = (GrEffectEdgeType)edgeType;
-                    effect.reset(GrQuadEffect::Create(et, *tt.target()->caps()));
-                    if (!effect) {
+                    GrProcessorEdgeType et = (GrProcessorEdgeType)edgeType;
+                    gp.reset(GrQuadEffect::Create(et, *tt.target()->caps()));
+                    if (!gp) {
                         continue;
                     }
                 }
 
                 SkScalar x = SkScalarMul(col, w);
                 SkScalar y = SkScalarMul(row, h);
                 SkPoint controlPts[] = {
                     {x + baseControlPts[0].fX, y + baseControlPts[0].fY},
                     {x + baseControlPts[1].fX, y + baseControlPts[1].fY},
                     {x + baseControlPts[2].fX, y + baseControlPts[2].fY}
@@ skipping 39 matching lines @@
 
                     GrPathUtils::QuadUVMatrix DevToUV(pts);
                     DevToUV.apply<4, sizeof(Vertex), sizeof(SkPoint)>(verts);
 
                     GrTestTarget tt;
                     context->getTestTarget(&tt);
                     SkASSERT(tt.target());
                     GrDrawState* drawState = tt.target()->drawState();
                     drawState->setVertexAttribs<kAttribs>(2, sizeof(Vertex));
 
-                    drawState->setGeometryProcessor(effect);
+                    drawState->setGeometryProcessor(gp);
                     drawState->setRenderTarget(rt);
                     drawState->setColor(0xff000000);
 
                     tt.target()->setVertexSourceToArray(verts, 4);
                     tt.target()->setIndexSourceToBuffer(context->getQuadIndexBuffer());
                     tt.target()->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 4, 6);
                 }
                 ++col;
                 if (numCols == col) {
                     col = 0;
                     ++row;
                 }
             }
         }
     }
 
 private:
     typedef GM INHERITED;
 };
 
 DEF_GM( return SkNEW(BezierCubicEffects); )
 DEF_GM( return SkNEW(BezierConicEffects); )
 DEF_GM( return SkNEW(BezierQuadEffects); )
 
 }
 
 #endif