/* * Copyright 2011 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "GrStencil.h" //////////////////////////////////////////////////////////////////////////////// // Stencil Rules for Merging user stencil space into clip // We can't include the clip bit in the ref or mask values because the division // between user and clip bits in the stencil depends on the number of stencil // bits in the runtime. Comments below indicate what the code should do to // incorporate the clip bit into these settings. /////// // Replace // set the ref to be the clip bit, but mask it out for the test GR_STATIC_CONST_SAME_STENCIL(gUserToClipReplace, kReplace_StencilOp, kZero_StencilOp, kLess_StencilFunc, 0xffff, // unset clip bit 0x0000, // set clip bit 0xffff); GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipReplace, kReplace_StencilOp, kZero_StencilOp, kEqual_StencilFunc, 0xffff, // unset clip bit 0x0000, // set clip bit 0xffff); /////// // Intersect GR_STATIC_CONST_SAME_STENCIL(gUserToClipIsect, kReplace_StencilOp, kZero_StencilOp, kLess_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipIsect, kReplace_StencilOp, kZero_StencilOp, kEqual_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); /////// // Difference GR_STATIC_CONST_SAME_STENCIL(gUserToClipDiff, kReplace_StencilOp, kZero_StencilOp, kEqual_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipDiff, kReplace_StencilOp, kZero_StencilOp, kLess_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); /////// // Union // first pass makes all the passing cases >= just clip bit set. GR_STATIC_CONST_SAME_STENCIL(gUserToClipUnionPass0, kReplace_StencilOp, kKeep_StencilOp, kLEqual_StencilFunc, 0xffff, 0x0001, // set clip bit 0xffff); // second pass allows anything greater than just clip bit set to pass GR_STATIC_CONST_SAME_STENCIL(gUserToClipUnionPass1, kReplace_StencilOp, kZero_StencilOp, kLEqual_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); // first pass finds zeros in the user bits and if found sets // the clip bit to 1 GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipUnionPass0, kReplace_StencilOp, kKeep_StencilOp, kEqual_StencilFunc, 0xffff, 0x0000, // set clip bit 0x0000 // set clip bit ); // second pass zeros the user bits GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipUnionPass1, kZero_StencilOp, kZero_StencilOp, kLess_StencilFunc, 0xffff, 0x0000, 0xffff // unset clip bit ); /////// // Xor GR_STATIC_CONST_SAME_STENCIL(gUserToClipXorPass0, kInvert_StencilOp, kKeep_StencilOp, kEqual_StencilFunc, 0xffff, // unset clip bit 0x0000, 0xffff); GR_STATIC_CONST_SAME_STENCIL(gUserToClipXorPass1, kReplace_StencilOp, kZero_StencilOp, kGreater_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipXorPass0, kInvert_StencilOp, kKeep_StencilOp, kEqual_StencilFunc, 0xffff, // unset clip bit 0x0000, 0xffff); GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipXorPass1, kReplace_StencilOp, kZero_StencilOp, kLess_StencilFunc, 0xffff, 0x0000, // set clip bit 0xffff); /////// // Reverse Diff GR_STATIC_CONST_SAME_STENCIL(gUserToClipRDiffPass0, kInvert_StencilOp, kZero_StencilOp, kLess_StencilFunc, 0xffff, // unset clip bit 0x0000, // set clip bit 0xffff); GR_STATIC_CONST_SAME_STENCIL(gUserToClipRDiffPass1, kReplace_StencilOp, kZero_StencilOp, kEqual_StencilFunc, 0x0000, // set clip bit 0x0000, // set clip bit 0xffff); // We are looking for stencil values that are all zero. The first pass sets the // clip bit if the stencil is all zeros. The second pass clears the user bits. GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipRDiffPass0, kInvert_StencilOp, kZero_StencilOp, kEqual_StencilFunc, 0xffff, 0x0000, 0x0000 // set clip bit ); GR_STATIC_CONST_SAME_STENCIL(gInvUserToClipRDiffPass1, kZero_StencilOp, kZero_StencilOp, kAlways_StencilFunc, 0xffff, 0x0000, 0xffff // unset clip bit ); /////// // Direct to Stencil // We can render a clip element directly without first writing to the client // portion of the clip when the fill is not inverse and the set operation will // only modify the in/out status of samples covered by the clip element. // this one only works if used right after stencil clip was cleared. // Our GrClip doesn't allow midstream replace ops. GR_STATIC_CONST_SAME_STENCIL(gReplaceClip, kReplace_StencilOp, kReplace_StencilOp, kAlways_StencilFunc, 0xffff, 0x0000, // set clip bit 0x0000 // set clipBit ); GR_STATIC_CONST_SAME_STENCIL(gUnionClip, kReplace_StencilOp, kReplace_StencilOp, kAlways_StencilFunc, 0xffff, 0x0000, // set clip bit 0x0000 // set clip bit ); GR_STATIC_CONST_SAME_STENCIL(gXorClip, kInvert_StencilOp, kInvert_StencilOp, kAlways_StencilFunc, 0xffff, 0x0000, 0x0000 // set clip bit ); GR_STATIC_CONST_SAME_STENCIL(gDiffClip, kZero_StencilOp, kZero_StencilOp, kAlways_StencilFunc, 0xffff, 0x0000, 0x0000 // set clip bit ); bool GrStencilSettings::GetClipPasses( SkRegion::Op op, bool canBeDirect, unsigned int stencilClipMask, bool invertedFill, int* numPasses, GrStencilSettings settings[kMaxStencilClipPasses]) { if (canBeDirect && !invertedFill) { *numPasses = 0; switch (op) { case SkRegion::kReplace_Op: *numPasses = 1; settings[0] = gReplaceClip; break; case SkRegion::kUnion_Op: *numPasses = 1; settings[0] = gUnionClip; break; case SkRegion::kXOR_Op: *numPasses = 1; settings[0] = gXorClip; break; case SkRegion::kDifference_Op: *numPasses = 1; settings[0] = gDiffClip; break; default: // suppress warning break; } if (1 == *numPasses) { settings[0].fFuncRefs[kFront_Face] |= stencilClipMask; settings[0].fWriteMasks[kFront_Face] |= stencilClipMask; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; settings[0].fWriteMasks[kBack_Face] = settings[0].fWriteMasks[kFront_Face]; return true; } } switch (op) { // if we make the path renderer go to stencil we always give it a // non-inverted fill and we use the stencil rules on the client->clipbit // pass to select either the zeros or nonzeros. case SkRegion::kReplace_Op: *numPasses= 1; settings[0] = invertedFill ? gInvUserToClipReplace : gUserToClipReplace; settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask; settings[0].fFuncRefs[kFront_Face] |= stencilClipMask; settings[0].fFuncMasks[kBack_Face] = settings[0].fFuncMasks[kFront_Face]; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; break; case SkRegion::kIntersect_Op: *numPasses = 1; settings[0] = invertedFill ? gInvUserToClipIsect : gUserToClipIsect; settings[0].fFuncRefs[kFront_Face] = stencilClipMask; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; break; case SkRegion::kUnion_Op: *numPasses = 2; if (invertedFill) { settings[0] = gInvUserToClipUnionPass0; settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask; settings[0].fFuncMasks[kBack_Face] = settings[0].fFuncMasks[kFront_Face]; settings[0].fFuncRefs[kFront_Face] |= stencilClipMask; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; settings[0].fWriteMasks[kFront_Face] |= stencilClipMask; settings[0].fWriteMasks[kBack_Face] = settings[0].fWriteMasks[kFront_Face]; settings[1] = gInvUserToClipUnionPass1; settings[1].fWriteMasks[kFront_Face] &= ~stencilClipMask; settings[1].fWriteMasks[kBack_Face] &= settings[1].fWriteMasks[kFront_Face]; } else { settings[0] = gUserToClipUnionPass0; settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask; settings[0].fFuncRefs[kFront_Face] |= stencilClipMask; settings[0].fFuncMasks[kBack_Face] = settings[0].fFuncMasks[kFront_Face]; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; settings[1] = gUserToClipUnionPass1; settings[1].fFuncRefs[kFront_Face] |= stencilClipMask; settings[1].fFuncRefs[kBack_Face] = settings[1].fFuncRefs[kFront_Face]; } break; case SkRegion::kXOR_Op: *numPasses = 2; if (invertedFill) { settings[0] = gInvUserToClipXorPass0; settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask; settings[0].fFuncMasks[kBack_Face] = settings[0].fFuncMasks[kFront_Face]; settings[1] = gInvUserToClipXorPass1; settings[1].fFuncRefs[kFront_Face] |= stencilClipMask; settings[1].fFuncRefs[kBack_Face] = settings[1].fFuncRefs[kFront_Face]; } else { settings[0] = gUserToClipXorPass0; settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask; settings[0].fFuncMasks[kBack_Face] = settings[0].fFuncMasks[kFront_Face]; settings[1] = gUserToClipXorPass1; settings[1].fFuncRefs[kFront_Face] |= stencilClipMask; settings[1].fFuncRefs[kBack_Face] = settings[1].fFuncRefs[kFront_Face]; } break; case SkRegion::kDifference_Op: *numPasses = 1; settings[0] = invertedFill ? gInvUserToClipDiff : gUserToClipDiff; settings[0].fFuncRefs[kFront_Face] |= stencilClipMask; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; break; case SkRegion::kReverseDifference_Op: if (invertedFill) { *numPasses = 2; settings[0] = gInvUserToClipRDiffPass0; settings[0].fWriteMasks[kFront_Face] |= stencilClipMask; settings[0].fWriteMasks[kBack_Face] = settings[0].fWriteMasks[kFront_Face]; settings[1] = gInvUserToClipRDiffPass1; settings[1].fWriteMasks[kFront_Face] &= ~stencilClipMask; settings[1].fWriteMasks[kBack_Face] = settings[1].fWriteMasks[kFront_Face]; } else { *numPasses = 2; settings[0] = gUserToClipRDiffPass0; settings[0].fFuncMasks[kFront_Face] &= ~stencilClipMask; settings[0].fFuncMasks[kBack_Face] = settings[0].fFuncMasks[kFront_Face]; settings[0].fFuncRefs[kFront_Face] |= stencilClipMask; settings[0].fFuncRefs[kBack_Face] = settings[0].fFuncRefs[kFront_Face]; settings[1] = gUserToClipRDiffPass1; settings[1].fFuncMasks[kFront_Face] |= stencilClipMask; settings[1].fFuncRefs[kFront_Face] |= stencilClipMask; settings[1].fFuncMasks[kBack_Face] = settings[1].fFuncMasks[kFront_Face]; settings[1].fFuncRefs[kBack_Face] = settings[1].fFuncRefs[kFront_Face]; } break; default: GrCrash("Unknown set op"); } return false; }