Removed SwiftShader's custom Blending enums

- Replaced BlendFactor with VkBlendFactor
- Replaced BlendOperation with VkBlendOp

Bug b/118386749

Change-Id: I25031c044af05b1922d031db9e82c52bb785def5
Reviewed-on: https://swiftshader-review.googlesource.com/c/22850
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 91bc446..1fb4d53 100644 (file)
--- a/src/Device/Context.cpp
+++ b/src/Device/Context.cpp
@@ -202,14 +202,14 @@ namespace sw
                depthWriteEnable = true;
 
                alphaBlendEnable = false;
-               sourceBlendFactorState = BLEND_ONE;
-               destBlendFactorState = BLEND_ZERO;
-               blendOperationState = BLENDOP_ADD;
+               sourceBlendFactorState = VK_BLEND_FACTOR_ONE;
+               destBlendFactorState = VK_BLEND_FACTOR_ZERO;
+               blendOperationState = VK_BLEND_OP_ADD;
 
                separateAlphaBlendEnable = false;
-               sourceBlendFactorStateAlpha = BLEND_ONE;
-               destBlendFactorStateAlpha = BLEND_ZERO;
-               blendOperationStateAlpha = BLENDOP_ADD;
+               sourceBlendFactorStateAlpha = VK_BLEND_FACTOR_ONE;
+               destBlendFactorStateAlpha = VK_BLEND_FACTOR_ZERO;
+               blendOperationStateAlpha = VK_BLEND_OP_ADD;
 
                cullMode = CULL_CLOCKWISE;
                frontFacingCCW = true;
@@ -255,21 +255,21 @@ namespace sw
                return modified;
        }
 
-       bool Context::setSourceBlendFactor(BlendFactor sourceBlendFactor)
+       bool Context::setSourceBlendFactor(VkBlendFactor sourceBlendFactor)
        {
                bool modified = (Context::sourceBlendFactorState != sourceBlendFactor);
                Context::sourceBlendFactorState = sourceBlendFactor;
                return modified;
        }
 
-       bool Context::setDestBlendFactor(BlendFactor destBlendFactor)
+       bool Context::setDestBlendFactor(VkBlendFactor destBlendFactor)
        {
                bool modified = (Context::destBlendFactorState != destBlendFactor);
                Context::destBlendFactorState = destBlendFactor;
                return modified;
        }
 
-       bool Context::setBlendOperation(BlendOperation blendOperation)
+       bool Context::setBlendOperation(VkBlendOp blendOperation)
        {
                bool modified = (Context::blendOperationState != blendOperation);
                Context::blendOperationState = blendOperation;
@@ -283,21 +283,21 @@ namespace sw
                return modified;
        }
 
-       bool Context::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
+       bool Context::setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha)
        {
                bool modified = (Context::sourceBlendFactorStateAlpha != sourceBlendFactorAlpha);
                Context::sourceBlendFactorStateAlpha = sourceBlendFactorAlpha;
                return modified;
        }
 
-       bool Context::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
+       bool Context::setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha)
        {
                bool modified = (Context::destBlendFactorStateAlpha != destBlendFactorAlpha);
                Context::destBlendFactorStateAlpha = destBlendFactorAlpha;
                return modified;
        }
 
-       bool Context::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
+       bool Context::setBlendOperationAlpha(VkBlendOp blendOperationAlpha)
        {
                bool modified = (Context::blendOperationStateAlpha != blendOperationAlpha);
                Context::blendOperationStateAlpha = blendOperationAlpha;
@@ -371,8 +371,8 @@ namespace sw
                        return false;
                }
 
-               bool colorBlend = !(blendOperation() == BLENDOP_SOURCE && sourceBlendFactor() == BLEND_ONE);
-               bool alphaBlend = separateAlphaBlendEnable ? !(blendOperationAlpha() == BLENDOP_SOURCE && sourceBlendFactorAlpha() == BLEND_ONE) : colorBlend;
+               bool colorBlend = !(blendOperation() == VK_BLEND_OP_SRC_EXT && sourceBlendFactor() == VK_BLEND_FACTOR_ONE);
+               bool alphaBlend = separateAlphaBlendEnable ? !(blendOperationAlpha() == VK_BLEND_OP_SRC_EXT && sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE) : colorBlend;
 
                return colorBlend || alphaBlend;
        }
@@ -382,20 +382,20 @@ namespace sw
                return colorLogicOpEnabled ? logicalOperation : VK_LOGIC_OP_COPY;
        }
 
-       BlendFactor Context::sourceBlendFactor()
+       VkBlendFactor Context::sourceBlendFactor()
        {
-               if(!alphaBlendEnable) return BLEND_ONE;
+               if(!alphaBlendEnable) return VK_BLEND_FACTOR_ONE;
 
                switch(blendOperationState)
                {
-               case BLENDOP_ADD:
-               case BLENDOP_SUB:
-               case BLENDOP_INVSUB:
+               case VK_BLEND_OP_ADD:
+               case VK_BLEND_OP_SUBTRACT:
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
                        return sourceBlendFactorState;
-               case BLENDOP_MIN:
-                       return BLEND_ONE;
-               case BLENDOP_MAX:
-                       return BLEND_ONE;
+               case VK_BLEND_OP_MIN:
+                       return VK_BLEND_FACTOR_ONE;
+               case VK_BLEND_OP_MAX:
+                       return VK_BLEND_FACTOR_ONE;
                default:
                        ASSERT(false);
                }
@@ -403,20 +403,20 @@ namespace sw
                return sourceBlendFactorState;
        }
 
-       BlendFactor Context::destBlendFactor()
+       VkBlendFactor Context::destBlendFactor()
        {
-               if(!alphaBlendEnable) return BLEND_ZERO;
+               if(!alphaBlendEnable) return VK_BLEND_FACTOR_ONE;
 
                switch(blendOperationState)
                {
-               case BLENDOP_ADD:
-               case BLENDOP_SUB:
-               case BLENDOP_INVSUB:
+               case VK_BLEND_OP_ADD:
+               case VK_BLEND_OP_SUBTRACT:
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
                        return destBlendFactorState;
-               case BLENDOP_MIN:
-                       return BLEND_ONE;
-               case BLENDOP_MAX:
-                       return BLEND_ONE;
+               case VK_BLEND_OP_MIN:
+                       return VK_BLEND_FACTOR_ONE;
+               case VK_BLEND_OP_MAX:
+                       return VK_BLEND_FACTOR_ONE;
                default:
                        ASSERT(false);
                }
@@ -424,111 +424,111 @@ namespace sw
                return destBlendFactorState;
        }
 
-       BlendOperation Context::blendOperation()
+       VkBlendOp Context::blendOperation()
        {
-               if(!alphaBlendEnable) return BLENDOP_SOURCE;
+               if(!alphaBlendEnable) return VK_BLEND_OP_SRC_EXT;
 
                switch(blendOperationState)
                {
-               case BLENDOP_ADD:
-                       if(sourceBlendFactor() == BLEND_ZERO)
+               case VK_BLEND_OP_ADD:
+                       if(sourceBlendFactor() == VK_BLEND_FACTOR_ZERO)
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_NULL;
+                                       return VK_BLEND_OP_ZERO_EXT;
                                }
                                else
                                {
-                                       return BLENDOP_DEST;
+                                       return VK_BLEND_OP_DST_EXT;
                                }
                        }
-                       else if(sourceBlendFactor() == BLEND_ONE)
+                       else if(sourceBlendFactor() == VK_BLEND_FACTOR_ONE)
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_SOURCE;
+                                       return VK_BLEND_OP_SRC_EXT;
                                }
                                else
                                {
-                                       return BLENDOP_ADD;
+                                       return VK_BLEND_OP_ADD;
                                }
                        }
                        else
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_SOURCE;
+                                       return VK_BLEND_OP_SRC_EXT;
                                }
                                else
                                {
-                                       return BLENDOP_ADD;
+                                       return VK_BLEND_OP_ADD;
                                }
                        }
-               case BLENDOP_SUB:
-                       if(sourceBlendFactor() == BLEND_ZERO)
+               case VK_BLEND_OP_SUBTRACT:
+                       if(sourceBlendFactor() == VK_BLEND_FACTOR_ZERO)
                        {
-                               return BLENDOP_NULL;   // Negative, clamped to zero
+                               return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
                        }
-                       else if(sourceBlendFactor() == BLEND_ONE)
+                       else if(sourceBlendFactor() == VK_BLEND_FACTOR_ONE)
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_SOURCE;
+                                       return VK_BLEND_OP_SRC_EXT;
                                }
                                else
                                {
-                                       return BLENDOP_SUB;
+                                       return VK_BLEND_OP_SUBTRACT;
                                }
                        }
                        else
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_SOURCE;
+                                       return VK_BLEND_OP_SRC_EXT;
                                }
                                else
                                {
-                                       return BLENDOP_SUB;
+                                       return VK_BLEND_OP_SUBTRACT;
                                }
                        }
-               case BLENDOP_INVSUB:
-                       if(sourceBlendFactor() == BLEND_ZERO)
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
+                       if(sourceBlendFactor() == VK_BLEND_FACTOR_ZERO)
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_NULL;
+                                       return VK_BLEND_OP_ZERO_EXT;
                                }
                                else
                                {
-                                       return BLENDOP_DEST;
+                                       return VK_BLEND_OP_DST_EXT;
                                }
                        }
-                       else if(sourceBlendFactor() == BLEND_ONE)
+                       else if(sourceBlendFactor() == VK_BLEND_FACTOR_ONE)
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_NULL;   // Negative, clamped to zero
+                                       return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
                                }
                                else
                                {
-                                       return BLENDOP_INVSUB;
+                                       return VK_BLEND_OP_REVERSE_SUBTRACT;
                                }
                        }
                        else
                        {
-                               if(destBlendFactor() == BLEND_ZERO)
+                               if(destBlendFactor() == VK_BLEND_OP_ZERO_EXT)
                                {
-                                       return BLENDOP_NULL;   // Negative, clamped to zero
+                                       return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
                                }
                                else
                                {
-                                       return BLENDOP_INVSUB;
+                                       return VK_BLEND_OP_REVERSE_SUBTRACT;
                                }
                        }
-               case BLENDOP_MIN:
-                       return BLENDOP_MIN;
-               case BLENDOP_MAX:
-                       return BLENDOP_MAX;
+               case VK_BLEND_OP_MIN:
+                       return VK_BLEND_OP_MIN;
+               case VK_BLEND_OP_MAX:
+                       return VK_BLEND_OP_MAX;
                default:
                        ASSERT(false);
                }
@@ -536,7 +536,7 @@ namespace sw
                return blendOperationState;
        }
 
-       BlendFactor Context::sourceBlendFactorAlpha()
+       VkBlendFactor Context::sourceBlendFactorAlpha()
        {
                if(!separateAlphaBlendEnable)
                {
@@ -546,14 +546,14 @@ namespace sw
                {
                        switch(blendOperationStateAlpha)
                        {
-                       case BLENDOP_ADD:
-                       case BLENDOP_SUB:
-                       case BLENDOP_INVSUB:
+                       case VK_BLEND_OP_ADD:
+                       case VK_BLEND_OP_SUBTRACT:
+                       case VK_BLEND_OP_REVERSE_SUBTRACT:
                                return sourceBlendFactorStateAlpha;
-                       case BLENDOP_MIN:
-                               return BLEND_ONE;
-                       case BLENDOP_MAX:
-                               return BLEND_ONE;
+                       case VK_BLEND_OP_MIN:
+                               return VK_BLEND_FACTOR_ONE;
+                       case VK_BLEND_OP_MAX:
+                               return VK_BLEND_FACTOR_ONE;
                        default:
                                ASSERT(false);
                        }
@@ -562,7 +562,7 @@ namespace sw
                }
        }
 
-       BlendFactor Context::destBlendFactorAlpha()
+       VkBlendFactor Context::destBlendFactorAlpha()
        {
                if(!separateAlphaBlendEnable)
                {
@@ -572,14 +572,14 @@ namespace sw
                {
                        switch(blendOperationStateAlpha)
                        {
-                       case BLENDOP_ADD:
-                       case BLENDOP_SUB:
-                       case BLENDOP_INVSUB:
+                       case VK_BLEND_OP_ADD:
+                       case VK_BLEND_OP_SUBTRACT:
+                       case VK_BLEND_OP_REVERSE_SUBTRACT:
                                return destBlendFactorStateAlpha;
-                       case BLENDOP_MIN:
-                               return BLEND_ONE;
-                       case BLENDOP_MAX:
-                               return BLEND_ONE;
+                       case VK_BLEND_OP_MIN:
+                               return VK_BLEND_FACTOR_ONE;
+                       case VK_BLEND_OP_MAX:
+                               return VK_BLEND_FACTOR_ONE;
                        default:
                                ASSERT(false);
                        }
@@ -588,7 +588,7 @@ namespace sw
                }
        }
 
-       BlendOperation Context::blendOperationAlpha()
+       VkBlendOp Context::blendOperationAlpha()
        {
                if(!separateAlphaBlendEnable)
                {
@@ -598,105 +598,105 @@ namespace sw
                {
                        switch(blendOperationStateAlpha)
                        {
-                       case BLENDOP_ADD:
-                               if(sourceBlendFactorAlpha() == BLEND_ZERO)
+                       case VK_BLEND_OP_ADD:
+                               if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_NULL;
+                                               return VK_BLEND_OP_ZERO_EXT;
                                        }
                                        else
                                        {
-                                               return BLENDOP_DEST;
+                                               return VK_BLEND_OP_DST_EXT;
                                        }
                                }
-                               else if(sourceBlendFactorAlpha() == BLEND_ONE)
+                               else if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_SOURCE;
+                                               return VK_BLEND_OP_SRC_EXT;
                                        }
                                        else
                                        {
-                                               return BLENDOP_ADD;
+                                               return VK_BLEND_OP_ADD;
                                        }
                                }
                                else
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_SOURCE;
+                                               return VK_BLEND_OP_SRC_EXT;
                                        }
                                        else
                                        {
-                                               return BLENDOP_ADD;
+                                               return VK_BLEND_OP_ADD;
                                        }
                                }
-                       case BLENDOP_SUB:
-                               if(sourceBlendFactorAlpha() == BLEND_ZERO)
+                       case VK_BLEND_OP_SUBTRACT:
+                               if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       return BLENDOP_NULL;   // Negative, clamped to zero
+                                       return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
                                }
-                               else if(sourceBlendFactorAlpha() == BLEND_ONE)
+                               else if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_SOURCE;
+                                               return VK_BLEND_OP_SRC_EXT;
                                        }
                                        else
                                        {
-                                               return BLENDOP_SUB;
+                                               return VK_BLEND_OP_SUBTRACT;
                                        }
                                }
                                else
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_SOURCE;
+                                               return VK_BLEND_OP_SRC_EXT;
                                        }
                                        else
                                        {
-                                               return BLENDOP_SUB;
+                                               return VK_BLEND_OP_SUBTRACT;
                                        }
                                }
-                       case BLENDOP_INVSUB:
-                               if(sourceBlendFactorAlpha() == BLEND_ZERO)
+                       case VK_BLEND_OP_REVERSE_SUBTRACT:
+                               if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_NULL;
+                                               return VK_BLEND_OP_ZERO_EXT;
                                        }
                                        else
                                        {
-                                               return BLENDOP_DEST;
+                                               return VK_BLEND_OP_DST_EXT;
                                        }
                                }
-                               else if(sourceBlendFactorAlpha() == BLEND_ONE)
+                               else if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
                                        {
-                                               return BLENDOP_NULL;   // Negative, clamped to zero
+                                               return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
                                        }
                                        else
                                        {
-                                               return BLENDOP_INVSUB;
+                                               return VK_BLEND_OP_REVERSE_SUBTRACT;
                                        }
                                }
                                else
                                {
-                                       if(destBlendFactorAlpha() == BLEND_ZERO)
+                                       if(destBlendFactorAlpha() == VK_BLEND_OP_ZERO_EXT)
                                        {
-                                               return BLENDOP_NULL;   // Negative, clamped to zero
+                                               return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
                                        }
                                        else
                                        {
-                                               return BLENDOP_INVSUB;
+                                               return VK_BLEND_OP_ZERO_EXT;
                                        }
                                }
-                       case BLENDOP_MIN:
-                               return BLENDOP_MIN;
-                       case BLENDOP_MAX:
-                               return BLENDOP_MAX;
+                       case VK_BLEND_OP_MIN:
+                               return VK_BLEND_OP_MIN;
+                       case VK_BLEND_OP_MAX:
+                               return VK_BLEND_OP_MAX;
                        default:
                                ASSERT(false);
                        }
@@ -764,8 +764,8 @@ namespace sw
                        return 0;
                }
 
-               if(blendOperation() == BLENDOP_DEST && destBlendFactor() == BLEND_ONE &&
-                  (!separateAlphaBlendEnable || (blendOperationAlpha() == BLENDOP_DEST && destBlendFactorAlpha() == BLEND_ONE)))
+               if(blendOperation() == VK_BLEND_OP_DST_EXT && destBlendFactor() == VK_BLEND_FACTOR_ONE &&
+                  (!separateAlphaBlendEnable || (blendOperationAlpha() == VK_BLEND_OP_DST_EXT && destBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)))
                {
                        return 0;
                }

diff --git a/src/Device/Context.hpp b/src/Device/Context.hpp
index d014564..790e4ca 100644 (file)
--- a/src/Device/Context.hpp
+++ b/src/Device/Context.hpp
@@ -93,42 +93,6 @@ namespace sw
                CULL_LAST = CULL_COUNTERCLOCKWISE
        };
 
-       enum BlendFactor ENUM_UNDERLYING_TYPE_UNSIGNED_INT
-       {
-               BLEND_ZERO,
-               BLEND_ONE,
-               BLEND_SOURCE,
-               BLEND_INVSOURCE,
-               BLEND_DEST,
-               BLEND_INVDEST,
-               BLEND_SOURCEALPHA,
-               BLEND_INVSOURCEALPHA,
-               BLEND_DESTALPHA,
-               BLEND_INVDESTALPHA,
-               BLEND_SRCALPHASAT,
-               BLEND_CONSTANT,
-               BLEND_INVCONSTANT,
-               BLEND_CONSTANTALPHA,
-               BLEND_INVCONSTANTALPHA,
-
-               BLEND_LAST = BLEND_INVCONSTANTALPHA
-       };
-
-       enum BlendOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
-       {
-               BLENDOP_ADD,
-               BLENDOP_SUB,
-               BLENDOP_INVSUB,
-               BLENDOP_MIN,
-               BLENDOP_MAX,
-
-               BLENDOP_SOURCE,   // Copy source
-               BLENDOP_DEST,     // Copy dest
-               BLENDOP_NULL,     // Nullify result
-
-               BLENDOP_LAST = BLENDOP_NULL
-       };
-
        enum TransparencyAntialiasing ENUM_UNDERLYING_TYPE_UNSIGNED_INT
        {
                TRANSPARENCY_NONE,
@@ -156,14 +120,14 @@ namespace sw
                bool setDepthBufferEnable(bool depthBufferEnable);
 
                bool setAlphaBlendEnable(bool alphaBlendEnable);
-               bool setSourceBlendFactor(BlendFactor sourceBlendFactor);
-               bool setDestBlendFactor(BlendFactor destBlendFactor);
-               bool setBlendOperation(BlendOperation blendOperation);
+               bool setSourceBlendFactor(VkBlendFactor sourceBlendFactor);
+               bool setDestBlendFactor(VkBlendFactor destBlendFactor);
+               bool setBlendOperation(VkBlendOp blendOperation);
 
                bool setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable);
-               bool setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha);
-               bool setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha);
-               bool setBlendOperationAlpha(BlendOperation blendOperationAlpha);
+               bool setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha);
+               bool setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha);
+               bool setBlendOperationAlpha(VkBlendOp blendOperationAlpha);
 
                bool setColorWriteMask(int index, int colorWriteMask);
                bool setWriteSRGB(bool sRGB);
@@ -179,13 +143,13 @@ namespace sw
                bool perspectiveActive();
 
                bool alphaBlendActive();
-               BlendFactor sourceBlendFactor();
-               BlendFactor destBlendFactor();
-               BlendOperation blendOperation();
+               VkBlendFactor sourceBlendFactor();
+               VkBlendFactor destBlendFactor();
+               VkBlendOp blendOperation();
 
-               BlendFactor sourceBlendFactorAlpha();
-               BlendFactor destBlendFactorAlpha();
-               BlendOperation blendOperationAlpha();
+               VkBlendFactor sourceBlendFactorAlpha();
+               VkBlendFactor destBlendFactorAlpha();
+               VkBlendOp blendOperationAlpha();
 
                VkLogicOp colorLogicOp();
 
@@ -261,14 +225,14 @@ namespace sw
                bool depthWriteEnable;
 
                bool alphaBlendEnable;
-               BlendFactor sourceBlendFactorState;
-               BlendFactor destBlendFactorState;
-               BlendOperation blendOperationState;
+               VkBlendFactor sourceBlendFactorState;
+               VkBlendFactor destBlendFactorState;
+               VkBlendOp blendOperationState;
 
                bool separateAlphaBlendEnable;
-               BlendFactor sourceBlendFactorStateAlpha;
-               BlendFactor destBlendFactorStateAlpha;
-               BlendOperation blendOperationStateAlpha;
+               VkBlendFactor sourceBlendFactorStateAlpha;
+               VkBlendFactor destBlendFactorStateAlpha;
+               VkBlendOp blendOperationStateAlpha;
 
                float lineWidth;
 

diff --git a/src/Device/PixelProcessor.cpp b/src/Device/PixelProcessor.cpp
index 7c0f98b..683eda2 100644 (file)
--- a/src/Device/PixelProcessor.cpp
+++ b/src/Device/PixelProcessor.cpp
@@ -560,17 +560,17 @@ namespace sw
                context->setAlphaBlendEnable(alphaBlendEnable);
        }
 
-       void PixelProcessor::setSourceBlendFactor(BlendFactor sourceBlendFactor)
+       void PixelProcessor::setSourceBlendFactor(VkBlendFactor sourceBlendFactor)
        {
                context->setSourceBlendFactor(sourceBlendFactor);
        }
 
-       void PixelProcessor::setDestBlendFactor(BlendFactor destBlendFactor)
+       void PixelProcessor::setDestBlendFactor(VkBlendFactor destBlendFactor)
        {
                context->setDestBlendFactor(destBlendFactor);
        }
 
-       void PixelProcessor::setBlendOperation(BlendOperation blendOperation)
+       void PixelProcessor::setBlendOperation(VkBlendOp blendOperation)
        {
                context->setBlendOperation(blendOperation);
        }
@@ -580,17 +580,17 @@ namespace sw
                context->setSeparateAlphaBlendEnable(separateAlphaBlendEnable);
        }
 
-       void PixelProcessor::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
+       void PixelProcessor::setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha)
        {
                context->setSourceBlendFactorAlpha(sourceBlendFactorAlpha);
        }
 
-       void PixelProcessor::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
+       void PixelProcessor::setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha)
        {
                context->setDestBlendFactorAlpha(destBlendFactorAlpha);
        }
 
-       void PixelProcessor::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
+       void PixelProcessor::setBlendOperationAlpha(VkBlendOp blendOperationAlpha)
        {
                context->setBlendOperationAlpha(blendOperationAlpha);
        }

diff --git a/src/Device/PixelProcessor.hpp b/src/Device/PixelProcessor.hpp
index 3475599..1b0e04b 100644 (file)
--- a/src/Device/PixelProcessor.hpp
+++ b/src/Device/PixelProcessor.hpp
@@ -65,12 +65,12 @@ namespace sw
                        bool depthClamp                           : 1;
 
                        bool alphaBlendActive                     : 1;
-                       BlendFactor sourceBlendFactor             : BITS(BLEND_LAST);
-                       BlendFactor destBlendFactor               : BITS(BLEND_LAST);
-                       BlendOperation blendOperation             : BITS(BLENDOP_LAST);
-                       BlendFactor sourceBlendFactorAlpha        : BITS(BLEND_LAST);
-                       BlendFactor destBlendFactorAlpha          : BITS(BLEND_LAST);
-                       BlendOperation blendOperationAlpha        : BITS(BLENDOP_LAST);
+                       VkBlendFactor sourceBlendFactor           : BITS(VK_BLEND_FACTOR_END_RANGE);
+                       VkBlendFactor destBlendFactor             : BITS(VK_BLEND_FACTOR_END_RANGE);
+                       VkBlendOp blendOperation                  : BITS(VK_BLEND_OP_BLUE_EXT);
+                       VkBlendFactor sourceBlendFactorAlpha      : BITS(VK_BLEND_FACTOR_END_RANGE);
+                       VkBlendFactor destBlendFactorAlpha        : BITS(VK_BLEND_FACTOR_END_RANGE);
+                       VkBlendOp blendOperationAlpha             : BITS(VK_BLEND_OP_BLUE_EXT);
 
                        unsigned int colorWriteMask                       : RENDERTARGETS * 4;   // Four component bit masks
                        VkFormat targetFormat[RENDERTARGETS];
@@ -239,14 +239,14 @@ namespace sw
                void setBlendConstant(const Color<float> &blendConstant);
 
                void setAlphaBlendEnable(bool alphaBlendEnable);
-               void setSourceBlendFactor(BlendFactor sourceBlendFactor);
-               void setDestBlendFactor(BlendFactor destBlendFactor);
-               void setBlendOperation(BlendOperation blendOperation);
+               void setSourceBlendFactor(VkBlendFactor sourceBlendFactor);
+               void setDestBlendFactor(VkBlendFactor destBlendFactor);
+               void setBlendOperation(VkBlendOp blendOperation);
 
                void setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable);
-               void setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha);
-               void setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha);
-               void setBlendOperationAlpha(BlendOperation blendOperationAlpha);
+               void setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha);
+               void setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha);
+               void setBlendOperationAlpha(VkBlendOp blendOperationAlpha);
 
                void setAlphaReference(float alphaReference);
 

diff --git a/src/Pipeline/PixelRoutine.cpp b/src/Pipeline/PixelRoutine.cpp
index 948e201..8e40a26 100644 (file)
--- a/src/Pipeline/PixelRoutine.cpp
+++ b/src/Pipeline/PixelRoutine.cpp
@@ -786,78 +786,78 @@ namespace sw
                }
        }
 
-       void PixelRoutine::blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
+       void PixelRoutine::blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorActive)
        {
                switch(blendFactorActive)
                {
-               case BLEND_ZERO:
+               case VK_BLEND_FACTOR_ZERO:
                        // Optimized
                        break;
-               case BLEND_ONE:
+               case VK_BLEND_FACTOR_ONE:
                        // Optimized
                        break;
-               case BLEND_SOURCE:
+               case VK_BLEND_FACTOR_SRC_COLOR:
                        blendFactor.x = current.x;
                        blendFactor.y = current.y;
                        blendFactor.z = current.z;
                        break;
-               case BLEND_INVSOURCE:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
                        blendFactor.x = Short4(0xFFFFu) - current.x;
                        blendFactor.y = Short4(0xFFFFu) - current.y;
                        blendFactor.z = Short4(0xFFFFu) - current.z;
                        break;
-               case BLEND_DEST:
+               case VK_BLEND_FACTOR_DST_COLOR:
                        blendFactor.x = pixel.x;
                        blendFactor.y = pixel.y;
                        blendFactor.z = pixel.z;
                        break;
-               case BLEND_INVDEST:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
                        blendFactor.x = Short4(0xFFFFu) - pixel.x;
                        blendFactor.y = Short4(0xFFFFu) - pixel.y;
                        blendFactor.z = Short4(0xFFFFu) - pixel.z;
                        break;
-               case BLEND_SOURCEALPHA:
+               case VK_BLEND_FACTOR_SRC_ALPHA:
                        blendFactor.x = current.w;
                        blendFactor.y = current.w;
                        blendFactor.z = current.w;
                        break;
-               case BLEND_INVSOURCEALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
                        blendFactor.x = Short4(0xFFFFu) - current.w;
                        blendFactor.y = Short4(0xFFFFu) - current.w;
                        blendFactor.z = Short4(0xFFFFu) - current.w;
                        break;
-               case BLEND_DESTALPHA:
+               case VK_BLEND_FACTOR_DST_ALPHA:
                        blendFactor.x = pixel.w;
                        blendFactor.y = pixel.w;
                        blendFactor.z = pixel.w;
                        break;
-               case BLEND_INVDESTALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
                        blendFactor.x = Short4(0xFFFFu) - pixel.w;
                        blendFactor.y = Short4(0xFFFFu) - pixel.w;
                        blendFactor.z = Short4(0xFFFFu) - pixel.w;
                        break;
-               case BLEND_SRCALPHASAT:
+               case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
                        blendFactor.x = Short4(0xFFFFu) - pixel.w;
                        blendFactor.x = Min(As<UShort4>(blendFactor.x), As<UShort4>(current.w));
                        blendFactor.y = blendFactor.x;
                        blendFactor.z = blendFactor.x;
                        break;
-               case BLEND_CONSTANT:
+               case VK_BLEND_FACTOR_CONSTANT_COLOR:
                        blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[0]));
                        blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[1]));
                        blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[2]));
                        break;
-               case BLEND_INVCONSTANT:
+               case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
                        blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[0]));
                        blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[1]));
                        blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[2]));
                        break;
-               case BLEND_CONSTANTALPHA:
+               case VK_BLEND_FACTOR_CONSTANT_ALPHA:
                        blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
                        blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
                        blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
                        break;
-               case BLEND_INVCONSTANTALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
                        blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
                        blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
                        blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
@@ -867,49 +867,49 @@ namespace sw
                }
        }
 
-       void PixelRoutine::blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive)
+       void PixelRoutine::blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorAlphaActive)
        {
                switch(blendFactorAlphaActive)
                {
-               case BLEND_ZERO:
+               case VK_BLEND_FACTOR_ZERO:
                        // Optimized
                        break;
-               case BLEND_ONE:
+               case VK_BLEND_FACTOR_ONE:
                        // Optimized
                        break;
-               case BLEND_SOURCE:
+               case VK_BLEND_FACTOR_SRC_COLOR:
                        blendFactor.w = current.w;
                        break;
-               case BLEND_INVSOURCE:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
                        blendFactor.w = Short4(0xFFFFu) - current.w;
                        break;
-               case BLEND_DEST:
+               case VK_BLEND_FACTOR_DST_COLOR:
                        blendFactor.w = pixel.w;
                        break;
-               case BLEND_INVDEST:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
                        blendFactor.w = Short4(0xFFFFu) - pixel.w;
                        break;
-               case BLEND_SOURCEALPHA:
+               case VK_BLEND_FACTOR_SRC_ALPHA:
                        blendFactor.w = current.w;
                        break;
-               case BLEND_INVSOURCEALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
                        blendFactor.w = Short4(0xFFFFu) - current.w;
                        break;
-               case BLEND_DESTALPHA:
+               case VK_BLEND_FACTOR_DST_ALPHA:
                        blendFactor.w = pixel.w;
                        break;
-               case BLEND_INVDESTALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
                        blendFactor.w = Short4(0xFFFFu) - pixel.w;
                        break;
-               case BLEND_SRCALPHASAT:
+               case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
                        blendFactor.w = Short4(0xFFFFu);
                        break;
-               case BLEND_CONSTANT:
-               case BLEND_CONSTANTALPHA:
+               case VK_BLEND_FACTOR_CONSTANT_COLOR:
+               case VK_BLEND_FACTOR_CONSTANT_ALPHA:
                        blendFactor.w = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
                        break;
-               case BLEND_INVCONSTANT:
-               case BLEND_INVCONSTANTALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
+               case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
                        blendFactor.w = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
                        break;
                default:
@@ -1050,14 +1050,14 @@ namespace sw
                blendFactor(sourceFactor, current, pixel, state.sourceBlendFactor);
                blendFactor(destFactor, current, pixel, state.destBlendFactor);
 
-               if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
+               if(state.sourceBlendFactor != VK_BLEND_FACTOR_ONE && state.sourceBlendFactor != VK_BLEND_FACTOR_ZERO)
                {
                        current.x = MulHigh(As<UShort4>(current.x), As<UShort4>(sourceFactor.x));
                        current.y = MulHigh(As<UShort4>(current.y), As<UShort4>(sourceFactor.y));
                        current.z = MulHigh(As<UShort4>(current.z), As<UShort4>(sourceFactor.z));
                }
 
-               if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
+               if(state.destBlendFactor != VK_BLEND_FACTOR_ONE && state.destBlendFactor != VK_BLEND_FACTOR_ZERO)
                {
                        pixel.x = MulHigh(As<UShort4>(pixel.x), As<UShort4>(destFactor.x));
                        pixel.y = MulHigh(As<UShort4>(pixel.y), As<UShort4>(destFactor.y));
@@ -1066,40 +1066,40 @@ namespace sw
 
                switch(state.blendOperation)
                {
-               case BLENDOP_ADD:
+               case VK_BLEND_OP_ADD:
                        current.x = AddSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
                        current.y = AddSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
                        current.z = AddSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
                        break;
-               case BLENDOP_SUB:
+               case VK_BLEND_OP_SUBTRACT:
                        current.x = SubSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
                        current.y = SubSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
                        current.z = SubSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
                        break;
-               case BLENDOP_INVSUB:
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
                        current.x = SubSat(As<UShort4>(pixel.x), As<UShort4>(current.x));
                        current.y = SubSat(As<UShort4>(pixel.y), As<UShort4>(current.y));
                        current.z = SubSat(As<UShort4>(pixel.z), As<UShort4>(current.z));
                        break;
-               case BLENDOP_MIN:
+               case VK_BLEND_OP_MIN:
                        current.x = Min(As<UShort4>(current.x), As<UShort4>(pixel.x));
                        current.y = Min(As<UShort4>(current.y), As<UShort4>(pixel.y));
                        current.z = Min(As<UShort4>(current.z), As<UShort4>(pixel.z));
                        break;
-               case BLENDOP_MAX:
+               case VK_BLEND_OP_MAX:
                        current.x = Max(As<UShort4>(current.x), As<UShort4>(pixel.x));
                        current.y = Max(As<UShort4>(current.y), As<UShort4>(pixel.y));
                        current.z = Max(As<UShort4>(current.z), As<UShort4>(pixel.z));
                        break;
-               case BLENDOP_SOURCE:
+               case VK_BLEND_OP_SRC_EXT:
                        // No operation
                        break;
-               case BLENDOP_DEST:
+               case VK_BLEND_OP_DST_EXT:
                        current.x = pixel.x;
                        current.y = pixel.y;
                        current.z = pixel.z;
                        break;
-               case BLENDOP_NULL:
+               case VK_BLEND_OP_ZERO_EXT:
                        current.x = Short4(0x0000);
                        current.y = Short4(0x0000);
                        current.z = Short4(0x0000);
@@ -1111,40 +1111,40 @@ namespace sw
                blendFactorAlpha(sourceFactor, current, pixel, state.sourceBlendFactorAlpha);
                blendFactorAlpha(destFactor, current, pixel, state.destBlendFactorAlpha);
 
-               if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
+               if(state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
                {
                        current.w = MulHigh(As<UShort4>(current.w), As<UShort4>(sourceFactor.w));
                }
 
-               if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
+               if(state.destBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.destBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
                {
                        pixel.w = MulHigh(As<UShort4>(pixel.w), As<UShort4>(destFactor.w));
                }
 
                switch(state.blendOperationAlpha)
                {
-               case BLENDOP_ADD:
+               case VK_BLEND_OP_ADD:
                        current.w = AddSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
                        break;
-               case BLENDOP_SUB:
+               case VK_BLEND_OP_SUBTRACT:
                        current.w = SubSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
                        break;
-               case BLENDOP_INVSUB:
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
                        current.w = SubSat(As<UShort4>(pixel.w), As<UShort4>(current.w));
                        break;
-               case BLENDOP_MIN:
+               case VK_BLEND_OP_MIN:
                        current.w = Min(As<UShort4>(current.w), As<UShort4>(pixel.w));
                        break;
-               case BLENDOP_MAX:
+               case VK_BLEND_OP_MAX:
                        current.w = Max(As<UShort4>(current.w), As<UShort4>(pixel.w));
                        break;
-               case BLENDOP_SOURCE:
+               case VK_BLEND_OP_SRC_EXT:
                        // No operation
                        break;
-               case BLENDOP_DEST:
+               case VK_BLEND_OP_DST_EXT:
                        current.w = pixel.w;
                        break;
-               case BLENDOP_NULL:
+               case VK_BLEND_OP_ZERO_EXT:
                        current.w = Short4(0x0000);
                        break;
                default:
@@ -1679,68 +1679,68 @@ namespace sw
                }
        }
 
-       void PixelRoutine::blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive)
+       void PixelRoutine::blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorActive)
        {
                switch(blendFactorActive)
                {
-               case BLEND_ZERO:
+               case VK_BLEND_FACTOR_ZERO:
                        // Optimized
                        break;
-               case BLEND_ONE:
+               case VK_BLEND_FACTOR_ONE:
                        // Optimized
                        break;
-               case BLEND_SOURCE:
+               case VK_BLEND_FACTOR_SRC_COLOR:
                        blendFactor.x = oC.x;
                        blendFactor.y = oC.y;
                        blendFactor.z = oC.z;
                        break;
-               case BLEND_INVSOURCE:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
                        blendFactor.x = Float4(1.0f) - oC.x;
                        blendFactor.y = Float4(1.0f) - oC.y;
                        blendFactor.z = Float4(1.0f) - oC.z;
                        break;
-               case BLEND_DEST:
+               case VK_BLEND_FACTOR_DST_COLOR:
                        blendFactor.x = pixel.x;
                        blendFactor.y = pixel.y;
                        blendFactor.z = pixel.z;
                        break;
-               case BLEND_INVDEST:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
                        blendFactor.x = Float4(1.0f) - pixel.x;
                        blendFactor.y = Float4(1.0f) - pixel.y;
                        blendFactor.z = Float4(1.0f) - pixel.z;
                        break;
-               case BLEND_SOURCEALPHA:
+               case VK_BLEND_FACTOR_SRC_ALPHA:
                        blendFactor.x = oC.w;
                        blendFactor.y = oC.w;
                        blendFactor.z = oC.w;
                        break;
-               case BLEND_INVSOURCEALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
                        blendFactor.x = Float4(1.0f) - oC.w;
                        blendFactor.y = Float4(1.0f) - oC.w;
                        blendFactor.z = Float4(1.0f) - oC.w;
                        break;
-               case BLEND_DESTALPHA:
+               case VK_BLEND_FACTOR_DST_ALPHA:
                        blendFactor.x = pixel.w;
                        blendFactor.y = pixel.w;
                        blendFactor.z = pixel.w;
                        break;
-               case BLEND_INVDESTALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
                        blendFactor.x = Float4(1.0f) - pixel.w;
                        blendFactor.y = Float4(1.0f) - pixel.w;
                        blendFactor.z = Float4(1.0f) - pixel.w;
                        break;
-               case BLEND_SRCALPHASAT:
+               case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
                        blendFactor.x = Float4(1.0f) - pixel.w;
                        blendFactor.x = Min(blendFactor.x, oC.w);
                        blendFactor.y = blendFactor.x;
                        blendFactor.z = blendFactor.x;
                        break;
-               case BLEND_CONSTANT:
+               case VK_BLEND_FACTOR_CONSTANT_COLOR:
                        blendFactor.x = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[0]));
                        blendFactor.y = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[1]));
                        blendFactor.z = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[2]));
                        break;
-               case BLEND_INVCONSTANT:
+               case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
                        blendFactor.x = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[0]));
                        blendFactor.y = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[1]));
                        blendFactor.z = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[2]));
@@ -1750,47 +1750,47 @@ namespace sw
                }
        }
 
-       void PixelRoutine::blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive)
+       void PixelRoutine::blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorAlphaActive)
        {
                switch(blendFactorAlphaActive)
                {
-               case BLEND_ZERO:
+               case VK_BLEND_FACTOR_ZERO:
                        // Optimized
                        break;
-               case BLEND_ONE:
+               case VK_BLEND_FACTOR_ONE:
                        // Optimized
                        break;
-               case BLEND_SOURCE:
+               case VK_BLEND_FACTOR_SRC_COLOR:
                        blendFactor.w = oC.w;
                        break;
-               case BLEND_INVSOURCE:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
                        blendFactor.w = Float4(1.0f) - oC.w;
                        break;
-               case BLEND_DEST:
+               case VK_BLEND_FACTOR_DST_COLOR:
                        blendFactor.w = pixel.w;
                        break;
-               case BLEND_INVDEST:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
                        blendFactor.w = Float4(1.0f) - pixel.w;
                        break;
-               case BLEND_SOURCEALPHA:
+               case VK_BLEND_FACTOR_SRC_ALPHA:
                        blendFactor.w = oC.w;
                        break;
-               case BLEND_INVSOURCEALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
                        blendFactor.w = Float4(1.0f) - oC.w;
                        break;
-               case BLEND_DESTALPHA:
+               case VK_BLEND_FACTOR_DST_ALPHA:
                        blendFactor.w = pixel.w;
                        break;
-               case BLEND_INVDESTALPHA:
+               case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
                        blendFactor.w = Float4(1.0f) - pixel.w;
                        break;
-               case BLEND_SRCALPHASAT:
+               case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
                        blendFactor.w = Float4(1.0f);
                        break;
-               case BLEND_CONSTANT:
+               case VK_BLEND_FACTOR_CONSTANT_COLOR:
                        blendFactor.w = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[3]));
                        break;
-               case BLEND_INVCONSTANT:
+               case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
                        blendFactor.w = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[3]));
                        break;
                default:
@@ -1879,14 +1879,14 @@ namespace sw
                blendFactor(sourceFactor, oC, pixel, state.sourceBlendFactor);
                blendFactor(destFactor, oC, pixel, state.destBlendFactor);
 
-               if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
+               if(state.sourceBlendFactor != VK_BLEND_FACTOR_ONE && state.sourceBlendFactor != VK_BLEND_FACTOR_ZERO)
                {
                        oC.x *= sourceFactor.x;
                        oC.y *= sourceFactor.y;
                        oC.z *= sourceFactor.z;
                }
 
-               if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
+               if(state.destBlendFactor != VK_BLEND_FACTOR_ONE && state.destBlendFactor != VK_BLEND_FACTOR_ZERO)
                {
                        pixel.x *= destFactor.x;
                        pixel.y *= destFactor.y;
@@ -1895,40 +1895,40 @@ namespace sw
 
                switch(state.blendOperation)
                {
-               case BLENDOP_ADD:
+               case VK_BLEND_OP_ADD:
                        oC.x += pixel.x;
                        oC.y += pixel.y;
                        oC.z += pixel.z;
                        break;
-               case BLENDOP_SUB:
+               case VK_BLEND_OP_SUBTRACT:
                        oC.x -= pixel.x;
                        oC.y -= pixel.y;
                        oC.z -= pixel.z;
                        break;
-               case BLENDOP_INVSUB:
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
                        oC.x = pixel.x - oC.x;
                        oC.y = pixel.y - oC.y;
                        oC.z = pixel.z - oC.z;
                        break;
-               case BLENDOP_MIN:
+               case VK_BLEND_OP_MIN:
                        oC.x = Min(oC.x, pixel.x);
                        oC.y = Min(oC.y, pixel.y);
                        oC.z = Min(oC.z, pixel.z);
                        break;
-               case BLENDOP_MAX:
+               case VK_BLEND_OP_MAX:
                        oC.x = Max(oC.x, pixel.x);
                        oC.y = Max(oC.y, pixel.y);
                        oC.z = Max(oC.z, pixel.z);
                        break;
-               case BLENDOP_SOURCE:
+               case VK_BLEND_OP_SRC_EXT:
                        // No operation
                        break;
-               case BLENDOP_DEST:
+               case VK_BLEND_OP_DST_EXT:
                        oC.x = pixel.x;
                        oC.y = pixel.y;
                        oC.z = pixel.z;
                        break;
-               case BLENDOP_NULL:
+               case VK_BLEND_OP_ZERO_EXT:
                        oC.x = Float4(0.0f);
                        oC.y = Float4(0.0f);
                        oC.z = Float4(0.0f);
@@ -1940,41 +1940,41 @@ namespace sw
                blendFactorAlpha(sourceFactor, oC, pixel, state.sourceBlendFactorAlpha);
                blendFactorAlpha(destFactor, oC, pixel, state.destBlendFactorAlpha);
 
-               if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
+               if(state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
                {
                        oC.w *= sourceFactor.w;
                }
 
-               if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
+               if(state.destBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.destBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
                {
                        pixel.w *= destFactor.w;
                }
 
                switch(state.blendOperationAlpha)
                {
-               case BLENDOP_ADD:
+               case VK_BLEND_OP_ADD:
                        oC.w += pixel.w;
                        break;
-               case BLENDOP_SUB:
+               case VK_BLEND_OP_SUBTRACT:
                        oC.w -= pixel.w;
                        break;
-               case BLENDOP_INVSUB:
+               case VK_BLEND_OP_REVERSE_SUBTRACT:
                        pixel.w -= oC.w;
                        oC.w = pixel.w;
                        break;
-               case BLENDOP_MIN:
+               case VK_BLEND_OP_MIN:
                        oC.w = Min(oC.w, pixel.w);
                        break;
-               case BLENDOP_MAX:
+               case VK_BLEND_OP_MAX:
                        oC.w = Max(oC.w, pixel.w);
                        break;
-               case BLENDOP_SOURCE:
+               case VK_BLEND_OP_SRC_EXT:
                        // No operation
                        break;
-               case BLENDOP_DEST:
+               case VK_BLEND_OP_DST_EXT:
                        oC.w = pixel.w;
                        break;
-               case BLENDOP_NULL:
+               case VK_BLEND_OP_ZERO_EXT:
                        oC.w = Float4(0.0f);
                        break;
                default:

diff --git a/src/Pipeline/PixelRoutine.hpp b/src/Pipeline/PixelRoutine.hpp
index c6a4f16..288ccc7 100644 (file)
--- a/src/Pipeline/PixelRoutine.hpp
+++ b/src/Pipeline/PixelRoutine.hpp
@@ -72,11 +72,11 @@ namespace sw
                Bool depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
 
                // Raster operations
-               void blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
-               void blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
+               void blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorActive);
+               void blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorAlphaActive);
                void readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel);
-               void blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
-               void blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
+               void blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorActive);
+               void blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorAlphaActive);
                void writeStencil(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
                void writeDepth(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);