Minor GrStencilSettings cleanup
Review URL: http://codereview.appspot.com/6329044/
git-svn-id: http://skia.googlecode.com/svn/trunk@4299 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 53221a3..6b80743 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -911,18 +911,9 @@
stencilBits = stencilBuffer->bits();
}
-#if GR_DEBUG
- if (!fGpu->getCaps().fStencilWrapOpsSupport) {
- GrAssert(settings.frontPassOp() != kIncWrap_StencilOp);
- GrAssert(settings.frontPassOp() != kDecWrap_StencilOp);
- GrAssert(settings.frontFailOp() != kIncWrap_StencilOp);
- GrAssert(settings.backFailOp() != kDecWrap_StencilOp);
- GrAssert(settings.backPassOp() != kIncWrap_StencilOp);
- GrAssert(settings.backPassOp() != kDecWrap_StencilOp);
- GrAssert(settings.backFailOp() != kIncWrap_StencilOp);
- GrAssert(settings.frontFailOp() != kDecWrap_StencilOp);
- }
-#endif
+ GrAssert(fGpu->getCaps().fStencilWrapOpsSupport ||
+ !settings.usesWrapOp());
+ GrAssert(fGpu->getCaps().fTwoSidedStencilSupport || !settings.isTwoSided());
this->adjustStencilParams(&settings, clipMode, stencilBits);
fGpu->setStencilSettings(settings);
}
diff --git a/src/gpu/GrStencil.h b/src/gpu/GrStencil.h
index 3a7595a..b4aa70e 100644
--- a/src/gpu/GrStencil.h
+++ b/src/gpu/GrStencil.h
@@ -178,19 +178,6 @@
fPad0 = fPad1 = 0;
this->setDisabled();
}
-
- GrStencilOp frontPassOp() const { return static_cast<GrStencilOp>(fPassOps[kFront_Face]); }
- GrStencilOp backPassOp() const { return static_cast<GrStencilOp>(fPassOps[kBack_Face]); }
- GrStencilOp frontFailOp() const { return static_cast<GrStencilOp>(fFailOps[kFront_Face]); }
- GrStencilOp backFailOp() const { return static_cast<GrStencilOp>(fFailOps[kBack_Face]); }
- GrStencilFunc frontFunc() const { return static_cast<GrStencilFunc>(fFuncs[kFront_Face]); }
- GrStencilFunc backFunc() const { return static_cast<GrStencilFunc>(fFuncs[kBack_Face]); }
- uint16_t frontFuncMask() const { return fFuncMasks[kFront_Face]; }
- uint16_t backFuncMask() const { return fFuncMasks[kBack_Face]; }
- uint16_t frontFuncRef() const { return fFuncRefs[kFront_Face]; }
- uint16_t backFuncRef() const { return fFuncRefs[kBack_Face]; }
- uint16_t frontWriteMask() const { return fWriteMasks[kFront_Face]; }
- uint16_t backWriteMask() const { return fWriteMasks[kFront_Face]; }
GrStencilOp passOp(Face f) const { return static_cast<GrStencilOp>(fPassOps[f]); }
GrStencilOp failOp(Face f) const { return static_cast<GrStencilOp>(fFailOps[f]); }
@@ -199,19 +186,6 @@
uint16_t funcRef(Face f) const { return fFuncRefs[f]; }
uint16_t writeMask(Face f) const { return fWriteMasks[f]; }
- void setFrontPassOp(GrStencilOp op) { fPassOps[kFront_Face] = op; fFlags = 0;}
- void setBackPassOp(GrStencilOp op) { fPassOps[kBack_Face] = op; fFlags = 0;}
- void setFrontFailOp(GrStencilOp op) { fFailOps[kFront_Face] = op; fFlags = 0;}
- void setBackFailOp(GrStencilOp op) { fFailOps[kBack_Face] = op; fFlags = 0;}
- void setFrontFunc(GrStencilFunc func) { fFuncs[kFront_Face] = func; fFlags = 0;}
- void setBackFunc(GrStencilFunc func) { fFuncs[kBack_Face] = func; fFlags = 0;}
- void setFrontFuncMask(unsigned short mask) { fFuncMasks[kFront_Face] = mask; }
- void setBackFuncMask(unsigned short mask) { fFuncMasks[kBack_Face] = mask; }
- void setFrontFuncRef(unsigned short ref) { fFuncRefs[kFront_Face] = ref; }
- void setBackFuncRef(unsigned short ref) { fFuncRefs[kBack_Face] = ref; }
- void setFrontWriteMask(unsigned short writeMask) { fWriteMasks[kFront_Face] = writeMask; }
- void setBackWriteMask(unsigned short writeMask) { fWriteMasks[kBack_Face] = writeMask; }
-
void setPassOp(Face f, GrStencilOp op) { fPassOps[f] = op; fFlags = 0;}
void setFailOp(Face f, GrStencilOp op) { fFailOps[f] = op; fFlags = 0;}
void setFunc(Face f, GrStencilFunc func) { fFuncs[f] = func; fFlags = 0;}
@@ -251,6 +225,26 @@
fFlags = kIsDisabled_StencilFlag | kDoesNotWrite_StencilFlag;
}
+ bool isTwoSided() const {
+ return fPassOps[kFront_Face] != fPassOps[kBack_Face] ||
+ fFailOps[kFront_Face] != fFailOps[kBack_Face] ||
+ fFuncs[kFront_Face] != fFuncs[kBack_Face] ||
+ fFuncMasks[kFront_Face] != fFuncMasks[kBack_Face] ||
+ fFuncRefs[kFront_Face] != fFuncRefs[kBack_Face] ||
+ fWriteMasks[kFront_Face] != fWriteMasks[kBack_Face];
+ }
+
+ bool usesWrapOp() const {
+ return kIncWrap_StencilOp == fPassOps[kFront_Face] ||
+ kDecWrap_StencilOp == fPassOps[kFront_Face] ||
+ kIncWrap_StencilOp == fPassOps[kBack_Face] ||
+ kDecWrap_StencilOp == fPassOps[kBack_Face] ||
+ kIncWrap_StencilOp == fFailOps[kFront_Face] ||
+ kDecWrap_StencilOp == fFailOps[kFront_Face] ||
+ kIncWrap_StencilOp == fFailOps[kBack_Face] ||
+ kDecWrap_StencilOp == fFailOps[kBack_Face];
+ }
+
bool isDisabled() const {
if (fFlags & kIsDisabled_StencilFlag) {
return true;
diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp
index 5b03500..6c0d4b2 100644
--- a/src/gpu/gl/GrGpuGL.cpp
+++ b/src/gpu/gl/GrGpuGL.cpp
@@ -1734,8 +1734,90 @@
#endif
}
-void GrGpuGL::onGpuStencilPath(const GrPath&, GrPathFill) {
+void GrGpuGL::onGpuStencilPath(const GrPath& path, GrPathFill fill) {
GrCrash("Not implemented yet. Should not get here.");
+#if 0
+ GrGLuint id = static_cast<const GrGLPath*>(&path)->pathID();
+ GrDrawState* drawState = this->drawState();
+ GrAssert(NULL != drawState->getRenderTarget());
+ if (NULL == drawState->getRenderTarget()->getStencilBuffer()) {
+ return;
+ }
+ GrRenderTarget* rt = drawState->getRenderTarget();
+
+ GrGLint stencilBits = rt->getStencilBuffer()->bits();
+ GrGLuint clipStencilMask = 1 << (stencilBits -1);
+ GrGLuint userStencilMask = clipStencilMask - 1;
+ unsigned ref = 0;
+ unsigned mask = 0;
+ GrStencilFunc func = ConvertStencilFuncAndMask(kAlwaysIfInClip_StencilFunc,
+ fClipMaskManager.isClipInStencil() && drawState->isClipState(),
+ clipStencilMask,
+ userStencilMask,
+ &ref,
+ &mask);
+ const GrMatrix& m = drawState->getViewMatrix();
+ // We use the GL model view matrix to hold the draw state's view matrix
+ // and the GL projection matrix to convert to normalized y-up coords.
+ GrGLfloat mv[] = {
+ // col 0
+ GrScalarToFloat(m[GrMatrix::kMScaleX]),
+ GrScalarToFloat(m[GrMatrix::kMSkewY]),
+ 0,
+ GrScalarToFloat(m[GrMatrix::kMPersp0]),
+
+ // col 1
+ GrScalarToFloat(m[GrMatrix::kMSkewX]),
+ GrScalarToFloat(m[GrMatrix::kMScaleY]),
+ 0,
+ GrScalarToFloat(m[GrMatrix::kMPersp1]),
+
+ // col 2
+ 0, 0, 0, 0,
+
+ // col3
+ GrScalarToFloat(m[GrMatrix::kMTransX]),
+ GrScalarToFloat(m[GrMatrix::kMTransY]),
+ 0.5f,
+ GrScalarToFloat(m[GrMatrix::kMPersp2])
+ };
+ GrGLfloat p[] = {
+ // col 0
+ 2.f / rt->width(), 0, 0, 0,
+
+ // col 1
+ 0, -2.f / rt->height(), 0, 0,
+
+ // col 2
+ 0, 0, 1.f, 0,
+
+ // col 3
+ -1.f, 1.f, 0, 1.f,
+ };
+ GL_CALL(MatrixMode(GR_GL_MODELVIEW));
+ GL_CALL(LoadMatrixf(mv));
+ GL_CALL(MatrixMode(GR_GL_PROJECTION));
+ GL_CALL(LoadMatrixf(p));
+
+ GL_CALL(Enable(GR_GL_STENCIL_TEST));
+ GL_CALL(PathStencilFunc(grToGLStencilFunc[func], ref, mask));
+ fHWStencilSettings.invalidate();
+
+ // Decide how to manipulate the stencil buffer based on the fill rule.
+ GrGLenum fillMode;
+ switch (fill) {
+ case kWinding_PathFill:
+ fillMode = GR_GL_COUNT_UP;
+ break;
+ case kEvenOdd_PathFill:
+ fillMode = GR_GL_INVERT;
+ break;
+ default:
+ // Only the above two fill rules are allowed.
+ GrCrash("Invalid fill rule.");
+ }
+ GL_CALL(StencilFillPath(id, fillMode, mask));
+#endif
}
void GrGpuGL::onResolveRenderTarget(GrRenderTarget* target) {