Rename stencil face terminology to clockwise/counter-clockwise
"Front" and "back" actually refer to opposite triangles in GL vs
Vulkan. Both APIs define counter-clockwise as the default winding
direction for the front face, but since GL uses a bottom-up coordinate
system, they are reversed from one another.
The idea of this CL is to define Ganesh's stencil settings in terms of
clockwise and counter-clockwise in skia device space, just like how we
use "sk_Clockwise" insead of "gl_FrontFacing" in SkSL. We
intentionally avoid the "front"/"back" terminology so there is no
ambiguity. The individual backends are now responsible to translate
cw/ccw into whatever that means for front and back in their own
particular APIs.
This change also swaps the front and back stencil faces in vulkan and
metal, since they were previously backwards from GL. This should have
no actual effect yet, because the only code so far where this matters
is ccpr.
Change-Id: Ife6afbe0a83899edc7eacc3f00a4507d065cccab
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/252977
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Commit-Queue: Chris Dalton <csmartdalton@google.com>
diff --git a/src/gpu/GrStencilSettings.cpp b/src/gpu/GrStencilSettings.cpp
index d03165c..f39648c 100644
--- a/src/gpu/GrStencilSettings.cpp
+++ b/src/gpu/GrStencilSettings.cpp
@@ -20,36 +20,36 @@
0x0000>()
);
-GR_STATIC_ASSERT(kAll_StencilFlags == (gUnused.fFrontFlags[0] & gUnused.fBackFlags[0]));
+GR_STATIC_ASSERT(kAll_StencilFlags == (gUnused.fCWFlags[0] & gUnused.fCCWFlags[0]));
const GrUserStencilSettings& GrUserStencilSettings::kUnused = gUnused;
void GrStencilSettings::reset(const GrUserStencilSettings& user, bool hasStencilClip,
int numStencilBits) {
- uint16_t frontFlags = user.fFrontFlags[hasStencilClip];
- if (frontFlags & kSingleSided_StencilFlag) {
- SkASSERT(frontFlags == user.fBackFlags[hasStencilClip]);
- fFlags = frontFlags;
+ uint16_t cwFlags = user.fCWFlags[hasStencilClip];
+ if (cwFlags & kSingleSided_StencilFlag) {
+ SkASSERT(cwFlags == user.fCCWFlags[hasStencilClip]);
+ fFlags = cwFlags;
if (!this->isDisabled()) {
- fFront.reset(user.fFront, hasStencilClip, numStencilBits);
+ fCWFace.reset(user.fCWFace, hasStencilClip, numStencilBits);
}
return;
}
- uint16_t backFlags = user.fBackFlags[hasStencilClip];
- fFlags = frontFlags & backFlags;
+ uint16_t ccwFlags = user.fCCWFlags[hasStencilClip];
+ fFlags = cwFlags & ccwFlags;
if (this->isDisabled()) {
return;
}
- if (!(frontFlags & kDisabled_StencilFlag)) {
- fFront.reset(user.fFront, hasStencilClip, numStencilBits);
+ if (!(cwFlags & kDisabled_StencilFlag)) {
+ fCWFace.reset(user.fCWFace, hasStencilClip, numStencilBits);
} else {
- fFront.setDisabled();
+ fCWFace.setDisabled();
}
- if (!(backFlags & kDisabled_StencilFlag)) {
- fBack.reset(user.fBack, hasStencilClip, numStencilBits);
+ if (!(ccwFlags & kDisabled_StencilFlag)) {
+ fCCWFace.reset(user.fCCWFace, hasStencilClip, numStencilBits);
} else {
- fBack.setDisabled();
+ fCCWFace.setDisabled();
}
}
@@ -59,11 +59,11 @@
return;
}
if (!this->isTwoSided()) {
- memcpy(&fFront, &that.fFront, sizeof(Face));
+ memcpy(&fCWFace, &that.fCWFace, sizeof(Face));
} else {
- memcpy(&fFront, &that.fFront, 2 * sizeof(Face));
+ memcpy(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
GR_STATIC_ASSERT(sizeof(Face) ==
- offsetof(GrStencilSettings, fBack) - offsetof(GrStencilSettings, fFront));
+ offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
}
}
@@ -77,13 +77,13 @@
return kDisabled_StencilFlag & (fFlags & that.fFlags);
}
if (kSingleSided_StencilFlag & (fFlags & that.fFlags)) {
- return 0 == memcmp(&fFront, &that.fFront, sizeof(Face)); // Both are single sided.
+ return 0 == memcmp(&fCWFace, &that.fCWFace, sizeof(Face)); // Both are single sided.
} else if (kSingleSided_StencilFlag & (fFlags | that.fFlags)) {
return false;
} else {
- return 0 == memcmp(&fFront, &that.fFront, 2 * sizeof(Face));
+ return 0 == memcmp(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
GR_STATIC_ASSERT(sizeof(Face) ==
- offsetof(GrStencilSettings, fBack) - offsetof(GrStencilSettings, fFront));
+ offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
}
// memcmp relies on GrStencilSettings::Face being tightly packed.
GR_STATIC_ASSERT(0 == offsetof(Face, fRef));
@@ -478,16 +478,16 @@
constexpr int kCount16 = sizeof(Face) / sizeof(uint16_t);
GR_STATIC_ASSERT(0 == sizeof(Face) % sizeof(uint16_t));
uint16_t* key = reinterpret_cast<uint16_t*>(b->add32n((kCount16 + 1) / 2));
- memcpy(key, &fFront, sizeof(Face));
+ memcpy(key, &fCWFace, sizeof(Face));
key[kCount16] = 0;
GR_STATIC_ASSERT(1 == kCount16 % 2);
} else {
constexpr int kCount32 = (2 * sizeof(Face)) / sizeof(uint32_t);
GR_STATIC_ASSERT(0 == (2 * sizeof(Face)) % sizeof(uint32_t));
uint32_t* key = b->add32n(kCount32);
- memcpy(key, &fFront, 2 * sizeof(Face));
+ memcpy(key, &fCWFace, 2 * sizeof(Face));
GR_STATIC_ASSERT(sizeof(Face) ==
- offsetof(GrStencilSettings, fBack) - offsetof(GrStencilSettings, fFront));
+ offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
}
// We rely on GrStencilSettings::Face being tightly packed for the key to be reliable.
GR_STATIC_ASSERT(0 == offsetof(Face, fRef));
diff --git a/src/gpu/GrStencilSettings.h b/src/gpu/GrStencilSettings.h
index e694236..fc1e66a 100644
--- a/src/gpu/GrStencilSettings.h
+++ b/src/gpu/GrStencilSettings.h
@@ -78,18 +78,24 @@
void setDisabled();
};
- const Face& frontAndBack() const {
+ const Face& singleSidedFace() const {
SkASSERT(!this->isDisabled());
SkASSERT(!this->isTwoSided());
- return fFront;
+ return fCWFace;
}
- const Face& front(GrSurfaceOrigin origin) const {
+ // Returns the stencil settings for triangles that wind clockwise in "post-origin" space.
+ // (i.e., the space that results after a potential y-axis flip on device space for bottom-left
+ // origins.)
+ const Face& postOriginCWFace(GrSurfaceOrigin origin) const {
SkASSERT(this->isTwoSided());
- return (kTopLeft_GrSurfaceOrigin == origin) ? fFront : fBack;
+ return (kTopLeft_GrSurfaceOrigin == origin) ? fCWFace : fCCWFace;
}
- const Face& back(GrSurfaceOrigin origin) const {
+ // Returns the stencil settings for triangles that wind counter-clockwise in "post-origin"
+ // space. (i.e., the space that results after a potential y-axis flip on device space for
+ // bottom-left origins.)
+ const Face& postOriginCCWFace(GrSurfaceOrigin origin) const {
SkASSERT(this->isTwoSided());
- return (kTopLeft_GrSurfaceOrigin == origin) ? fBack : fFront;
+ return (kTopLeft_GrSurfaceOrigin == origin) ? fCCWFace : fCWFace;
}
/**
@@ -128,8 +134,8 @@
enum { kInvalid_PrivateFlag = (kLast_StencilFlag << 1) };
uint32_t fFlags;
- Face fFront;
- Face fBack;
+ Face fCWFace;
+ Face fCCWFace;
};
#endif
diff --git a/src/gpu/GrUserStencilSettings.h b/src/gpu/GrUserStencilSettings.h
index 83a19b7..95e97bc 100644
--- a/src/gpu/GrUserStencilSettings.h
+++ b/src/gpu/GrUserStencilSettings.h
@@ -118,12 +118,12 @@
template<uint16_t Ref, GrUserStencilTest Test, uint16_t TestMask,
GrUserStencilOp PassOp, GrUserStencilOp FailOp, uint16_t WriteMask> struct Init {};
- template<uint16_t FtRef, uint16_t BkRef,
- GrUserStencilTest FtTest, GrUserStencilTest BkTest,
- uint16_t FtTestMask, uint16_t BkTestMask,
- GrUserStencilOp FtPassOp, GrUserStencilOp BkPassOp,
- GrUserStencilOp FtFailOp, GrUserStencilOp BkFailOp,
- uint16_t FtWriteMask, uint16_t BkWriteMask> struct InitSeparate {};
+ template<uint16_t CWRef, uint16_t CCWRef,
+ GrUserStencilTest CWTest, GrUserStencilTest CCWTest,
+ uint16_t CWTestMask, uint16_t CCWTestMask,
+ GrUserStencilOp CWPassOp, GrUserStencilOp CCWPassOp,
+ GrUserStencilOp CWFailOp, GrUserStencilOp CCWFailOp,
+ uint16_t CWWriteMask, uint16_t CCWWriteMask> struct InitSeparate {};
template<uint16_t Ref, GrUserStencilTest Test, uint16_t TestMask,
GrUserStencilOp PassOp, GrUserStencilOp FailOp, uint16_t WriteMask>
@@ -131,17 +131,17 @@
return Init<Ref, Test, TestMask, PassOp, FailOp, WriteMask>();
}
- template<uint16_t FtRef, uint16_t BkRef,
- GrUserStencilTest FtTest, GrUserStencilTest BkTest,
- uint16_t FtTestMask, uint16_t BkTestMask,
- GrUserStencilOp FtPassOp, GrUserStencilOp BkPassOp,
- GrUserStencilOp FtFailOp, GrUserStencilOp BkFailOp,
- uint16_t FtWriteMask, uint16_t BkWriteMask>
- constexpr static InitSeparate<FtRef, BkRef, FtTest, BkTest, FtTestMask, BkTestMask,
- FtPassOp, BkPassOp, FtFailOp, BkFailOp, FtWriteMask,
- BkWriteMask> StaticInitSeparate() {
- return InitSeparate<FtRef, BkRef, FtTest, BkTest, FtTestMask, BkTestMask,
- FtPassOp, BkPassOp, FtFailOp, BkFailOp, FtWriteMask, BkWriteMask>();
+ template<uint16_t CWRef, uint16_t CCWRef,
+ GrUserStencilTest CWTest, GrUserStencilTest CCWTest,
+ uint16_t CWTestMask, uint16_t CCWTestMask,
+ GrUserStencilOp CWPassOp, GrUserStencilOp CCWPassOp,
+ GrUserStencilOp CWFailOp, GrUserStencilOp CCWFailOp,
+ uint16_t CWWriteMask, uint16_t CCWWriteMask>
+ constexpr static InitSeparate<CWRef, CCWRef, CWTest, CCWTest, CWTestMask, CCWTestMask,
+ CWPassOp, CCWPassOp, CWFailOp, CCWFailOp, CWWriteMask,
+ CCWWriteMask> StaticInitSeparate() {
+ return InitSeparate<CWRef, CCWRef, CWTest, CCWTest, CWTestMask, CCWTestMask,
+ CWPassOp, CCWPassOp, CWFailOp, CCWFailOp, CWWriteMask, CCWWriteMask>();
}
// We construct with template arguments in order to enforce that the struct be compile-time
@@ -151,40 +151,41 @@
typename Attrs = Attrs<Test, PassOp, FailOp> >
constexpr explicit GrUserStencilSettings(
const Init<Ref, Test, TestMask, PassOp, FailOp, WriteMask>&)
- : fFrontFlags{(uint16_t)(Attrs::Flags(false) | kSingleSided_StencilFlag),
+ : fCWFlags{(uint16_t)(Attrs::Flags(false) | kSingleSided_StencilFlag),
(uint16_t)(Attrs::Flags(true) | kSingleSided_StencilFlag)}
- , fFront{Ref, Test, Attrs::EffectiveTestMask(TestMask), PassOp, FailOp,
+ , fCWFace{Ref, Test, Attrs::EffectiveTestMask(TestMask), PassOp, FailOp,
Attrs::EffectiveWriteMask(WriteMask)}
- , fBackFlags{(uint16_t)(Attrs::Flags(false) | kSingleSided_StencilFlag),
+ , fCCWFlags{(uint16_t)(Attrs::Flags(false) | kSingleSided_StencilFlag),
(uint16_t)(Attrs::Flags(true) | kSingleSided_StencilFlag)}
- , fBack{Ref, Test, Attrs::EffectiveTestMask(TestMask), PassOp, FailOp,
+ , fCCWFace{Ref, Test, Attrs::EffectiveTestMask(TestMask), PassOp, FailOp,
Attrs::EffectiveWriteMask(WriteMask)} {
}
- template<uint16_t FtRef, uint16_t BkRef,
- GrUserStencilTest FtTest, GrUserStencilTest BkTest,
- uint16_t FtTestMask, uint16_t BkTestMask,
- GrUserStencilOp FtPassOp, GrUserStencilOp BkPassOp,
- GrUserStencilOp FtFailOp, GrUserStencilOp BkFailOp,
- uint16_t FtWriteMask, uint16_t BkWriteMask,
- typename FtAttrs = Attrs<FtTest, FtPassOp, FtFailOp>,
- typename BkAttrs = Attrs<BkTest, BkPassOp, BkFailOp> >
+ template<uint16_t CWRef, uint16_t CCWRef,
+ GrUserStencilTest CWTest, GrUserStencilTest CCWTest,
+ uint16_t CWTestMask, uint16_t CCWTestMask,
+ GrUserStencilOp CWPassOp, GrUserStencilOp CCWPassOp,
+ GrUserStencilOp CWFailOp, GrUserStencilOp CCWFailOp,
+ uint16_t CWWriteMask, uint16_t CCWWriteMask,
+ typename CWAttrs = Attrs<CWTest, CWPassOp, CWFailOp>,
+ typename CCWAttrs = Attrs<CCWTest, CCWPassOp, CCWFailOp> >
constexpr explicit GrUserStencilSettings(
- const InitSeparate<FtRef, BkRef, FtTest, BkTest, FtTestMask, BkTestMask,
- FtPassOp, BkPassOp, FtFailOp, BkFailOp, FtWriteMask, BkWriteMask>&)
- : fFrontFlags{FtAttrs::Flags(false), FtAttrs::Flags(true)}
- , fFront{FtRef, FtTest, FtAttrs::EffectiveTestMask(FtTestMask), FtPassOp, FtFailOp,
- FtAttrs::EffectiveWriteMask(FtWriteMask)}
- , fBackFlags{BkAttrs::Flags(false), BkAttrs::Flags(true)}
- , fBack{BkRef, BkTest, BkAttrs::EffectiveTestMask(BkTestMask), BkPassOp, BkFailOp,
- BkAttrs::EffectiveWriteMask(BkWriteMask)} {}
+ const InitSeparate<CWRef, CCWRef, CWTest, CCWTest, CWTestMask, CCWTestMask,
+ CWPassOp, CCWPassOp, CWFailOp, CCWFailOp, CWWriteMask,
+ CCWWriteMask>&)
+ : fCWFlags{CWAttrs::Flags(false), CWAttrs::Flags(true)}
+ , fCWFace{CWRef, CWTest, CWAttrs::EffectiveTestMask(CWTestMask), CWPassOp, CWFailOp,
+ CWAttrs::EffectiveWriteMask(CWWriteMask)}
+ , fCCWFlags{CCWAttrs::Flags(false), CCWAttrs::Flags(true)}
+ , fCCWFace{CCWRef, CCWTest, CCWAttrs::EffectiveTestMask(CCWTestMask), CCWPassOp, CCWFailOp,
+ CCWAttrs::EffectiveWriteMask(CCWWriteMask)} {}
// This struct can only be constructed with static initializers.
GrUserStencilSettings() = delete;
GrUserStencilSettings(const GrUserStencilSettings&) = delete;
uint16_t flags(bool hasStencilClip) const {
- return fFrontFlags[hasStencilClip] & fBackFlags[hasStencilClip];
+ return fCWFlags[hasStencilClip] & fCCWFlags[hasStencilClip];
}
bool isDisabled(bool hasStencilClip) const {
return this->flags(hasStencilClip) & kDisabled_StencilFlag;
@@ -199,10 +200,10 @@
return !(this->flags(hasStencilClip) & kNoWrapOps_StencilFlag);
}
- const uint16_t fFrontFlags[2]; // frontFlagsForDraw = fFrontFlags[hasStencilClip].
- const Face fFront;
- const uint16_t fBackFlags[2]; // backFlagsForDraw = fBackFlags[hasStencilClip].
- const Face fBack;
+ const uint16_t fCWFlags[2]; // cwFlagsForDraw = fCWFlags[hasStencilClip].
+ const Face fCWFace;
+ const uint16_t fCCWFlags[2]; // ccwFlagsForDraw = fCCWFlags[hasStencilClip].
+ const Face fCCWFace;
static const GrUserStencilSettings& kUnused;
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 453bfbe..4221703 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -2450,12 +2450,14 @@
fHWStencilTestEnabled = kYes_TriState;
}
- if (stencilSettings.isTwoSided()) {
- set_gl_stencil(this->glInterface(), stencilSettings.front(origin), GR_GL_FRONT);
- set_gl_stencil(this->glInterface(), stencilSettings.back(origin), GR_GL_BACK);
+ if (!stencilSettings.isTwoSided()) {
+ set_gl_stencil(this->glInterface(), stencilSettings.singleSidedFace(),
+ GR_GL_FRONT_AND_BACK);
} else {
- set_gl_stencil(
- this->glInterface(), stencilSettings.frontAndBack(), GR_GL_FRONT_AND_BACK);
+ set_gl_stencil(this->glInterface(), stencilSettings.postOriginCWFace(origin),
+ GR_GL_FRONT);
+ set_gl_stencil(this->glInterface(), stencilSettings.postOriginCCWFace(origin),
+ GR_GL_BACK);
}
fHWStencilSettings = stencilSettings;
fHWStencilOrigin = origin;
diff --git a/src/gpu/gl/GrGLPathRendering.cpp b/src/gpu/gl/GrGLPathRendering.cpp
index 884bb9f..9cce898 100644
--- a/src/gpu/gl/GrGLPathRendering.cpp
+++ b/src/gpu/gl/GrGLPathRendering.cpp
@@ -99,9 +99,9 @@
this->flushPathStencilSettings(*args.fStencil);
- GrGLenum fillMode =
- gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.frontAndBack().fPassOp);
- GrGLint writeMask = fHWPathStencilSettings.frontAndBack().fWriteMask;
+ GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
+ fHWPathStencilSettings.singleSidedFace().fPassOp);
+ GrGLint writeMask = fHWPathStencilSettings.singleSidedFace().fWriteMask;
if (glPath->shouldFill()) {
GL_CALL(StencilFillPath(glPath->pathID(), fillMode, writeMask));
@@ -123,9 +123,9 @@
this->flushPathStencilSettings(stencilPassSettings);
- GrGLenum fillMode =
- gr_stencil_op_to_gl_path_rendering_fill_mode(fHWPathStencilSettings.frontAndBack().fPassOp);
- GrGLint writeMask = fHWPathStencilSettings.frontAndBack().fWriteMask;
+ GrGLenum fillMode = gr_stencil_op_to_gl_path_rendering_fill_mode(
+ fHWPathStencilSettings.singleSidedFace().fPassOp);
+ GrGLint writeMask = fHWPathStencilSettings.singleSidedFace().fWriteMask;
if (glPath->shouldStroke()) {
if (glPath->shouldFill()) {
@@ -247,14 +247,14 @@
SkASSERT(stencilSettings.isValid());
// Just the func, ref, and mask is set here. The op and write mask are params to the call
// that draws the path to the SB (glStencilFillPath)
- uint16_t ref = stencilSettings.frontAndBack().fRef;
- GrStencilTest test = stencilSettings.frontAndBack().fTest;
- uint16_t testMask = stencilSettings.frontAndBack().fTestMask;
+ uint16_t ref = stencilSettings.singleSidedFace().fRef;
+ GrStencilTest test = stencilSettings.singleSidedFace().fTest;
+ uint16_t testMask = stencilSettings.singleSidedFace().fTestMask;
if (!fHWPathStencilSettings.isValid() ||
- ref != fHWPathStencilSettings.frontAndBack().fRef ||
- test != fHWPathStencilSettings.frontAndBack().fTest ||
- testMask != fHWPathStencilSettings.frontAndBack().fTestMask) {
+ ref != fHWPathStencilSettings.singleSidedFace().fRef ||
+ test != fHWPathStencilSettings.singleSidedFace().fTest ||
+ testMask != fHWPathStencilSettings.singleSidedFace().fTestMask) {
GL_CALL(PathStencilFunc(GrToGLStencilFunc(test), ref, testMask));
}
fHWPathStencilSettings = stencilSettings;
diff --git a/src/gpu/mtl/GrMtlDepthStencil.mm b/src/gpu/mtl/GrMtlDepthStencil.mm
index 7434772..8cb584d 100644
--- a/src/gpu/mtl/GrMtlDepthStencil.mm
+++ b/src/gpu/mtl/GrMtlDepthStencil.mm
@@ -75,11 +75,11 @@
MTLDepthStencilDescriptor* desc = [[MTLDepthStencilDescriptor alloc] init];
if (!stencil.isDisabled()) {
if (stencil.isTwoSided()) {
- desc.frontFaceStencil = skia_stencil_to_mtl(stencil.front(origin));
- desc.backFaceStencil = skia_stencil_to_mtl(stencil.back(origin));
+ desc.frontFaceStencil = skia_stencil_to_mtl(stencil.postOriginCCWFace(origin));
+ desc.backFaceStencil = skia_stencil_to_mtl(stencil.postOriginCWFace(origin));
}
else {
- desc.frontFaceStencil = skia_stencil_to_mtl(stencil.frontAndBack());
+ desc.frontFaceStencil = skia_stencil_to_mtl(stencil.singleSidedFace());
desc.backFaceStencil = desc.frontFaceStencil;
}
}
@@ -113,11 +113,11 @@
memset(&depthStencilKey, 0, sizeof(Key));
} else {
if (stencil.isTwoSided()) {
- skia_stencil_to_key(stencil.front(origin), &depthStencilKey.fFront);
- skia_stencil_to_key(stencil.back(origin), &depthStencilKey.fBack);
+ skia_stencil_to_key(stencil.postOriginCCWFace(origin), &depthStencilKey.fFront);
+ skia_stencil_to_key(stencil.postOriginCWFace(origin), &depthStencilKey.fBack);
}
else {
- skia_stencil_to_key(stencil.frontAndBack(), &depthStencilKey.fFront);
+ skia_stencil_to_key(stencil.singleSidedFace(), &depthStencilKey.fFront);
memcpy(&depthStencilKey.fBack, &depthStencilKey.fFront, sizeof(Key::Face));
}
}
diff --git a/src/gpu/mtl/GrMtlPipelineState.mm b/src/gpu/mtl/GrMtlPipelineState.mm
index 2b7463a..0533610 100644
--- a/src/gpu/mtl/GrMtlPipelineState.mm
+++ b/src/gpu/mtl/GrMtlPipelineState.mm
@@ -197,15 +197,16 @@
if (!fStencil.isDisabled()) {
if (fStencil.isTwoSided()) {
if (@available(macOS 10.11, iOS 9.0, *)) {
- [renderCmdEncoder setStencilFrontReferenceValue:fStencil.front(origin).fRef
- backReferenceValue:fStencil.back(origin).fRef];
+ [renderCmdEncoder
+ setStencilFrontReferenceValue:fStencil.postOriginCCWFace(origin).fRef
+ backReferenceValue:fStencil.postOriginCWFace(origin).fRef];
} else {
// Two-sided stencil not supported on older versions of iOS
// TODO: Find a way to recover from this
SkASSERT(false);
}
} else {
- [renderCmdEncoder setStencilReferenceValue:fStencil.frontAndBack().fRef];
+ [renderCmdEncoder setStencilReferenceValue:fStencil.singleSidedFace().fRef];
}
}
[renderCmdEncoder setDepthStencilState:state->mtlDepthStencil()];
diff --git a/src/gpu/vk/GrVkPipeline.cpp b/src/gpu/vk/GrVkPipeline.cpp
index 6868ff5..031f856 100644
--- a/src/gpu/vk/GrVkPipeline.cpp
+++ b/src/gpu/vk/GrVkPipeline.cpp
@@ -252,11 +252,11 @@
stencilInfo->stencilTestEnable = !stencilSettings.isDisabled();
if (!stencilSettings.isDisabled()) {
if (!stencilSettings.isTwoSided()) {
- setup_stencil_op_state(&stencilInfo->front, stencilSettings.frontAndBack());
+ setup_stencil_op_state(&stencilInfo->front, stencilSettings.singleSidedFace());
stencilInfo->back = stencilInfo->front;
} else {
- setup_stencil_op_state(&stencilInfo->front, stencilSettings.front(origin));
- setup_stencil_op_state(&stencilInfo->back, stencilSettings.back(origin));
+ setup_stencil_op_state(&stencilInfo->front, stencilSettings.postOriginCCWFace(origin));
+ setup_stencil_op_state(&stencilInfo->back, stencilSettings.postOriginCWFace(origin));
}
}
stencilInfo->minDepthBounds = 0.0f;
