DepthStencilState.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 "GraphicsTypes.h"
 
DILIGENT_BEGIN_NAMESPACE(Diligent)
 
 
 
DILIGENT_TYPED_ENUM(STENCIL_OP, Int8)
{
    STENCIL_OP_UNDEFINED = 0,
 
    STENCIL_OP_KEEP      = 1,
 
    STENCIL_OP_ZERO      = 2,
 
    STENCIL_OP_REPLACE   = 3,
    
    STENCIL_OP_INCR_SAT  = 4,
 
    STENCIL_OP_DECR_SAT  = 5,
 
    STENCIL_OP_INVERT    = 6,
 
    STENCIL_OP_INCR_WRAP = 7,
 
    STENCIL_OP_DECR_WRAP = 8,
 
    STENCIL_OP_NUM_OPS
};
 
 
struct StencilOpDesc
{
    STENCIL_OP          StencilFailOp       DEFAULT_INITIALIZER(STENCIL_OP_KEEP);
 
    STENCIL_OP          StencilDepthFailOp  DEFAULT_INITIALIZER(STENCIL_OP_KEEP);
 
    STENCIL_OP          StencilPassOp       DEFAULT_INITIALIZER(STENCIL_OP_KEEP);
 
    COMPARISON_FUNCTION StencilFunc         DEFAULT_INITIALIZER(COMPARISON_FUNC_ALWAYS);
 
 
#if DILIGENT_CPP_INTERFACE
    // We have to explicitly define constructors because otherwise Apple's clang fails to compile the following legitimate code:
    //     StencilOpDesc{STENCIL_OP_KEEP, STENCIL_OP_KEEP, STENCIL_OP_KEEP, COMPARISON_FUNC_ALWAYS}
 
    StencilOpDesc()noexcept{}
 
    StencilOpDesc(STENCIL_OP          _StencilFailOp,
                  STENCIL_OP          _StencilDepthFailOp,
                  STENCIL_OP          _StencilPassOp,
                  COMPARISON_FUNCTION _StencilFunc)noexcept : 
        StencilFailOp      {_StencilFailOp     },
        StencilDepthFailOp {_StencilDepthFailOp},
        StencilPassOp      {_StencilPassOp     },
        StencilFunc        {_StencilFunc       }
    {}
 
 
    bool operator== (const StencilOpDesc& rhs) const
    {
        return StencilFailOp      == rhs.StencilFailOp      &&
               StencilDepthFailOp == rhs.StencilDepthFailOp &&
               StencilPassOp      == rhs.StencilPassOp      &&
               StencilFunc        == rhs.StencilFunc;
    }
#endif
};
typedef struct StencilOpDesc StencilOpDesc;
 
 
struct DepthStencilStateDesc
{
    Bool                DepthEnable         DEFAULT_INITIALIZER(True);
 
    Bool                DepthWriteEnable    DEFAULT_INITIALIZER(True);
 
    COMPARISON_FUNCTION DepthFunc           DEFAULT_INITIALIZER(COMPARISON_FUNC_LESS);
 
    Bool                StencilEnable       DEFAULT_INITIALIZER(False);
    
    Uint8               StencilReadMask     DEFAULT_INITIALIZER(0xFF);
    
    Uint8               StencilWriteMask    DEFAULT_INITIALIZER(0xFF);
 
    StencilOpDesc FrontFace;
 
    StencilOpDesc BackFace;
 
 
#if DILIGENT_CPP_INTERFACE
    // We have to explicitly define constructors because otherwise Apple's clang fails to compile the following legitimate code:
    //     DepthStencilStateDesc{False, False}
 
    DepthStencilStateDesc()noexcept{}
 
    DepthStencilStateDesc(Bool                _DepthEnable,
                          Bool                _DepthWriteEnable,
                          COMPARISON_FUNCTION _DepthFunc        = DepthStencilStateDesc{}.DepthFunc,
                          Bool                _StencilEnable    = DepthStencilStateDesc{}.StencilEnable,
                          Uint8               _StencilReadMask  = DepthStencilStateDesc{}.StencilReadMask,
                          Uint8               _StencilWriteMask = DepthStencilStateDesc{}.StencilWriteMask,
                          StencilOpDesc       _FrontFace        = StencilOpDesc{},
                          StencilOpDesc       _BackFace         = StencilOpDesc{})noexcept : 
        DepthEnable     {_DepthEnable     },
        DepthWriteEnable{_DepthWriteEnable},
        DepthFunc       {_DepthFunc       },
        StencilEnable   {_StencilEnable   },
        StencilReadMask {_StencilReadMask },
        StencilWriteMask{_StencilWriteMask},
        FrontFace       {_FrontFace       },
        BackFace        {_BackFace        }
    {}
 
 
    bool operator== (const DepthStencilStateDesc& rhs) const
    {
        return  DepthEnable      == rhs.DepthEnable      &&
                DepthWriteEnable == rhs.DepthWriteEnable &&
                DepthFunc        == rhs.DepthFunc        &&
                StencilEnable    == rhs.StencilEnable    &&
                StencilReadMask  == rhs.StencilReadMask  &&
                StencilWriteMask == rhs.StencilWriteMask &&
                FrontFace        == rhs.FrontFace        &&
                BackFace         == rhs.BackFace;     
    }
#endif
};
typedef struct DepthStencilStateDesc DepthStencilStateDesc;
 
DILIGENT_END_NAMESPACE