Sampler.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 <cfloat>
#include "DeviceObject.h"

namespace Diligent
{

// {595A59BF-FA81-4855-BC5E-C0E048745A95}
static constexpr INTERFACE_ID IID_Sampler =
{ 0x595a59bf, 0xfa81, 0x4855, { 0xbc, 0x5e, 0xc0, 0xe0, 0x48, 0x74, 0x5a, 0x95 } };


struct SamplerDesc : DeviceObjectAttribs
{
    FILTER_TYPE MinFilter;
    
    FILTER_TYPE MagFilter;

    FILTER_TYPE MipFilter;

    TEXTURE_ADDRESS_MODE AddressU;
    
    TEXTURE_ADDRESS_MODE AddressV;

    TEXTURE_ADDRESS_MODE AddressW;

    Float32 MipLODBias;

    Uint32 MaxAnisotropy;

    COMPARISON_FUNCTION ComparisonFunc;

    Float32 BorderColor[4];

    float MinLOD;

    float MaxLOD;


    SamplerDesc(FILTER_TYPE          _MinFilter      = FILTER_TYPE_LINEAR,
                FILTER_TYPE          _MagFilter      = FILTER_TYPE_LINEAR,
                FILTER_TYPE          _MipFilter      = FILTER_TYPE_LINEAR,
                TEXTURE_ADDRESS_MODE _AddressU       = TEXTURE_ADDRESS_CLAMP,
                TEXTURE_ADDRESS_MODE _AddressV       = TEXTURE_ADDRESS_CLAMP,
                TEXTURE_ADDRESS_MODE _AddressW       = TEXTURE_ADDRESS_CLAMP,
                Float32              _MipLODBias     = 0,
                Uint32               _MaxAnisotropy  = 0,
                COMPARISON_FUNCTION  _ComparisonFunc = COMPARISON_FUNC_NEVER,
                float                _MinLOD         = 0,
                float                _MaxLOD         = +FLT_MAX) : 
        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;
    }

    SamplerDesc(const SamplerDesc&) = default;
    SamplerDesc(SamplerDesc&&) = default;
    SamplerDesc& operator = (const SamplerDesc&) = default;
    SamplerDesc& operator = (SamplerDesc&&) = default;


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


class ISampler : public IDeviceObject
{
public:
    virtual void QueryInterface( const Diligent::INTERFACE_ID &IID, IObject **ppInterface ) = 0;

    virtual const SamplerDesc& GetDesc()const = 0;
};

}