Clip in grdrawtarget

tests/GLProgramsTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
 
-#include "GrTBackendProcessorFactory.h"
 #include "GrContextFactory.h"
 #include "GrOptDrawState.h"
-#include "effects/GrConfigConversionEffect.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-#include "gl/GrGLPathRendering.h"
-#include "gl/GrGpuGL.h"
+#include "GrTBackendProcessorFactory.h"
+#include "GrTest.h"
 #include "SkChecksum.h"
 #include "SkRandom.h"
 #include "Test.h"
+#include "effects/GrConfigConversionEffect.h"
+#include "gl/GrGLPathRendering.h"
+#include "gl/GrGpuGL.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * A dummy processor which just tries to insert a massive key and verify that it can retrieve the
  * whole thing correctly
  */
 static const uint32_t kMaxKeySize = 1024;
 
 class GLBigKeyProcessor;
 
 class BigKeyProcessor : public GrFragmentProcessor {
@@ skipping 56 matching lines @@
 private:
     typedef GrGLFragmentProcessor INHERITED;
 };
 
 /*
  * Begin test code
  */
 static const int kRenderTargetHeight = 1;
 static const int kRenderTargetWidth = 1;
 
-static GrRenderTarget* random_render_target(GrGpuGL* gpu,
+static GrRenderTarget* random_render_target(GrContext* context,
                                             const GrCacheID& cacheId,
                                             SkRandom* random) {
     // setup render target
     GrTextureParams params;
     GrSurfaceDesc texDesc;
     texDesc.fWidth = kRenderTargetWidth;
     texDesc.fHeight = kRenderTargetHeight;
     texDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     texDesc.fConfig = kRGBA_8888_GrPixelConfig;
     texDesc.fOrigin = random->nextBool() == true ? kTopLeft_GrSurfaceOrigin :
                                                    kBottomLeft_GrSurfaceOrigin;
 
-    SkAutoTUnref<GrTexture> texture(
-        gpu->getContext()->findAndRefTexture(texDesc, cacheId, &params));
+    SkAutoTUnref<GrTexture> texture(context->findAndRefTexture(texDesc, cacheId, &params));
     if (!texture) {
-        texture.reset(gpu->getContext()->createTexture(&params, texDesc, cacheId, 0, 0));
+        texture.reset(context->createTexture(&params, texDesc, cacheId, 0, 0));
         if (!texture) {
             return NULL;
         }
     }
     return SkRef(texture->asRenderTarget());
 }
 
 // TODO clean this up, we have to do this to test geometry processors but there has got to be
 // a better way.  In the mean time, we actually fill out these generic vertex attribs below with
 // the correct vertex attribs from the GP.  We have to ensure, however, we don't try to add more
@@ skipping 31 matching lines @@
 static void setup_random_ff_attribute(GrVertexAttribBinding binding, GrVertexAttribType type,
                                       SkRandom* random, int* attribIndex, int* runningStride) {
     if (random->nextBool()) {
         kGenericVertexAttribs[*attribIndex].fType = type;
         kGenericVertexAttribs[*attribIndex].fOffset = *runningStride;
         kGenericVertexAttribs[*attribIndex].fBinding = binding;
         *runningStride += GrVertexAttribTypeSize(kGenericVertexAttribs[(*attribIndex)++].fType);
     }
 }
 
-static void set_random_gp(GrGpuGL* gpu, SkRandom* random, GrTexture* dummyTextures[]) {
+static void set_random_gp(GrContext* context,
+                          const GrDrawTargetCaps& caps,
+                          GrDrawState* ds,
+                          SkRandom* random,
+                          GrTexture* dummyTextures[]) {
     GrProgramElementRef<const GrGeometryProcessor> gp(
             GrProcessorTestFactory<GrGeometryProcessor>::CreateStage(random,
-                                                                     gpu->getContext(),
-                                                                     *gpu->caps(),
+                                                                     context,
+                                                                     caps,
                                                                      dummyTextures));
     SkASSERT(gp);
 
     // we have to set dummy vertex attributes, first we setup the fixed function attributes
     // always leave the position attribute untouched in the array
     int attribIndex = 1;
     int runningStride = GrVertexAttribTypeSize(kGenericVertexAttribs[0].fType);
 
     // local coords
     setup_random_ff_attribute(kLocalCoord_GrVertexAttribBinding, kVec2f_GrVertexAttribType,
@@ skipping 17 matching lines @@
     int maxIndex = SK_ARRAY_COUNT(kGenericVertexAttribs);
     for (int i = 0; i < numGPAttribs && i + attribIndex < maxIndex; i++) {
         kGenericVertexAttribs[i + attribIndex].fType =
                 convert_sltype_to_attribtype(v[i].getType());
         kGenericVertexAttribs[i + attribIndex].fOffset = runningStride;
         kGenericVertexAttribs[i + attribIndex].fBinding = kGeometryProcessor_GrVertexAttribBinding;
         runningStride += GrVertexAttribTypeSize(kGenericVertexAttribs[i + attribIndex].fType);
     }
 
     // update the vertex attributes with the ds
-    GrDrawState* ds = gpu->drawState();
     ds->setVertexAttribs<kGenericVertexAttribs>(attribIndex + numGPAttribs, runningStride);
     ds->setGeometryProcessor(gp);
 }
 
 static void set_random_color_coverage_stages(GrGpuGL* gpu,
+                                             GrDrawState* ds,
                                              int maxStages,
                                              bool usePathRendering,
                                              SkRandom* random,
                                              GrTexture* dummyTextures[]) {
     int numProcs = random->nextULessThan(maxStages + 1);
     int numColorProcs = random->nextULessThan(numProcs + 1);
 
     int currTextureCoordSet = 0;
     for (int s = 0; s < numProcs;) {
         GrProgramElementRef<GrFragmentProcessor> fp(
@@ skipping 14 matching lines @@
                                 GrGLPathRendering::FixedFunction_TexturingMode) {;
             int numTransforms = fp->numTransforms();
             if (currTextureCoordSet + numTransforms >
                 gpu->glCaps().maxFixedFunctionTextureCoords()) {
                 continue;
             }
             currTextureCoordSet += numTransforms;
         }
 
         // finally add the stage to the correct pipeline in the drawstate
-        GrDrawState* ds = gpu->drawState();
         if (s < numColorProcs) {
             ds->addColorProcessor(fp);
         } else {
             ds->addCoverageProcessor(fp);
         }
         ++s;
     }
 }
 
 // There are only a few cases of random colors which interest us
 enum ColorMode {
     kAllOnes_ColorMode,
     kAllZeros_ColorMode,
     kAlphaOne_ColorMode,
     kRandom_ColorMode,
     kLast_ColorMode = kRandom_ColorMode
 };
 
-static void set_random_color(GrGpuGL* gpu, SkRandom* random) {
+static void set_random_color(GrDrawState* ds, SkRandom* random) {
     ColorMode colorMode = ColorMode(random->nextULessThan(kLast_ColorMode + 1));
     GrColor color;
     switch (colorMode) {
         case kAllOnes_ColorMode:
             color = GrColorPackRGBA(0xFF, 0xFF, 0xFF, 0xFF);
             break;
         case kAllZeros_ColorMode:
             color = GrColorPackRGBA(0, 0, 0, 0);
             break;
         case kAlphaOne_ColorMode:
             color = GrColorPackRGBA(random->nextULessThan(256),
                                     random->nextULessThan(256),
                                     random->nextULessThan(256),
                                     0xFF);
             break;
         case kRandom_ColorMode:
             uint8_t alpha = random->nextULessThan(256);
             color = GrColorPackRGBA(random->nextRangeU(0, alpha),
                                     random->nextRangeU(0, alpha),
                                     random->nextRangeU(0, alpha),
                                     alpha);
             break;
     }
     GrColorIsPMAssert(color);
-    gpu->drawState()->setColor(color);
+    ds->setColor(color);
 }
 
 // There are only a few cases of random coverages which interest us
 enum CoverageMode {
     kZero_CoverageMode,
     kFF_CoverageMode,
     kRandom_CoverageMode,
     kLast_CoverageMode = kRandom_CoverageMode
 };
 
-static void set_random_coverage(GrGpuGL* gpu, SkRandom* random) {
+static void set_random_coverage(GrDrawState* ds, SkRandom* random) {
     CoverageMode coverageMode = CoverageMode(random->nextULessThan(kLast_CoverageMode + 1));
     uint8_t coverage;
     switch (coverageMode) {
         case kZero_CoverageMode:
             coverage = 0;
             break;
         case kFF_CoverageMode:
             coverage = 0xFF;
             break;
         case kRandom_CoverageMode:
             coverage = uint8_t(random->nextU());
             break;
     }
-    gpu->drawState()->setCoverage(coverage);
+    ds->setCoverage(coverage);
 }
 
-static void set_random_hints(GrGpuGL* gpu, SkRandom* random) {
+static void set_random_hints(GrDrawState* ds, SkRandom* random) {
     for (int i = 1; i <= GrDrawState::kLast_Hint; i <<= 1) {
-        gpu->drawState()->setHint(GrDrawState::Hints(i), random->nextBool());
+        ds->setHint(GrDrawState::Hints(i), random->nextBool());
     }
 }
 
-static void set_random_state(GrGpuGL* gpu, SkRandom* random) {
+static void set_random_state(GrDrawState* ds, SkRandom* random) {
     int state = 0;
     for (int i = 1; i <= GrDrawState::kLast_StateBit; i <<= 1) {
         state |= random->nextBool() * i;
     }
-    gpu->drawState()->enableState(state);
+    ds->enableState(state);
 }
 
 // this function will randomly pick non-self referencing blend modes
-static void set_random_blend_func(GrGpuGL* gpu, SkRandom* random) {
+static void set_random_blend_func(GrDrawState* ds, SkRandom* random) {
     GrBlendCoeff src;
     do {
         src = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsSrc(src));
 
     GrBlendCoeff dst;
     do {
         dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
     } while (GrBlendCoeffRefsDst(dst));
 
-    gpu->drawState()->setBlendFunc(src, dst);
+    ds->setBlendFunc(src, dst);
 }
 
 // right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
-static void set_random_stencil(GrGpuGL* gpu, SkRandom* random) {
+static void set_random_stencil(GrDrawState* ds, SkRandom* random) {
     GR_STATIC_CONST_SAME_STENCIL(kDoesWriteStencil,
                                  kReplace_StencilOp,
                                  kReplace_StencilOp,
                                  kAlways_StencilFunc,
                                  0xffff,
                                  0xffff,
                                  0xffff);
     GR_STATIC_CONST_SAME_STENCIL(kDoesNotWriteStencil,
                                  kKeep_StencilOp,
                                  kKeep_StencilOp,
                                  kNever_StencilFunc,
                                  0xffff,
                                  0xffff,
                                  0xffff);
 
     if (random->nextBool()) {
-        gpu->drawState()->setStencil(kDoesWriteStencil);
+        ds->setStencil(kDoesWriteStencil);
     } else {
-        gpu->drawState()->setStencil(kDoesNotWriteStencil);
+        ds->setStencil(kDoesNotWriteStencil);
     }
 }
 
-bool GrGpuGL::programUnitTest(int maxStages) {
+bool GrDrawTarget::programUnitTest(int maxStages) {
+    GrGpuGL* gpu = static_cast<GrGpuGL*>(fContext->getGpu());
     // setup dummy textures
     GrSurfaceDesc dummyDesc;
     dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     dummyDesc.fConfig = kSkia8888_GrPixelConfig;
     dummyDesc.fWidth = 34;
     dummyDesc.fHeight = 18;
-    SkAutoTUnref<GrTexture> dummyTexture1(this->createTexture(dummyDesc, NULL, 0));
+    SkAutoTUnref<GrTexture> dummyTexture1(gpu->createTexture(dummyDesc, NULL, 0));
     dummyDesc.fFlags = kNone_GrSurfaceFlags;
     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
     dummyDesc.fWidth = 16;
     dummyDesc.fHeight = 22;
-    SkAutoTUnref<GrTexture> dummyTexture2(this->createTexture(dummyDesc, NULL, 0));
+    SkAutoTUnref<GrTexture> dummyTexture2(gpu->createTexture(dummyDesc, NULL, 0));
 
     if (!dummyTexture1 || ! dummyTexture2) {
         SkDebugf("Could not allocate dummy textures");
         return false;
     }
 
     GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
 
     // Setup texture cache id key
     const GrCacheID::Domain glProgramsDomain = GrCacheID::GenerateDomain();
     GrCacheID::Key key;
     memset(&key, 0, sizeof(key));
     key.fData32[0] = kRenderTargetWidth;
     key.fData32[1] = kRenderTargetHeight;
     GrCacheID glProgramsCacheID(glProgramsDomain, key);
 
     // setup clip
-    SkRect screen =
-            SkRect::MakeWH(SkIntToScalar(kRenderTargetWidth), SkIntToScalar(kRenderTargetHeight));
+    SkRect screen = SkRect::MakeWH(SkIntToScalar(kRenderTargetWidth),
+                                   SkIntToScalar(kRenderTargetHeight));
 
     SkClipStack stack;
     stack.clipDevRect(screen, SkRegion::kReplace_Op, false);
 
     // wrap the SkClipStack in a GrClipData
     GrClipData clipData;
     clipData.fClipStack = &stack;
     this->setClip(&clipData);
 
     SkRandom random;
     static const int NUM_TESTS = 512;
     for (int t = 0; t < NUM_TESTS;) {
         // setup random render target(can fail)
-        SkAutoTUnref<GrRenderTarget> rt(random_render_target(this, glProgramsCacheID, &random));
-        if (!rt) {
+        SkAutoTUnref<GrRenderTarget> rt(random_render_target(fContext, glProgramsCacheID, &random));
+        if (!rt.get()) {
             SkDebugf("Could not allocate render target");
             return false;
         }
 
         GrDrawState* ds = this->drawState();
         ds->setRenderTarget(rt.get());
 
         // if path rendering we have to setup a couple of things like the draw type
-        bool usePathRendering = this->glCaps().pathRenderingSupport() && random.nextBool();
+        bool usePathRendering = gpu->glCaps().pathRenderingSupport() && random.nextBool();
 
         GrGpu::DrawType drawType = usePathRendering ? GrGpu::kDrawPath_DrawType :
                                                       GrGpu::kDrawPoints_DrawType;
 
         // twiddle drawstate knobs randomly
         bool hasGeometryProcessor = usePathRendering ? false : random.nextBool();
         if (hasGeometryProcessor) {
-            set_random_gp(this, &random, dummyTextures);
+            set_random_gp(fContext, gpu->glCaps(), ds, &random, dummyTextures);
         }
-        set_random_color_coverage_stages(this, maxStages - hasGeometryProcessor, usePathRendering,
-                                         &random, dummyTextures);
-        set_random_color(this, &random);
-        set_random_coverage(this, &random);
-        set_random_hints(this, &random);
-        set_random_state(this, &random);
-        set_random_blend_func(this, &random);
-        set_random_stencil(this, &random);
+        set_random_color_coverage_stages(gpu,
+                                         ds,
+                                         maxStages - hasGeometryProcessor,
+                                         usePathRendering,
+                                         &random,
+                                         dummyTextures);
+        set_random_color(ds, &random);
+        set_random_coverage(ds, &random);
+        set_random_hints(ds, &random);
+        set_random_state(ds, &random);
+        set_random_blend_func(ds, &random);
+        set_random_stencil(ds, &random);
 
         GrDeviceCoordTexture dstCopy;
 
         if (!this->setupDstReadIfNecessary(&dstCopy, NULL)) {
             SkDebugf("Couldn't setup dst read texture");
             return false;
         }
 
         // create optimized draw state, setup readDst texture if required, and build a descriptor
         // and program.  ODS creation can fail, so we have to check
         SkAutoTUnref<GrOptDrawState> ods(GrOptDrawState::Create(this->getDrawState(),
-                                                                this,
+                                                                gpu,
                                                                 &dstCopy,
                                                                 drawType));
         if (!ods.get()) {
             ds->reset();
             continue;
         }
-        SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(*ods, drawType, this));
+        SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(*ods, drawType, gpu));
         if (NULL == program.get()) {
             SkDebugf("Failed to create program!");
             return false;
         }
 
         // We have to reset the drawstate because we might have added a gp
         ds->reset();
 
         // because occasionally optimized drawstate creation will fail for valid reasons, we only
         // want to increment on success
@@ skipping 22 matching lines @@
                 maxStages = 1;
             } else {
                 return;
             }
 #if SK_ANGLE
             // Some long shaders run out of temporary registers in the D3D compiler on ANGLE.
             if (type == GrContextFactory::kANGLE_GLContextType) {
                 maxStages = 3;
             }
 #endif
-            REPORTER_ASSERT(reporter, gpu->programUnitTest(maxStages));
+            GrTestTarget target;
+            context->getTestTarget(&target);
+            REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif