Removed SwiftShader's custom Depth/Stencil comparison enums
- Replaced DepthCompareMode, StencilCompareMode and AlphaCompareMode
by VkCompareOp.
- Replaced StencilOperation by VkStencilOp.
Bug b/118386749
Change-Id: I7dec0cff119012345865eb164599f086edf2c88a
Reviewed-on: https://swiftshader-review.googlesource.com/c/22768
Tested-by: Alexis Hétu <sugoi@google.com>
Reviewed-by: Nicolas Capens <nicolascapens@google.com>
diff --git a/src/Device/Context.cpp b/src/Device/Context.cpp
index d955c79..590e58e 100644
--- a/src/Device/Context.cpp
+++ b/src/Device/Context.cpp
@@ -175,29 +175,29 @@
stencilBuffer = nullptr;
stencilEnable = false;
- stencilCompareMode = STENCIL_ALWAYS;
+ stencilCompareMode = VK_COMPARE_OP_ALWAYS;
stencilReference = 0;
stencilMask = 0xFFFFFFFF;
- stencilFailOperation = OPERATION_KEEP;
- stencilPassOperation = OPERATION_KEEP;
- stencilZFailOperation = OPERATION_KEEP;
+ stencilFailOperation = VK_STENCIL_OP_KEEP;
+ stencilPassOperation = VK_STENCIL_OP_KEEP;
+ stencilZFailOperation = VK_STENCIL_OP_KEEP;
stencilWriteMask = 0xFFFFFFFF;
twoSidedStencil = false;
- stencilCompareModeCCW = STENCIL_ALWAYS;
+ stencilCompareModeCCW = VK_COMPARE_OP_ALWAYS;
stencilReferenceCCW = 0;
stencilMaskCCW = 0xFFFFFFFF;
- stencilFailOperationCCW = OPERATION_KEEP;
- stencilPassOperationCCW = OPERATION_KEEP;
- stencilZFailOperationCCW = OPERATION_KEEP;
+ stencilFailOperationCCW = VK_STENCIL_OP_KEEP;
+ stencilPassOperationCCW = VK_STENCIL_OP_KEEP;
+ stencilZFailOperationCCW = VK_STENCIL_OP_KEEP;
stencilWriteMaskCCW = 0xFFFFFFFF;
- alphaCompareMode = ALPHA_ALWAYS;
+ alphaCompareMode = VK_COMPARE_OP_ALWAYS;
alphaTestEnable = false;
rasterizerDiscard = false;
- depthCompareMode = DEPTH_LESS;
+ depthCompareMode = VK_COMPARE_OP_LESS;
depthBufferEnable = true;
depthWriteEnable = true;
@@ -343,8 +343,8 @@
{
if(transparencyAntialiasing != TRANSPARENCY_NONE) return true;
if(!alphaTestEnable) return false;
- if(alphaCompareMode == ALPHA_ALWAYS) return false;
- if(alphaReference == 0.0f && alphaCompareMode == ALPHA_GREATEREQUAL) return false;
+ if(alphaCompareMode == VK_COMPARE_OP_ALWAYS) return false;
+ if(alphaReference == 0.0f && alphaCompareMode == VK_COMPARE_OP_GREATER_OR_EQUAL) return false;
return true;
}
diff --git a/src/Device/Context.hpp b/src/Device/Context.hpp
index 4d826b4..8db5ced 100644
--- a/src/Device/Context.hpp
+++ b/src/Device/Context.hpp
@@ -84,62 +84,6 @@
DRAW_LAST = DRAW_INDEXEDTRIANGLEFAN32
};
- enum DepthCompareMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
- {
- DEPTH_ALWAYS,
- DEPTH_NEVER,
- DEPTH_EQUAL,
- DEPTH_NOTEQUAL,
- DEPTH_LESS,
- DEPTH_LESSEQUAL,
- DEPTH_GREATER,
- DEPTH_GREATEREQUAL,
-
- DEPTH_LAST = DEPTH_GREATEREQUAL
- };
-
- enum StencilCompareMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
- {
- STENCIL_ALWAYS,
- STENCIL_NEVER,
- STENCIL_EQUAL,
- STENCIL_NOTEQUAL,
- STENCIL_LESS,
- STENCIL_LESSEQUAL,
- STENCIL_GREATER,
- STENCIL_GREATEREQUAL,
-
- STENCIL_LAST = STENCIL_GREATEREQUAL
- };
-
- enum StencilOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
- {
- OPERATION_KEEP,
- OPERATION_ZERO,
- OPERATION_REPLACE,
- OPERATION_INCRSAT,
- OPERATION_DECRSAT,
- OPERATION_INVERT,
- OPERATION_INCR,
- OPERATION_DECR,
-
- OPERATION_LAST = OPERATION_DECR
- };
-
- enum AlphaCompareMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
- {
- ALPHA_ALWAYS,
- ALPHA_NEVER,
- ALPHA_EQUAL,
- ALPHA_NOTEQUAL,
- ALPHA_LESS,
- ALPHA_LESSEQUAL,
- ALPHA_GREATER,
- ALPHA_GREATEREQUAL,
-
- ALPHA_LAST = ALPHA_GREATEREQUAL
- };
-
enum CullMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
{
CULL_NONE,
@@ -275,25 +219,25 @@
DrawType drawType;
bool stencilEnable;
- StencilCompareMode stencilCompareMode;
+ VkCompareOp stencilCompareMode;
int stencilReference;
int stencilMask;
- StencilOperation stencilFailOperation;
- StencilOperation stencilPassOperation;
- StencilOperation stencilZFailOperation;
+ VkStencilOp stencilFailOperation;
+ VkStencilOp stencilPassOperation;
+ VkStencilOp stencilZFailOperation;
int stencilWriteMask;
bool twoSidedStencil;
- StencilCompareMode stencilCompareModeCCW;
+ VkCompareOp stencilCompareModeCCW;
int stencilReferenceCCW;
int stencilMaskCCW;
- StencilOperation stencilFailOperationCCW;
- StencilOperation stencilPassOperationCCW;
- StencilOperation stencilZFailOperationCCW;
+ VkStencilOp stencilFailOperationCCW;
+ VkStencilOp stencilPassOperationCCW;
+ VkStencilOp stencilZFailOperationCCW;
int stencilWriteMaskCCW;
// Pixel processor states
- AlphaCompareMode alphaCompareMode;
+ VkCompareOp alphaCompareMode;
bool alphaTestEnable;
CullMode cullMode;
@@ -335,7 +279,7 @@
// Pixel processor states
bool rasterizerDiscard;
bool depthBufferEnable;
- DepthCompareMode depthCompareMode;
+ VkCompareOp depthCompareMode;
bool depthWriteEnable;
bool alphaBlendEnable;
diff --git a/src/Device/PixelProcessor.cpp b/src/Device/PixelProcessor.cpp
index 79d3d63..be72211 100644
--- a/src/Device/PixelProcessor.cpp
+++ b/src/Device/PixelProcessor.cpp
@@ -343,12 +343,12 @@
context->setDepthBufferEnable(depthBufferEnable);
}
- void PixelProcessor::setDepthCompare(DepthCompareMode depthCompareMode)
+ void PixelProcessor::setDepthCompare(VkCompareOp depthCompareMode)
{
context->depthCompareMode = depthCompareMode;
}
- void PixelProcessor::setAlphaCompare(AlphaCompareMode alphaCompareMode)
+ void PixelProcessor::setAlphaCompare(VkCompareOp alphaCompareMode)
{
context->alphaCompareMode = alphaCompareMode;
}
@@ -379,7 +379,7 @@
context->stencilEnable = stencilEnable;
}
- void PixelProcessor::setStencilCompare(StencilCompareMode stencilCompareMode)
+ void PixelProcessor::setStencilCompare(VkCompareOp stencilCompareMode)
{
context->stencilCompareMode = stencilCompareMode;
}
@@ -408,17 +408,17 @@
stencilCCW.set(context->stencilReferenceCCW, stencilMaskCCW, context->stencilWriteMaskCCW);
}
- void PixelProcessor::setStencilFailOperation(StencilOperation stencilFailOperation)
+ void PixelProcessor::setStencilFailOperation(VkStencilOp stencilFailOperation)
{
context->stencilFailOperation = stencilFailOperation;
}
- void PixelProcessor::setStencilPassOperation(StencilOperation stencilPassOperation)
+ void PixelProcessor::setStencilPassOperation(VkStencilOp stencilPassOperation)
{
context->stencilPassOperation = stencilPassOperation;
}
- void PixelProcessor::setStencilZFailOperation(StencilOperation stencilZFailOperation)
+ void PixelProcessor::setStencilZFailOperation(VkStencilOp stencilZFailOperation)
{
context->stencilZFailOperation = stencilZFailOperation;
}
@@ -440,22 +440,22 @@
context->twoSidedStencil = enable;
}
- void PixelProcessor::setStencilCompareCCW(StencilCompareMode stencilCompareMode)
+ void PixelProcessor::setStencilCompareCCW(VkCompareOp stencilCompareMode)
{
context->stencilCompareModeCCW = stencilCompareMode;
}
- void PixelProcessor::setStencilFailOperationCCW(StencilOperation stencilFailOperation)
+ void PixelProcessor::setStencilFailOperationCCW(VkStencilOp stencilFailOperation)
{
context->stencilFailOperationCCW = stencilFailOperation;
}
- void PixelProcessor::setStencilPassOperationCCW(StencilOperation stencilPassOperation)
+ void PixelProcessor::setStencilPassOperationCCW(VkStencilOp stencilPassOperation)
{
context->stencilPassOperationCCW = stencilPassOperation;
}
- void PixelProcessor::setStencilZFailOperationCCW(StencilOperation stencilZFailOperation)
+ void PixelProcessor::setStencilZFailOperationCCW(VkStencilOp stencilZFailOperation)
{
context->stencilZFailOperationCCW = stencilZFailOperation;
}
diff --git a/src/Device/PixelProcessor.hpp b/src/Device/PixelProcessor.hpp
index 6a2c4db..f429ecb 100644
--- a/src/Device/PixelProcessor.hpp
+++ b/src/Device/PixelProcessor.hpp
@@ -37,24 +37,24 @@
bool depthOverride : 1; // TODO: Eliminate by querying shader.
bool shaderContainsKill : 1; // TODO: Eliminate by querying shader.
- DepthCompareMode depthCompareMode : BITS(DEPTH_LAST);
- AlphaCompareMode alphaCompareMode : BITS(ALPHA_LAST);
+ VkCompareOp depthCompareMode : BITS(VK_COMPARE_OP_END_RANGE);
+ VkCompareOp alphaCompareMode : BITS(VK_COMPARE_OP_END_RANGE);
bool depthWriteEnable : 1;
bool quadLayoutDepthBuffer : 1;
bool stencilActive : 1;
- StencilCompareMode stencilCompareMode : BITS(STENCIL_LAST);
- StencilOperation stencilFailOperation : BITS(OPERATION_LAST);
- StencilOperation stencilPassOperation : BITS(OPERATION_LAST);
- StencilOperation stencilZFailOperation : BITS(OPERATION_LAST);
+ VkCompareOp stencilCompareMode : BITS(VK_COMPARE_OP_END_RANGE);
+ VkStencilOp stencilFailOperation : BITS(VK_STENCIL_OP_END_RANGE);
+ VkStencilOp stencilPassOperation : BITS(VK_STENCIL_OP_END_RANGE);
+ VkStencilOp stencilZFailOperation : BITS(VK_STENCIL_OP_END_RANGE);
bool noStencilMask : 1;
bool noStencilWriteMask : 1;
bool stencilWriteMasked : 1;
bool twoSidedStencil : 1;
- StencilCompareMode stencilCompareModeCCW : BITS(STENCIL_LAST);
- StencilOperation stencilFailOperationCCW : BITS(OPERATION_LAST);
- StencilOperation stencilPassOperationCCW : BITS(OPERATION_LAST);
- StencilOperation stencilZFailOperationCCW : BITS(OPERATION_LAST);
+ VkCompareOp stencilCompareModeCCW : BITS(VK_COMPARE_OP_END_RANGE);
+ VkStencilOp stencilFailOperationCCW : BITS(VK_STENCIL_OP_END_RANGE);
+ VkStencilOp stencilPassOperationCCW : BITS(VK_STENCIL_OP_END_RANGE);
+ VkStencilOp stencilZFailOperationCCW : BITS(VK_STENCIL_OP_END_RANGE);
bool noStencilMaskCCW : 1;
bool noStencilWriteMaskCCW : 1;
bool stencilWriteMaskedCCW : 1;
@@ -119,7 +119,7 @@
bool alphaTestActive() const
{
- return (alphaCompareMode != ALPHA_ALWAYS) || (transparencyAntialiasing != TRANSPARENCY_NONE);
+ return (alphaCompareMode != VK_COMPARE_OP_ALWAYS) || (transparencyAntialiasing != TRANSPARENCY_NONE);
}
unsigned int hash;
@@ -209,8 +209,8 @@
void setWriteSRGB(bool sRGB);
void setDepthBufferEnable(bool depthBufferEnable);
- void setDepthCompare(DepthCompareMode depthCompareMode);
- void setAlphaCompare(AlphaCompareMode alphaCompareMode);
+ void setDepthCompare(VkCompareOp depthCompareMode);
+ void setAlphaCompare(VkCompareOp alphaCompareMode);
void setDepthWriteEnable(bool depthWriteEnable);
void setAlphaTestEnable(bool alphaTestEnable);
void setCullMode(CullMode cullMode, bool frontFacingCCW);
@@ -220,20 +220,20 @@
void setLogicalOperation(LogicalOperation logicalOperation);
void setStencilEnable(bool stencilEnable);
- void setStencilCompare(StencilCompareMode stencilCompareMode);
+ void setStencilCompare(VkCompareOp stencilCompareMode);
void setStencilReference(int stencilReference);
void setStencilMask(int stencilMask);
- void setStencilFailOperation(StencilOperation stencilFailOperation);
- void setStencilPassOperation(StencilOperation stencilPassOperation);
- void setStencilZFailOperation(StencilOperation stencilZFailOperation);
+ void setStencilFailOperation(VkStencilOp stencilFailOperation);
+ void setStencilPassOperation(VkStencilOp stencilPassOperation);
+ void setStencilZFailOperation(VkStencilOp stencilZFailOperation);
void setStencilWriteMask(int stencilWriteMask);
void setTwoSidedStencil(bool enable);
- void setStencilCompareCCW(StencilCompareMode stencilCompareMode);
+ void setStencilCompareCCW(VkCompareOp stencilCompareMode);
void setStencilReferenceCCW(int stencilReference);
void setStencilMaskCCW(int stencilMask);
- void setStencilFailOperationCCW(StencilOperation stencilFailOperation);
- void setStencilPassOperationCCW(StencilOperation stencilPassOperation);
- void setStencilZFailOperationCCW(StencilOperation stencilZFailOperation);
+ void setStencilFailOperationCCW(VkStencilOp stencilFailOperation);
+ void setStencilPassOperationCCW(VkStencilOp stencilPassOperation);
+ void setStencilZFailOperationCCW(VkStencilOp stencilZFailOperation);
void setStencilWriteMaskCCW(int stencilWriteMask);
void setBlendConstant(const Color<float> &blendConstant);
diff --git a/src/Device/QuadRasterizer.cpp b/src/Device/QuadRasterizer.cpp
index 0ab41c8..6251018 100644
--- a/src/Device/QuadRasterizer.cpp
+++ b/src/Device/QuadRasterizer.cpp
@@ -161,7 +161,7 @@
if(veryEarlyDepthTest && state.multiSample == 1 && !state.depthOverride)
{
- if(!state.stencilActive && state.depthTestActive && (state.depthCompareMode == DEPTH_LESSEQUAL || state.depthCompareMode == DEPTH_LESS)) // FIXME: Both modes ok?
+ if(!state.stencilActive && state.depthTestActive && (state.depthCompareMode == VK_COMPARE_OP_LESS_OR_EQUAL || state.depthCompareMode == VK_COMPARE_OP_LESS)) // FIXME: Both modes ok?
{
Float4 xxxx = Float4(Float(x0)) + *Pointer<Float4>(primitive + OFFSET(Primitive,xQuad), 16);
diff --git a/src/Pipeline/PixelRoutine.cpp b/src/Pipeline/PixelRoutine.cpp
index 4a989a8..e3db352 100644
--- a/src/Pipeline/PixelRoutine.cpp
+++ b/src/Pipeline/PixelRoutine.cpp
@@ -339,43 +339,43 @@
sMask = SignMask(value) & cMask;
}
- void PixelRoutine::stencilTest(Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW)
+ void PixelRoutine::stencilTest(Byte8 &value, VkCompareOp stencilCompareMode, bool CCW)
{
Byte8 equal;
switch(stencilCompareMode)
{
- case STENCIL_ALWAYS:
+ case VK_COMPARE_OP_ALWAYS:
value = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
break;
- case STENCIL_NEVER:
+ case VK_COMPARE_OP_NEVER:
value = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
break;
- case STENCIL_LESS: // a < b ~ b > a
+ case VK_COMPARE_OP_LESS: // a < b ~ b > a
value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
break;
- case STENCIL_EQUAL:
+ case VK_COMPARE_OP_EQUAL:
value = CmpEQ(value, *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
break;
- case STENCIL_NOTEQUAL: // a != b ~ !(a == b)
+ case VK_COMPARE_OP_NOT_EQUAL: // a != b ~ !(a == b)
value = CmpEQ(value, *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
value ^= Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
break;
- case STENCIL_LESSEQUAL: // a <= b ~ (b > a) || (a == b)
+ case VK_COMPARE_OP_LESS_OR_EQUAL: // a <= b ~ (b > a) || (a == b)
equal = value;
equal = CmpEQ(equal, *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
value |= equal;
break;
- case STENCIL_GREATER: // a > b
+ case VK_COMPARE_OP_GREATER: // a > b
equal = *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ));
value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
equal = CmpGT(As<SByte8>(equal), As<SByte8>(value));
value = equal;
break;
- case STENCIL_GREATEREQUAL: // a >= b ~ !(a < b) ~ !(b > a)
+ case VK_COMPARE_OP_GREATER_OR_EQUAL: // a >= b ~ !(a < b) ~ !(b > a)
value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
value ^= Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
@@ -426,7 +426,7 @@
Float4 zValue;
- if(state.depthCompareMode != DEPTH_NEVER || (state.depthCompareMode != DEPTH_ALWAYS && !state.depthWriteEnable))
+ if(state.depthCompareMode != VK_COMPARE_OP_NEVER || (state.depthCompareMode != VK_COMPARE_OP_ALWAYS && !state.depthWriteEnable))
{
if(!state.quadLayoutDepthBuffer)
{
@@ -444,19 +444,19 @@
switch(state.depthCompareMode)
{
- case DEPTH_ALWAYS:
+ case VK_COMPARE_OP_ALWAYS:
// Optimized
break;
- case DEPTH_NEVER:
+ case VK_COMPARE_OP_NEVER:
// Optimized
break;
- case DEPTH_EQUAL:
+ case VK_COMPARE_OP_EQUAL:
zTest = CmpEQ(zValue, Z);
break;
- case DEPTH_NOTEQUAL:
+ case VK_COMPARE_OP_NOT_EQUAL:
zTest = CmpNEQ(zValue, Z);
break;
- case DEPTH_LESS:
+ case VK_COMPARE_OP_LESS:
if(complementaryDepthBuffer)
{
zTest = CmpLT(zValue, Z);
@@ -466,7 +466,7 @@
zTest = CmpNLE(zValue, Z);
}
break;
- case DEPTH_GREATEREQUAL:
+ case VK_COMPARE_OP_GREATER_OR_EQUAL:
if(complementaryDepthBuffer)
{
zTest = CmpNLT(zValue, Z);
@@ -476,7 +476,7 @@
zTest = CmpLE(zValue, Z);
}
break;
- case DEPTH_LESSEQUAL:
+ case VK_COMPARE_OP_LESS_OR_EQUAL:
if(complementaryDepthBuffer)
{
zTest = CmpLE(zValue, Z);
@@ -486,7 +486,7 @@
zTest = CmpNLT(zValue, Z);
}
break;
- case DEPTH_GREATER:
+ case VK_COMPARE_OP_GREATER:
if(complementaryDepthBuffer)
{
zTest = CmpNLE(zValue, Z);
@@ -502,10 +502,10 @@
switch(state.depthCompareMode)
{
- case DEPTH_ALWAYS:
+ case VK_COMPARE_OP_ALWAYS:
zMask = cMask;
break;
- case DEPTH_NEVER:
+ case VK_COMPARE_OP_NEVER:
zMask = 0x0;
break;
default:
@@ -528,35 +528,35 @@
switch(state.alphaCompareMode)
{
- case ALPHA_ALWAYS:
+ case VK_COMPARE_OP_ALWAYS:
aMask = 0xF;
break;
- case ALPHA_NEVER:
+ case VK_COMPARE_OP_NEVER:
aMask = 0x0;
break;
- case ALPHA_EQUAL:
+ case VK_COMPARE_OP_EQUAL:
cmp = CmpEQ(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
break;
- case ALPHA_NOTEQUAL: // a != b ~ !(a == b)
+ case VK_COMPARE_OP_NOT_EQUAL: // a != b ~ !(a == b)
cmp = CmpEQ(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4(0xFFFFu); // FIXME
aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
break;
- case ALPHA_LESS: // a < b ~ b > a
+ case VK_COMPARE_OP_LESS: // a < b ~ b > a
cmp = CmpGT(*Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)), alpha);
aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
break;
- case ALPHA_GREATEREQUAL: // a >= b ~ (a > b) || (a == b) ~ !(b > a) // TODO: Approximate
+ case VK_COMPARE_OP_GREATER_OR_EQUAL: // a >= b ~ (a > b) || (a == b) ~ !(b > a) // TODO: Approximate
equal = CmpEQ(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
cmp = CmpGT(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
cmp |= equal;
aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
break;
- case ALPHA_LESSEQUAL: // a <= b ~ !(a > b)
+ case VK_COMPARE_OP_LESS_OR_EQUAL: // a <= b ~ !(a > b)
cmp = CmpGT(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4(0xFFFFu); // FIXME
aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
break;
- case ALPHA_GREATER: // a > b
+ case VK_COMPARE_OP_GREATER: // a > b
cmp = CmpGT(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
break;
@@ -624,7 +624,7 @@
Float4 zValue;
- if(state.depthCompareMode != DEPTH_NEVER || (state.depthCompareMode != DEPTH_ALWAYS && !state.depthWriteEnable))
+ if(state.depthCompareMode != VK_COMPARE_OP_NEVER || (state.depthCompareMode != VK_COMPARE_OP_ALWAYS && !state.depthWriteEnable))
{
if(!state.quadLayoutDepthBuffer)
{
@@ -661,9 +661,9 @@
return;
}
- if(state.stencilPassOperation == OPERATION_KEEP && state.stencilZFailOperation == OPERATION_KEEP && state.stencilFailOperation == OPERATION_KEEP)
+ if(state.stencilPassOperation == VK_STENCIL_OP_KEEP && state.stencilZFailOperation == VK_STENCIL_OP_KEEP && state.stencilFailOperation == VK_STENCIL_OP_KEEP)
{
- if(!state.twoSidedStencil || (state.stencilPassOperationCCW == OPERATION_KEEP && state.stencilZFailOperationCCW == OPERATION_KEEP && state.stencilFailOperationCCW == OPERATION_KEEP))
+ if(!state.twoSidedStencil || (state.stencilPassOperationCCW == VK_STENCIL_OP_KEEP && state.stencilZFailOperationCCW == VK_STENCIL_OP_KEEP && state.stencilFailOperationCCW == VK_STENCIL_OP_KEEP))
{
return;
}
@@ -720,7 +720,7 @@
*Pointer<Byte4>(buffer) = Byte4(newValue);
}
- void PixelRoutine::stencilOperation(Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask)
+ void PixelRoutine::stencilOperation(Byte8 &newValue, Byte8 &bufferValue, VkStencilOp stencilPassOperation, VkStencilOp stencilZFailOperation, VkStencilOp stencilFailOperation, bool CCW, Int &zMask, Int &sMask)
{
Byte8 &pass = newValue;
Byte8 fail;
@@ -753,32 +753,32 @@
}
}
- void PixelRoutine::stencilOperation(Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW)
+ void PixelRoutine::stencilOperation(Byte8 &output, Byte8 &bufferValue, VkStencilOp operation, bool CCW)
{
switch(operation)
{
- case OPERATION_KEEP:
+ case VK_STENCIL_OP_KEEP:
output = bufferValue;
break;
- case OPERATION_ZERO:
+ case VK_STENCIL_OP_ZERO:
output = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
break;
- case OPERATION_REPLACE:
+ case VK_STENCIL_OP_REPLACE:
output = *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceQ));
break;
- case OPERATION_INCRSAT:
+ case VK_STENCIL_OP_INCREMENT_AND_CLAMP:
output = AddSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
break;
- case OPERATION_DECRSAT:
+ case VK_STENCIL_OP_DECREMENT_AND_CLAMP:
output = SubSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
break;
- case OPERATION_INVERT:
+ case VK_STENCIL_OP_INVERT:
output = bufferValue ^ Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
break;
- case OPERATION_INCR:
+ case VK_STENCIL_OP_INCREMENT_AND_WRAP:
output = bufferValue + Byte8(1, 1, 1, 1, 1, 1, 1, 1);
break;
- case OPERATION_DECR:
+ case VK_STENCIL_OP_DECREMENT_AND_WRAP:
output = bufferValue - Byte8(1, 1, 1, 1, 1, 1, 1, 1);
break;
default:
diff --git a/src/Pipeline/PixelRoutine.hpp b/src/Pipeline/PixelRoutine.hpp
index 8e8e074..c6a4f16 100644
--- a/src/Pipeline/PixelRoutine.hpp
+++ b/src/Pipeline/PixelRoutine.hpp
@@ -66,9 +66,9 @@
private:
Float4 interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
void stencilTest(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask);
- void stencilTest(Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW);
- void stencilOperation(Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask);
- void stencilOperation(Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW);
+ void stencilTest(Byte8 &value, VkCompareOp stencilCompareMode, bool CCW);
+ void stencilOperation(Byte8 &newValue, Byte8 &bufferValue, VkStencilOp stencilPassOperation, VkStencilOp stencilZFailOperation, VkStencilOp stencilFailOperation, bool CCW, Int &zMask, Int &sMask);
+ void stencilOperation(Byte8 &output, Byte8 &bufferValue, VkStencilOp operation, bool CCW);
Bool depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
// Raster operations
