src/third_party/skia/tests/GLProgramsTest.cpp

   1
   2 /*
   3  * Copyright 2011 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 // This is a GPU-backend specific test. It relies on static intializers to work
  10
  11 #include "SkTypes.h"
  12
  13 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
  14
  15 #include "GrBackendProcessorFactory.h"
  16 #include "GrContextFactory.h"
  17 #include "GrOptDrawState.h"
  18 #include "effects/GrConfigConversionEffect.h"
  19 #include "gl/GrGLPathRendering.h"
  20 #include "gl/GrGpuGL.h"
  21 #include "SkChecksum.h"
  22 #include "SkRandom.h"
  23 #include "Test.h"
  24
  25 static void get_stage_stats(const GrFragmentStage stage, bool* readsDst,
  26                             bool* readsFragPosition, bool* requiresVertexShader) {
  27     if (stage.getFragmentProcessor()->willReadDstColor()) {
  28         *readsDst = true;
  29     }
  30     if (stage.getProcessor()->willReadFragmentPosition()) {
  31         *readsFragPosition = true;
  32     }
  33 }
  34
  35 bool GrGLProgramDesc::setRandom(SkRandom* random,
  36                                 GrGpuGL* gpu,
  37                                 const GrRenderTarget* dstRenderTarget,
  38                                 const GrTexture* dstCopyTexture,
  39                                 const GrGeometryStage* geometryProcessor,
  40                                 const GrFragmentStage* stages[],
  41                                 int numColorStages,
  42                                 int numCoverageStages,
  43                                 int currAttribIndex,
  44                                 GrGpu::DrawType drawType) {
  45     bool isPathRendering = GrGpu::IsPathRenderingDrawType(drawType);
  46     bool useLocalCoords = !isPathRendering &&
  47                           random->nextBool() &&
  48                           currAttribIndex < GrDrawState::kMaxVertexAttribCnt;
  49
  50     int numStages = numColorStages + numCoverageStages;
  51     fKey.reset();
  52
  53     GR_STATIC_ASSERT(0 == kEffectKeyOffsetsAndLengthOffset % sizeof(uint32_t));
  54
  55     // Make room for everything up to and including the array of offsets to effect keys.
  56     fKey.push_back_n(kEffectKeyOffsetsAndLengthOffset + 2 * sizeof(uint16_t) * (numStages +
  57             (geometryProcessor ? 1 : 0)));
  58
  59     bool dstRead = false;
  60     bool fragPos = false;
  61     bool vertexShader = SkToBool(geometryProcessor);
  62     int offset = 0;
  63     if (geometryProcessor) {
  64         const GrGeometryStage* stage = geometryProcessor;
  65         uint16_t* offsetAndSize = reinterpret_cast<uint16_t*>(fKey.begin() +
  66                                                               kEffectKeyOffsetsAndLengthOffset +
  67                                                               offset * 2 * sizeof(uint16_t));
  68         uint32_t effectKeyOffset = fKey.count();
  69         if (effectKeyOffset > SK_MaxU16) {
  70             fKey.reset();
  71             return false;
  72         }
  73         GrProcessorKeyBuilder b(&fKey);
  74         uint16_t effectKeySize;
  75         if (!GetProcessorKey(*stage, gpu->glCaps(), useLocalCoords, &b, &effectKeySize)) {
  76             fKey.reset();
  77             return false;
  78         }
  79         vertexShader = true;
  80         fragPos = stage->getProcessor()->willReadFragmentPosition();
  81         offsetAndSize[0] = effectKeyOffset;
  82         offsetAndSize[1] = effectKeySize;
  83         offset++;
  84     }
  85
  86     for (int s = 0; s < numStages; ++s, ++offset) {
  87         const GrFragmentStage* stage = stages[s];
  88         uint16_t* offsetAndSize = reinterpret_cast<uint16_t*>(fKey.begin() +
  89                                                               kEffectKeyOffsetsAndLengthOffset +
  90                                                               offset * 2 * sizeof(uint16_t));
  91         uint32_t effectKeyOffset = fKey.count();
  92         if (effectKeyOffset > SK_MaxU16) {
  93             fKey.reset();
  94             return false;
  95         }
  96         GrProcessorKeyBuilder b(&fKey);
  97         uint16_t effectKeySize;
  98         if (!GetProcessorKey(*stages[s], gpu->glCaps(), useLocalCoords, &b, &effectKeySize)) {
  99             fKey.reset();
 100             return false;
 101         }
 102         get_stage_stats(*stage, &dstRead, &fragPos, &vertexShader);
 103         offsetAndSize[0] = effectKeyOffset;
 104         offsetAndSize[1] = effectKeySize;
 105     }
 106
 107     KeyHeader* header = this->header();
 108     memset(header, 0, kHeaderSize);
 109     header->fEmitsPointSize = random->nextBool();
 110
 111     header->fPositionAttributeIndex = 0;
 112
 113     // if the effects have used up all off the available attributes,
 114     // don't try to use color or coverage attributes as input
 115     do {
 116         header->fColorInput = static_cast<GrGLProgramDesc::ColorInput>(
 117                                      random->nextULessThan(kColorInputCnt));
 118     } while ((GrDrawState::kMaxVertexAttribCnt <= currAttribIndex || isPathRendering) &&
 119              kAttribute_ColorInput == header->fColorInput);
 120     header->fColorAttributeIndex = (header->fColorInput == kAttribute_ColorInput) ?
 121                                         currAttribIndex++ :
 122                                         -1;
 123
 124     do {
 125         header->fCoverageInput = static_cast<GrGLProgramDesc::ColorInput>(
 126                                      random->nextULessThan(kColorInputCnt));
 127     } while ((GrDrawState::kMaxVertexAttribCnt <= currAttribIndex || isPathRendering)  &&
 128              kAttribute_ColorInput == header->fCoverageInput);
 129     header->fCoverageAttributeIndex = (header->fCoverageInput == kAttribute_ColorInput) ?
 130                                         currAttribIndex++ :
 131                                         -1;
 132     bool useGS = random->nextBool();
 133 #if GR_GL_EXPERIMENTAL_GS
 134     header->fExperimentalGS = gpu->caps()->geometryShaderSupport() && useGS;
 135 #else
 136     (void) useGS;
 137 #endif
 138
 139     header->fLocalCoordAttributeIndex = useLocalCoords ? currAttribIndex++ : -1;
 140
 141     header->fColorEffectCnt = numColorStages;
 142     header->fCoverageEffectCnt = numCoverageStages;
 143
 144     if (dstRead) {
 145         header->fDstReadKey = SkToU8(GrGLFragmentShaderBuilder::KeyForDstRead(dstCopyTexture,
 146                                                                       gpu->glCaps()));
 147     } else {
 148         header->fDstReadKey = 0;
 149     }
 150     if (fragPos) {
 151         header->fFragPosKey = SkToU8(GrGLFragmentShaderBuilder::KeyForFragmentPosition(dstRenderTarget,
 152                                                                                gpu->glCaps()));
 153     } else {
 154         header->fFragPosKey = 0;
 155     }
 156
 157     header->fUseFragShaderOnly = isPathRendering && gpu->glPathRendering()->texturingMode() ==
 158                                                     GrGLPathRendering::FixedFunction_TexturingMode;
 159     header->fHasGeometryProcessor = vertexShader;
 160
 161     GrOptDrawState::PrimaryOutputType primaryOutput;
 162     GrOptDrawState::SecondaryOutputType secondaryOutput;
 163     if (!dstRead) {
 164         primaryOutput = GrOptDrawState::kModulate_PrimaryOutputType;
 165     } else {
 166         primaryOutput = static_cast<GrOptDrawState::PrimaryOutputType>(
 167             random->nextULessThan(GrOptDrawState::kPrimaryOutputTypeCnt));
 168     }
 169
 170     if (GrOptDrawState::kCombineWithDst_PrimaryOutputType == primaryOutput ||
 171         !gpu->caps()->dualSourceBlendingSupport()) {
 172         secondaryOutput = GrOptDrawState::kNone_SecondaryOutputType;
 173     } else {
 174         secondaryOutput = static_cast<GrOptDrawState::SecondaryOutputType>(
 175             random->nextULessThan(GrOptDrawState::kSecondaryOutputTypeCnt));
 176     }
 177
 178     header->fPrimaryOutputType = primaryOutput;
 179     header->fSecondaryOutputType = secondaryOutput;
 180
 181     this->finalize();
 182     return true;
 183 }
 184
 185 // TODO clean this up, we have to do this to test geometry processors but there has got to be
 186 // a better way.  In the mean time, we actually fill out these generic vertex attribs below with
 187 // the correct vertex attribs from the GP.  We have to ensure, however, we don't try to add more
 188 // than two attributes.
 189 GrVertexAttrib genericVertexAttribs[] = {
 190     { kVec2f_GrVertexAttribType, 0,   kPosition_GrVertexAttribBinding },
 191     { kVec2f_GrVertexAttribType, 0,   kGeometryProcessor_GrVertexAttribBinding },
 192     { kVec2f_GrVertexAttribType, 0,   kGeometryProcessor_GrVertexAttribBinding }
 193 };
 194
 195 /*
 196  * convert sl type to vertexattrib type, not a complete implementation, only use for debugging
 197  */
 198 GrVertexAttribType convert_sltype_to_attribtype(GrSLType type) {
 199     switch (type) {
 200         case kFloat_GrSLType:
 201             return kFloat_GrVertexAttribType;
 202         case kVec2f_GrSLType:
 203             return kVec2f_GrVertexAttribType;
 204         case kVec3f_GrSLType:
 205             return kVec3f_GrVertexAttribType;
 206         case kVec4f_GrSLType:
 207             return kVec4f_GrVertexAttribType;
 208         default:
 209             SkFAIL("Type isn't convertible");
 210             return kFloat_GrVertexAttribType;
 211     }
 212 }
 213 // TODO end test hack
 214
 215
 216 bool GrGpuGL::programUnitTest(int maxStages) {
 217
 218     GrTextureDesc dummyDesc;
 219     dummyDesc.fFlags = kRenderTarget_GrTextureFlagBit;
 220     dummyDesc.fConfig = kSkia8888_GrPixelConfig;
 221     dummyDesc.fWidth = 34;
 222     dummyDesc.fHeight = 18;
 223     SkAutoTUnref<GrTexture> dummyTexture1(this->createTexture(dummyDesc, NULL, 0));
 224     dummyDesc.fFlags = kNone_GrTextureFlags;
 225     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
 226     dummyDesc.fWidth = 16;
 227     dummyDesc.fHeight = 22;
 228     SkAutoTUnref<GrTexture> dummyTexture2(this->createTexture(dummyDesc, NULL, 0));
 229
 230     if (!dummyTexture1 || ! dummyTexture2) {
 231         return false;
 232     }
 233
 234     static const int NUM_TESTS = 512;
 235
 236     SkRandom random;
 237     for (int t = 0; t < NUM_TESTS; ++t) {
 238
 239 #if 0
 240         GrPrintf("\nTest Program %d\n-------------\n", t);
 241         static const int stop = -1;
 242         if (t == stop) {
 243             int breakpointhere = 9;
 244         }
 245 #endif
 246
 247         GrGLProgramDesc pdesc;
 248
 249         int currAttribIndex = 1;  // we need to always leave room for position
 250         int currTextureCoordSet = 0;
 251         GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
 252
 253         int numStages = random.nextULessThan(maxStages + 1);
 254         int numColorStages = random.nextULessThan(numStages + 1);
 255         int numCoverageStages = numStages - numColorStages;
 256
 257         SkAutoSTMalloc<8, const GrFragmentStage*> stages(numStages);
 258
 259         bool usePathRendering = this->glCaps().pathRenderingSupport() && random.nextBool();
 260
 261         GrGpu::DrawType drawType = usePathRendering ? GrGpu::kDrawPath_DrawType :
 262                                                       GrGpu::kDrawPoints_DrawType;
 263
 264         SkAutoTDelete<GrGeometryStage> geometryProcessor;
 265         bool hasGeometryProcessor = usePathRendering ? false : random.nextBool();
 266         if (hasGeometryProcessor) {
 267             while (true) {
 268                 SkAutoTUnref<const GrGeometryProcessor> effect(
 269                         GrProcessorTestFactory<GrGeometryProcessor>::CreateStage(&random, this->getContext(), *this->caps(),
 270                                                          dummyTextures));
 271                 SkASSERT(effect);
 272                 // Only geometryProcessor can use vertex shader
 273                 GrGeometryStage* stage = SkNEW_ARGS(GrGeometryStage, (effect.get()));
 274                 geometryProcessor.reset(stage);
 275
 276                 // we have to set dummy vertex attribs
 277                 const GrGeometryProcessor::VertexAttribArray& v = effect->getVertexAttribs();
 278                 int numVertexAttribs = v.count();
 279
 280                 SkASSERT(GrGeometryProcessor::kMaxVertexAttribs == 2 &&
 281                          GrGeometryProcessor::kMaxVertexAttribs >= numVertexAttribs);
 282                 size_t runningStride = GrVertexAttribTypeSize(genericVertexAttribs[0].fType);
 283                 for (int i = 0; i < numVertexAttribs; i++) {
 284                     genericVertexAttribs[i + 1].fOffset = runningStride;
 285                     genericVertexAttribs[i + 1].fType =
 286                             convert_sltype_to_attribtype(v[i].getType());
 287                     runningStride += GrVertexAttribTypeSize(genericVertexAttribs[i + 1].fType);
 288                 }
 289
 290                 // update the vertex attributes with the ds
 291                 GrDrawState* ds = this->drawState();
 292                 ds->setVertexAttribs<genericVertexAttribs>(numVertexAttribs + 1, runningStride);
 293                 currAttribIndex = numVertexAttribs + 1;
 294                 break;
 295             }
 296         }
 297         for (int s = 0; s < numStages;) {
 298             SkAutoTUnref<const GrFragmentProcessor> effect(
 299                     GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(
 300                                                                             &random,
 301                                                                             this->getContext(),
 302                                                                             *this->caps(),
 303                                                                             dummyTextures));
 304             SkASSERT(effect);
 305
 306             // If adding this effect would exceed the max texture coord set count then generate a
 307             // new random effect.
 308             if (usePathRendering && this->glPathRendering()->texturingMode() ==
 309                                     GrGLPathRendering::FixedFunction_TexturingMode) {;
 310                 int numTransforms = effect->numTransforms();
 311                 if (currTextureCoordSet + numTransforms > this->glCaps().maxFixedFunctionTextureCoords()) {
 312                     continue;
 313                 }
 314                 currTextureCoordSet += numTransforms;
 315             }
 316             GrFragmentStage* stage = SkNEW_ARGS(GrFragmentStage, (effect.get()));
 317
 318             stages[s] = stage;
 319             ++s;
 320         }
 321         const GrTexture* dstTexture = random.nextBool() ? dummyTextures[0] : dummyTextures[1];
 322         if (!pdesc.setRandom(&random,
 323                              this,
 324                              dummyTextures[0]->asRenderTarget(),
 325                              dstTexture,
 326                              geometryProcessor.get(),
 327                              stages.get(),
 328                              numColorStages,
 329                              numCoverageStages,
 330                              currAttribIndex,
 331                              drawType)) {
 332             return false;
 333         }
 334
 335         SkAutoTUnref<GrGLProgram> program(GrGLProgram::Create(this,
 336                                                               pdesc,
 337                                                               geometryProcessor.get(),
 338                                                               stages,
 339                                                               stages + numColorStages));
 340         for (int s = 0; s < numStages; ++s) {
 341             SkDELETE(stages[s]);
 342         }
 343         if (NULL == program.get()) {
 344             return false;
 345         }
 346
 347         // We have to reset the drawstate because we might have added a gp
 348         this->drawState()->reset();
 349     }
 350     return true;
 351 }
 352
 353 DEF_GPUTEST(GLPrograms, reporter, factory) {
 354     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
 355         GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(type));
 356         if (context) {
 357             GrGpuGL* gpu = static_cast<GrGpuGL*>(context->getGpu());
 358             int maxStages = 6;
 359 #if SK_ANGLE
 360             // Some long shaders run out of temporary registers in the D3D compiler on ANGLE.
 361             if (type == GrContextFactory::kANGLE_GLContextType) {
 362                 maxStages = 3;
 363             }
 364 #endif
 365             REPORTER_ASSERT(reporter, gpu->programUnitTest(maxStages));
 366         }
 367     }
 368 }
 369
 370 // This is evil evil evil. The linker may throw away whole translation units as dead code if it
 371 // thinks none of the functions are called. It will do this even if there are static initializers
 372 // in the unit that could pass pointers to functions from the unit out to other translation units!
 373 // We force some of the effects that would otherwise be discarded to link here.
 374
 375 #include "SkAlphaThresholdFilter.h"
 376 #include "SkColorMatrixFilter.h"
 377 #include "SkLightingImageFilter.h"
 378 #include "SkMagnifierImageFilter.h"
 379
 380 void forceLinking();
 381
 382 void forceLinking() {
 383     SkLightingImageFilter::CreateDistantLitDiffuse(SkPoint3(0,0,0), 0, 0, 0);
 384     SkAlphaThresholdFilter::Create(SkRegion(), .5f, .5f);
 385     SkAutoTUnref<SkImageFilter> mag(SkMagnifierImageFilter::Create(
 386         SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1));
 387     GrConfigConversionEffect::Create(NULL,
 388                                      false,
 389                                      GrConfigConversionEffect::kNone_PMConversion,
 390                                      SkMatrix::I());
 391     SkScalar matrix[20];
 392     SkAutoTUnref<SkColorMatrixFilter> cmf(SkColorMatrixFilter::Create(matrix));
 393 }
 394
 395 #endif