Sampler.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
 
 
#include "DeviceObject.h"
 
DILIGENT_BEGIN_NAMESPACE(Diligent)
 
 
// {595A59BF-FA81-4855-BC5E-C0E048745A95}
static const INTERFACE_ID IID_Sampler =
    {0x595a59bf, 0xfa81, 0x4855, {0xbc, 0x5e, 0xc0, 0xe0, 0x48, 0x74, 0x5a, 0x95}};
 
 
// clang-format off
 
 
struct SamplerDesc DILIGENT_DERIVE(DeviceObjectAttribs)
 
    FILTER_TYPE MinFilter           DEFAULT_INITIALIZER(FILTER_TYPE_LINEAR);
    
    FILTER_TYPE MagFilter           DEFAULT_INITIALIZER(FILTER_TYPE_LINEAR);
 
    FILTER_TYPE MipFilter           DEFAULT_INITIALIZER(FILTER_TYPE_LINEAR);
 
    TEXTURE_ADDRESS_MODE AddressU   DEFAULT_INITIALIZER(TEXTURE_ADDRESS_CLAMP);
    
    TEXTURE_ADDRESS_MODE AddressV   DEFAULT_INITIALIZER(TEXTURE_ADDRESS_CLAMP);
 
    TEXTURE_ADDRESS_MODE AddressW   DEFAULT_INITIALIZER(TEXTURE_ADDRESS_CLAMP);
 
    Float32 MipLODBias                  DEFAULT_INITIALIZER(0);
 
    Uint32 MaxAnisotropy                DEFAULT_INITIALIZER(0);
 
    COMPARISON_FUNCTION ComparisonFunc  DEFAULT_INITIALIZER(COMPARISON_FUNC_NEVER);
 
    Float32 BorderColor[4]              DEFAULT_INITIALIZER({});
 
    float MinLOD                        DEFAULT_INITIALIZER(0);
 
    float MaxLOD                        DEFAULT_INITIALIZER(+3.402823466e+38F);
 
 
#if DILIGENT_CPP_INTERFACE
    SamplerDesc()noexcept{}
     
    SamplerDesc(FILTER_TYPE          _MinFilter,
                FILTER_TYPE          _MagFilter,
                FILTER_TYPE          _MipFilter,
                TEXTURE_ADDRESS_MODE _AddressU       = SamplerDesc{}.AddressU,
                TEXTURE_ADDRESS_MODE _AddressV       = SamplerDesc{}.AddressV,
                TEXTURE_ADDRESS_MODE _AddressW       = SamplerDesc{}.AddressW,
                Float32              _MipLODBias     = SamplerDesc{}.MipLODBias,
                Uint32               _MaxAnisotropy  = SamplerDesc{}.MaxAnisotropy,
                COMPARISON_FUNCTION  _ComparisonFunc = SamplerDesc{}.ComparisonFunc,
                float                _MinLOD         = SamplerDesc{}.MinLOD,
                float                _MaxLOD         = SamplerDesc{}.MaxLOD) : 
        MinFilter      {_MinFilter     },
        MagFilter      {_MagFilter     },
        MipFilter      {_MipFilter     },
        AddressU       {_AddressU      },
        AddressV       {_AddressV      },
        AddressW       {_AddressW      },
        MipLODBias     {_MipLODBias    },
        MaxAnisotropy  {_MaxAnisotropy },
        ComparisonFunc {_ComparisonFunc},
        MinLOD         {_MinLOD        },
        MaxLOD         {_MaxLOD        }
    {
        BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 0;
    }
 
    bool operator == (const SamplerDesc& RHS)const
    {
                // Name is primarily used for debug purposes and does not affect the state.
                // It is ignored in comparison operation.
        return  // strcmp(Name, RHS.Name) == 0          &&
                MinFilter       == RHS.MinFilter      &&
                MagFilter       == RHS.MagFilter      && 
                MipFilter       == RHS.MipFilter      && 
                AddressU        == RHS.AddressU       && 
                AddressV        == RHS.AddressV       && 
                AddressW        == RHS.AddressW       && 
                MipLODBias      == RHS.MipLODBias     && 
                MaxAnisotropy   == RHS.MaxAnisotropy  && 
                ComparisonFunc  == RHS.ComparisonFunc && 
                BorderColor[0]  == RHS.BorderColor[0] && 
                BorderColor[1]  == RHS.BorderColor[1] &&
                BorderColor[2]  == RHS.BorderColor[2] &&
                BorderColor[3]  == RHS.BorderColor[3] &&
                MinLOD          == RHS.MinLOD         && 
                MaxLOD          == RHS.MaxLOD;
    }
#endif
};
typedef struct SamplerDesc SamplerDesc;
 
#define DILIGENT_INTERFACE_NAME ISampler
#include "../../../Primitives/interface/DefineInterfaceHelperMacros.h"
 
// clang-format off
#define ISamplerInclusiveMethods  \
    IDeviceObjectInclusiveMethods \
    /*ISamplerMethods Sampler*/
// clang-format on
 
#if DILIGENT_CPP_INTERFACE
 
// clang-format off
 
 
DILIGENT_BEGIN_INTERFACE(ISampler, IDeviceObject)
{
#if DILIGENT_CPP_INTERFACE
    virtual const SamplerDesc& METHOD(GetDesc)() const override = 0;
#endif
};
DILIGENT_END_INTERFACE
 
#endif
 
 
#include "../../../Primitives/interface/UndefInterfaceHelperMacros.h"
 
#if DILIGENT_C_INTERFACE
 
typedef struct ISamplerVtbl
{
    ISamplerInclusiveMethods;
} ISamplerVtbl;
 
typedef struct ISampler
{
    struct ISamplerVtbl* pVtbl;
} ISampler;
 
#    define ISampler_GetDesc(This) (const struct SamplerDesc*)IDeviceObject_GetDesc(This)
 
#endif
 
DILIGENT_END_NAMESPACE // namespace Diligent