src/third_party/skia/src/gpu/GrStencil.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
  10 #include "GrStencil.h"
  11
  12 ////////////////////////////////////////////////////////////////////////////////
  13 // Stencil Rules for Merging user stencil space into clip
  14
  15 // We can't include the clip bit in the ref or mask values because the division
  16 // between user and clip bits in the stencil depends on the number of stencil
  17 // bits in the runtime. Comments below indicate what the code should do to
  18 // incorporate the clip bit into these settings.
  19
  20 ///////
  21 // Replace
  22
  23 // set the ref to be the clip bit, but mask it out for the test
  24 GR_STATIC_CONST_SAME_STENCIL(gUserToClipReplace,
  25     kReplace_StencilOp,
  26     kZero_StencilOp,
  27     kLess_StencilFunc,
  28     0xffff,           // unset clip bit
  29     0x0000,           // set clip bit
  30     0xffff);
  31
  32 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipReplace,
  33     kReplace_StencilOp,
  34     kZero_StencilOp,
  35     kEqual_StencilFunc,
  36     0xffff,           // unset clip bit
  37     0x0000,           // set clip bit
  38     0xffff);
  39
  40 ///////
  41 // Intersect
  42 GR_STATIC_CONST_SAME_STENCIL(gUserToClipIsect,
  43     kReplace_StencilOp,
  44     kZero_StencilOp,
  45     kLess_StencilFunc,
  46     0xffff,
  47     0x0000,           // set clip bit
  48     0xffff);
  49
  50 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipIsect,
  51     kReplace_StencilOp,
  52     kZero_StencilOp,
  53     kEqual_StencilFunc,
  54     0xffff,
  55     0x0000,           // set clip bit
  56     0xffff);
  57
  58 ///////
  59 // Difference
  60 GR_STATIC_CONST_SAME_STENCIL(gUserToClipDiff,
  61     kReplace_StencilOp,
  62     kZero_StencilOp,
  63     kEqual_StencilFunc,
  64     0xffff,
  65     0x0000,           // set clip bit
  66     0xffff);
  67
  68 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipDiff,
  69     kReplace_StencilOp,
  70     kZero_StencilOp,
  71     kLess_StencilFunc,
  72     0xffff,
  73     0x0000,           // set clip bit
  74     0xffff);
  75
  76 ///////
  77 // Union
  78
  79 // first pass makes all the passing cases >= just clip bit set.
  80 GR_STATIC_CONST_SAME_STENCIL(gUserToClipUnionPass0,
  81     kReplace_StencilOp,
  82     kKeep_StencilOp,
  83     kLEqual_StencilFunc,
  84     0xffff,
  85     0x0001,           // set clip bit
  86     0xffff);
  87
  88 // second pass allows anything greater than just clip bit set to pass
  89 GR_STATIC_CONST_SAME_STENCIL(gUserToClipUnionPass1,
  90     kReplace_StencilOp,
  91     kZero_StencilOp,
  92     kLEqual_StencilFunc,
  93     0xffff,
  94     0x0000,           // set clip bit
  95     0xffff);
  96
  97 // first pass finds zeros in the user bits and if found sets
  98 // the clip bit to 1
  99 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipUnionPass0,
 100     kReplace_StencilOp,
 101     kKeep_StencilOp,
 102     kEqual_StencilFunc,
 103     0xffff,
 104     0x0000,           // set clip bit
 105     0x0000            // set clip bit
 106 );
 107
 108 // second pass zeros the user bits
 109 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipUnionPass1,
 110     kZero_StencilOp,
 111     kZero_StencilOp,
 112     kLess_StencilFunc,
 113     0xffff,
 114     0x0000,
 115     0xffff            // unset clip bit
 116 );
 117
 118 ///////
 119 // Xor
 120 GR_STATIC_CONST_SAME_STENCIL(gUserToClipXorPass0,
 121     kInvert_StencilOp,
 122     kKeep_StencilOp,
 123     kEqual_StencilFunc,
 124     0xffff,           // unset clip bit
 125     0x0000,
 126     0xffff);
 127
 128 GR_STATIC_CONST_SAME_STENCIL(gUserToClipXorPass1,
 129     kReplace_StencilOp,
 130     kZero_StencilOp,
 131     kGreater_StencilFunc,
 132     0xffff,
 133     0x0000,          // set clip bit
 134     0xffff);
 135
 136 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipXorPass0,
 137     kInvert_StencilOp,
 138     kKeep_StencilOp,
 139     kEqual_StencilFunc,
 140     0xffff,           // unset clip bit
 141     0x0000,
 142     0xffff);
 143
 144 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipXorPass1,
 145     kReplace_StencilOp,
 146     kZero_StencilOp,
 147     kLess_StencilFunc,
 148     0xffff,
 149     0x0000,          // set clip bit
 150     0xffff);
 151
 152 ///////
 153 // Reverse Diff
 154 GR_STATIC_CONST_SAME_STENCIL(gUserToClipRDiffPass0,
 155     kInvert_StencilOp,
 156     kZero_StencilOp,
 157     kLess_StencilFunc,
 158     0xffff,         // unset clip bit
 159     0x0000,         // set clip bit
 160     0xffff);
 161
 162 GR_STATIC_CONST_SAME_STENCIL(gUserToClipRDiffPass1,
 163     kReplace_StencilOp,
 164     kZero_StencilOp,
 165     kEqual_StencilFunc,
 166     0x0000,          // set clip bit
 167     0x0000,          // set clip bit
 168     0xffff);
 169
 170 // We are looking for stencil values that are all zero. The first pass sets the
 171 // clip bit if the stencil is all zeros. The second pass clears the user bits.
 172 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipRDiffPass0,
 173     kInvert_StencilOp,
 174     kZero_StencilOp,
 175     kEqual_StencilFunc,
 176     0xffff,
 177     0x0000,
 178     0x0000           // set clip bit
 179 );
 180
 181 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipRDiffPass1,
 182     kZero_StencilOp,
 183     kZero_StencilOp,
 184     kAlways_StencilFunc,
 185     0xffff,
 186     0x0000,
 187     0xffff           // unset clip bit
 188 );
 189
 190 ///////
 191 // Direct to Stencil
 192
 193 // We can render a clip element directly without first writing to the client
 194 // portion of the clip when the fill is not inverse and the set operation will
 195 // only modify the in/out status of samples covered by the clip element.
 196
 197 // this one only works if used right after stencil clip was cleared.
 198 // Our clip mask creation code doesn't allow midstream replace ops.
 199 GR_STATIC_CONST_SAME_STENCIL(gReplaceClip,
 200     kReplace_StencilOp,
 201     kReplace_StencilOp,
 202     kAlways_StencilFunc,
 203     0xffff,
 204     0x0000,           // set clip bit
 205     0x0000            // set clipBit
 206 );
 207
 208 GR_STATIC_CONST_SAME_STENCIL(gUnionClip,
 209     kReplace_StencilOp,
 210     kReplace_StencilOp,
 211     kAlways_StencilFunc,
 212     0xffff,
 213     0x0000,           // set clip bit
 214     0x0000            // set clip bit
 215 );
 216
 217 GR_STATIC_CONST_SAME_STENCIL(gXorClip,
 218     kInvert_StencilOp,
 219     kInvert_StencilOp,
 220     kAlways_StencilFunc,
 221     0xffff,
 222     0x0000,
 223     0x0000            // set clip bit
 224 );
 225
 226 GR_STATIC_CONST_SAME_STENCIL(gDiffClip,
 227     kZero_StencilOp,
 228     kZero_StencilOp,
 229     kAlways_StencilFunc,
 230     0xffff,
 231     0x0000,
 232     0x0000            // set clip bit
 233 );
 234
 235 bool GrStencilSettings::GetClipPasses(
 236                             SkRegion::Op op,
 237                             bool canBeDirect,
 238                             unsigned int stencilClipMask,
 239                             bool invertedFill,
 240                             int* numPasses,
 241                             GrStencilSettings settings[kMaxStencilClipPasses]) {
 242     if (canBeDirect && !invertedFill) {
 243         *numPasses = 0;
 244         switch (op) {
 245             case SkRegion::kReplace_Op:
 246                 *numPasses = 1;
 247                 settings[0] = gReplaceClip;
 248                 break;
 249             case SkRegion::kUnion_Op:
 250                 *numPasses = 1;
 251                 settings[0] = gUnionClip;
 252                 break;
 253             case SkRegion::kXOR_Op:
 254                 *numPasses = 1;
 255                 settings[0] = gXorClip;
 256                 break;
 257             case SkRegion::kDifference_Op:
 258                 *numPasses = 1;
 259                 settings[0] = gDiffClip;
 260                 break;
 261             default: // suppress warning
 262                 break;
 263         }
 264         if (1 == *numPasses) {
 265             settings[0].fFuncRefs[kFront_Face]   |= stencilClipMask;
 266             settings[0].fWriteMasks[kFront_Face] |= stencilClipMask;
 267             settings[0].fFuncRefs[kBack_Face] =
 268                 settings[0].fFuncRefs[kFront_Face];
 269             settings[0].fWriteMasks[kBack_Face] =
 270                 settings[0].fWriteMasks[kFront_Face];
 271             return true;
 272         }
 273     }
 274     switch (op) {
 275         // if we make the path renderer go to stencil we always give it a
 276         // non-inverted fill and we use the stencil rules on the client->clipbit
 277         // pass to select either the zeros or nonzeros.
 278         case SkRegion::kReplace_Op:
 279             *numPasses= 1;
 280             settings[0] = invertedFill ? gInvUserToClipReplace :
 281                                          gUserToClipReplace;
 282             settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask;
 283             settings[0].fFuncRefs[kFront_Face] |= stencilClipMask;
 284             settings[0].fFuncMasks[kBack_Face] =
 285                 settings[0].fFuncMasks[kFront_Face];
 286             settings[0].fFuncRefs[kBack_Face] =
 287                 settings[0].fFuncRefs[kFront_Face];
 288             break;
 289         case SkRegion::kIntersect_Op:
 290             *numPasses = 1;
 291             settings[0] = invertedFill ? gInvUserToClipIsect : gUserToClipIsect;
 292             settings[0].fFuncRefs[kFront_Face] = stencilClipMask;
 293             settings[0].fFuncRefs[kBack_Face] =
 294                 settings[0].fFuncRefs[kFront_Face];
 295             break;
 296         case SkRegion::kUnion_Op:
 297             *numPasses = 2;
 298             if (invertedFill) {
 299                 settings[0] = gInvUserToClipUnionPass0;
 300                 settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask;
 301                 settings[0].fFuncMasks[kBack_Face] =
 302                     settings[0].fFuncMasks[kFront_Face];
 303                 settings[0].fFuncRefs[kFront_Face] |= stencilClipMask;
 304                 settings[0].fFuncRefs[kBack_Face] =
 305                     settings[0].fFuncRefs[kFront_Face];
 306                 settings[0].fWriteMasks[kFront_Face] |= stencilClipMask;
 307                 settings[0].fWriteMasks[kBack_Face] =
 308                     settings[0].fWriteMasks[kFront_Face];
 309
 310                 settings[1] = gInvUserToClipUnionPass1;
 311                 settings[1].fWriteMasks[kFront_Face] &= ~stencilClipMask;
 312                 settings[1].fWriteMasks[kBack_Face] &=
 313                     settings[1].fWriteMasks[kFront_Face];
 314
 315             } else {
 316                 settings[0] = gUserToClipUnionPass0;
 317                 settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask;
 318                 settings[0].fFuncRefs[kFront_Face] |= stencilClipMask;
 319                 settings[0].fFuncMasks[kBack_Face] =
 320                     settings[0].fFuncMasks[kFront_Face];
 321                 settings[0].fFuncRefs[kBack_Face] =
 322                     settings[0].fFuncRefs[kFront_Face];
 323
 324                 settings[1] = gUserToClipUnionPass1;
 325                 settings[1].fFuncRefs[kFront_Face] |= stencilClipMask;
 326                 settings[1].fFuncRefs[kBack_Face] =
 327                     settings[1].fFuncRefs[kFront_Face];
 328             }
 329             break;
 330         case SkRegion::kXOR_Op:
 331             *numPasses = 2;
 332             if (invertedFill) {
 333                 settings[0] = gInvUserToClipXorPass0;
 334                 settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask;
 335                 settings[0].fFuncMasks[kBack_Face] =
 336                     settings[0].fFuncMasks[kFront_Face];
 337
 338                 settings[1] = gInvUserToClipXorPass1;
 339                 settings[1].fFuncRefs[kFront_Face] |= stencilClipMask;
 340                 settings[1].fFuncRefs[kBack_Face] =
 341                     settings[1].fFuncRefs[kFront_Face];
 342             } else {
 343                 settings[0] = gUserToClipXorPass0;
 344                 settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask;
 345                 settings[0].fFuncMasks[kBack_Face] =
 346                     settings[0].fFuncMasks[kFront_Face];
 347
 348                 settings[1] = gUserToClipXorPass1;
 349                 settings[1].fFuncRefs[kFront_Face] |= stencilClipMask;
 350                 settings[1].fFuncRefs[kBack_Face] =
 351                     settings[1].fFuncRefs[kFront_Face];
 352             }
 353             break;
 354         case SkRegion::kDifference_Op:
 355             *numPasses = 1;
 356             settings[0] = invertedFill ? gInvUserToClipDiff : gUserToClipDiff;
 357             settings[0].fFuncRefs[kFront_Face] |= stencilClipMask;
 358             settings[0].fFuncRefs[kBack_Face] =
 359                 settings[0].fFuncRefs[kFront_Face];
 360             break;
 361         case SkRegion::kReverseDifference_Op:
 362             if (invertedFill) {
 363                 *numPasses = 2;
 364                 settings[0] = gInvUserToClipRDiffPass0;
 365                 settings[0].fWriteMasks[kFront_Face] |= stencilClipMask;
 366                 settings[0].fWriteMasks[kBack_Face] =
 367                     settings[0].fWriteMasks[kFront_Face];
 368                 settings[1] = gInvUserToClipRDiffPass1;
 369                 settings[1].fWriteMasks[kFront_Face] &= ~stencilClipMask;
 370                 settings[1].fWriteMasks[kBack_Face] =
 371                     settings[1].fWriteMasks[kFront_Face];
 372             } else {
 373                 *numPasses = 2;
 374                 settings[0] = gUserToClipRDiffPass0;
 375                 settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask;
 376                 settings[0].fFuncMasks[kBack_Face] =
 377                     settings[0].fFuncMasks[kFront_Face];
 378                 settings[0].fFuncRefs[kFront_Face] |= stencilClipMask;
 379                 settings[0].fFuncRefs[kBack_Face] =
 380                     settings[0].fFuncRefs[kFront_Face];
 381
 382                 settings[1] = gUserToClipRDiffPass1;
 383                 settings[1].fFuncMasks[kFront_Face] |= stencilClipMask;
 384                 settings[1].fFuncRefs[kFront_Face] |= stencilClipMask;
 385                 settings[1].fFuncMasks[kBack_Face] =
 386                     settings[1].fFuncMasks[kFront_Face];
 387                 settings[1].fFuncRefs[kBack_Face] =
 388                     settings[1].fFuncRefs[kFront_Face];
 389             }
 390             break;
 391         default:
 392             SkFAIL("Unknown set op");
 393     }
 394     return false;
 395 }