BlendState.h

Go to the documentation of this file.

/*
 *  Copyright 2019-2021 Diligent Graphics LLC
 *  Copyright 2015-2019 Egor Yusov
 *  
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */
 
#pragma once
 
// clang-format off
 
 
#include "../../../Primitives/interface/BasicTypes.h"
#include "Constants.h"
 
DILIGENT_BEGIN_NAMESPACE(Diligent)
 
 
 
DILIGENT_TYPED_ENUM(BLEND_FACTOR, Int8)
{
    BLEND_FACTOR_UNDEFINED = 0,
 
    BLEND_FACTOR_ZERO,
 
    BLEND_FACTOR_ONE,
 
    BLEND_FACTOR_SRC_COLOR,
 
    BLEND_FACTOR_INV_SRC_COLOR,
 
    BLEND_FACTOR_SRC_ALPHA,
 
    BLEND_FACTOR_INV_SRC_ALPHA,
 
    BLEND_FACTOR_DEST_ALPHA,
 
    BLEND_FACTOR_INV_DEST_ALPHA,
 
    BLEND_FACTOR_DEST_COLOR,
 
    BLEND_FACTOR_INV_DEST_COLOR,
 
    BLEND_FACTOR_SRC_ALPHA_SAT,
 
    BLEND_FACTOR_BLEND_FACTOR,
 
    BLEND_FACTOR_INV_BLEND_FACTOR,
 
    BLEND_FACTOR_SRC1_COLOR,
 
    BLEND_FACTOR_INV_SRC1_COLOR,
 
    BLEND_FACTOR_SRC1_ALPHA,
 
    BLEND_FACTOR_INV_SRC1_ALPHA,
 
    BLEND_FACTOR_NUM_FACTORS
};
 
 
 
DILIGENT_TYPED_ENUM(BLEND_OPERATION, Int8)
{
    BLEND_OPERATION_UNDEFINED = 0,
 
    BLEND_OPERATION_ADD,
 
    BLEND_OPERATION_SUBTRACT,
 
    BLEND_OPERATION_REV_SUBTRACT,
 
    BLEND_OPERATION_MIN,
 
    BLEND_OPERATION_MAX,
 
    BLEND_OPERATION_NUM_OPERATIONS
};
 
 
 
DILIGENT_TYPED_ENUM(COLOR_MASK, Int8)
{
    COLOR_MASK_NONE  = 0,
 
    COLOR_MASK_RED   = 1,
 
    COLOR_MASK_GREEN = 2,
 
    COLOR_MASK_BLUE  = 4,
 
    COLOR_MASK_ALPHA = 8,
 
    COLOR_MASK_ALL   = (((COLOR_MASK_RED | COLOR_MASK_GREEN) | COLOR_MASK_BLUE) | COLOR_MASK_ALPHA)
};
 
 
 
DILIGENT_TYPED_ENUM(LOGIC_OPERATION, Int8)
{
    LOGIC_OP_CLEAR = 0,
 
    LOGIC_OP_SET,
 
    LOGIC_OP_COPY,
 
    LOGIC_OP_COPY_INVERTED,
 
    LOGIC_OP_NOOP,
 
    LOGIC_OP_INVERT,
 
    LOGIC_OP_AND,
 
    LOGIC_OP_NAND,
 
    LOGIC_OP_OR,
 
    LOGIC_OP_NOR,
 
    LOGIC_OP_XOR,
 
    LOGIC_OP_EQUIV,
 
    LOGIC_OP_AND_REVERSE,
 
    LOGIC_OP_AND_INVERTED,
 
    LOGIC_OP_OR_REVERSE,
 
    LOGIC_OP_OR_INVERTED,
 
    LOGIC_OP_NUM_OPERATIONS
};
 
 
 
struct RenderTargetBlendDesc
{
    Bool            BlendEnable           DEFAULT_INITIALIZER(False);
 
    Bool            LogicOperationEnable  DEFAULT_INITIALIZER(False);
 
    BLEND_FACTOR    SrcBlend              DEFAULT_INITIALIZER(BLEND_FACTOR_ONE);
 
    BLEND_FACTOR    DestBlend             DEFAULT_INITIALIZER(BLEND_FACTOR_ZERO);
 
    BLEND_OPERATION BlendOp               DEFAULT_INITIALIZER(BLEND_OPERATION_ADD);
 
    BLEND_FACTOR    SrcBlendAlpha         DEFAULT_INITIALIZER(BLEND_FACTOR_ONE);
 
    BLEND_FACTOR    DestBlendAlpha        DEFAULT_INITIALIZER(BLEND_FACTOR_ZERO);
 
    BLEND_OPERATION BlendOpAlpha          DEFAULT_INITIALIZER(BLEND_OPERATION_ADD);
 
    LOGIC_OPERATION LogicOp               DEFAULT_INITIALIZER(LOGIC_OP_NOOP);
 
    Uint8           RenderTargetWriteMask DEFAULT_INITIALIZER(COLOR_MASK_ALL);
 
#if DILIGENT_CPP_INTERFACE
 
    RenderTargetBlendDesc()noexcept{}
 
    explicit
    RenderTargetBlendDesc(Bool            _BlendEnable,
                          Bool            _LogicOperationEnable  = RenderTargetBlendDesc{}.LogicOperationEnable ,
                          BLEND_FACTOR    _SrcBlend              = RenderTargetBlendDesc{}.SrcBlend,
                          BLEND_FACTOR    _DestBlend             = RenderTargetBlendDesc{}.DestBlend,
                          BLEND_OPERATION _BlendOp               = RenderTargetBlendDesc{}.BlendOp,
                          BLEND_FACTOR    _SrcBlendAlpha         = RenderTargetBlendDesc{}.SrcBlendAlpha,
                          BLEND_FACTOR    _DestBlendAlpha        = RenderTargetBlendDesc{}.DestBlendAlpha,
                          BLEND_OPERATION _BlendOpAlpha          = RenderTargetBlendDesc{}.BlendOpAlpha,
                          LOGIC_OPERATION _LogicOp               = RenderTargetBlendDesc{}.LogicOp,
                          Uint8           _RenderTargetWriteMask = RenderTargetBlendDesc{}.RenderTargetWriteMask) :
        BlendEnable          {_BlendEnable          },
        LogicOperationEnable {_LogicOperationEnable },
        SrcBlend             {_SrcBlend             },
        DestBlend            {_DestBlend            },
        BlendOp              {_BlendOp              },
        SrcBlendAlpha        {_SrcBlendAlpha        },
        DestBlendAlpha       {_DestBlendAlpha       },
        BlendOpAlpha         {_BlendOpAlpha         },
        LogicOp              {_LogicOp              },
        RenderTargetWriteMask{_RenderTargetWriteMask}
    {}
 
 
    bool operator == (const RenderTargetBlendDesc& rhs)const
    {
        return BlendEnable           == rhs.BlendEnable    &&
               LogicOperationEnable  == rhs.LogicOperationEnable &&
               SrcBlend              == rhs.SrcBlend       &&
               DestBlend             == rhs.DestBlend      &&
               BlendOp               == rhs.BlendOp        &&
               SrcBlendAlpha         == rhs.SrcBlendAlpha  &&
               DestBlendAlpha        == rhs.DestBlendAlpha &&
               BlendOpAlpha          == rhs.BlendOpAlpha   &&
               LogicOp               == rhs.LogicOp        &&
               RenderTargetWriteMask == rhs.RenderTargetWriteMask;
    }
#endif
};
typedef struct RenderTargetBlendDesc RenderTargetBlendDesc;
 
 
 
struct BlendStateDesc
{
    Bool AlphaToCoverageEnable DEFAULT_INITIALIZER(False);
 
    Bool IndependentBlendEnable DEFAULT_INITIALIZER(False);
 
    RenderTargetBlendDesc RenderTargets[DILIGENT_MAX_RENDER_TARGETS];
 
#if DILIGENT_CPP_INTERFACE
    // We have to explicitly define constructors because otherwise Apple's clang fails to compile the following legitimate code:
    //     BlendStateDesc{False, False}
 
    BlendStateDesc() noexcept {}
 
    BlendStateDesc(Bool                         _AlphaToCoverageEnable,
                   Bool                         _IndependentBlendEnable,
                   const RenderTargetBlendDesc& RT0 = RenderTargetBlendDesc{}) noexcept :
        AlphaToCoverageEnable   {_AlphaToCoverageEnable },
        IndependentBlendEnable  {_IndependentBlendEnable},
        RenderTargets           {RT0}
    {
    }
 
 
    bool operator==(const BlendStateDesc& RHS) const
    {
        bool bRTsEqual = true;
        for (size_t i = 0; i < MAX_RENDER_TARGETS; ++i)
        {
            if (!(RenderTargets[i] == RHS.RenderTargets[i]))
            {
                bRTsEqual = false;
                break;
            }
        }
 
        return bRTsEqual &&
            AlphaToCoverageEnable == RHS.AlphaToCoverageEnable &&
            IndependentBlendEnable == RHS.IndependentBlendEnable;
    }
#endif
};
typedef struct BlendStateDesc BlendStateDesc;
 
DILIGENT_END_NAMESPACE // namespace Diligent