DepthStencilState.h

/*     Copyright 2015-2018 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
 * 
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF ANY PROPRIETARY RIGHTS.
 *
 *  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


#include "BasicTypes.h"

namespace Diligent
{


enum STENCIL_OP : Int32
{
    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;

    STENCIL_OP          StencilDepthFailOp;

    STENCIL_OP          StencilPassOp;

    COMPARISON_FUNCTION StencilFunc;


    StencilOpDesc() : 
        StencilFailOp     ( STENCIL_OP_KEEP ),
        StencilDepthFailOp( STENCIL_OP_KEEP ),
        StencilPassOp     ( STENCIL_OP_KEEP ),
        StencilFunc       ( COMPARISON_FUNC_ALWAYS )
    {}


    bool operator == (const StencilOpDesc& rhs)const
    {
        return StencilFailOp      == rhs.StencilFailOp      &&
               StencilDepthFailOp == rhs.StencilDepthFailOp &&
               StencilPassOp      == rhs.StencilPassOp      &&
               StencilFunc        == rhs.StencilFunc;
    }
};


struct DepthStencilStateDesc
{
    Bool                DepthEnable;

    Bool                DepthWriteEnable;

    COMPARISON_FUNCTION DepthFunc;

    Bool                StencilEnable;
    
    Uint8               StencilReadMask;
    
    Uint8               StencilWriteMask;

    StencilOpDesc      FrontFace;

    StencilOpDesc      BackFace;


    DepthStencilStateDesc(Bool                _DepthEnable      = True,
                          Bool                _DepthWriteEnable = True,
                          COMPARISON_FUNCTION _DepthFunc        = COMPARISON_FUNC_LESS,
                          Bool                _StencilEnable    = False,
                          Uint8               _StencilReadMask  = 0xFF,
                          Uint8               _StencilWriteMask = 0xFF) : 
        DepthEnable     ( _DepthEnable ),
        DepthWriteEnable( _DepthWriteEnable ),
        DepthFunc       ( _DepthFunc ),
        StencilEnable   ( _StencilEnable ),
        StencilReadMask ( _StencilReadMask ),
        StencilWriteMask( _StencilWriteMask )
    {}


    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;     
    }
};

}