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
 
@@ skipping 355 matching lines @@
                                  0xffff,
                                  0xffff);
 
     if (random->nextBool()) {
         gpu->drawState()->setStencil(kDoesWriteStencil);
     } else {
         gpu->drawState()->setStencil(kDoesNotWriteStencil);
     }
 }
 
-bool GrGpuGL::programUnitTest(int maxStages) {
+bool GrDrawTarget::programUnitTest(int maxStages) {
+    GrGpuGL* gpu = static_cast<GrGpuGL*>(fContext->getGpu());

[bsalomon, 2014/11/05 19:13:43]

Does this have to be the GL subclass?

[joshualitt, 2014/11/05 19:55:47]

Otherwise we can't build the GL program and we need access to the GLCaps.

[bsalomon, 2014/11/05 20:00:22]

Gotcha, seems like we're pretty close to making this be backend-independent, but
not quite there yet.

     // 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();
@@ skipping 12 matching lines @@
 
     // 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));
+        SkAutoTUnref<GrRenderTarget> rt(random_render_target(gpu, glProgramsCacheID, &random));
         if (!rt) {
             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(gpu, &random, dummyTextures);
         }
-        set_random_color_coverage_stages(this, maxStages - hasGeometryProcessor, usePathRendering,
+        set_random_color_coverage_stages(gpu, 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(gpu, &random);
+        set_random_coverage(gpu, &random);
+        set_random_hints(gpu, &random);
+        set_random_state(gpu, &random);
+        set_random_blend_func(gpu, &random);
+        set_random_stencil(gpu, &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,
+        SkAutoTUnref<GrOptDrawState> ods(GrOptDrawState::Create(gpu->getDrawState(),
+                                                                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));
+            GrDrawTarget* dt = static_cast<GrDrawTarget*>(context->getDrawTarget());
+            REPORTER_ASSERT(reporter, dt->programUnitTest(maxStages));
         }
     }
 }
 
 #endif