SamplerState.h

#pragma once
 
namespace Cogs
{
  struct SamplerState
  {
    enum AddressMode
    {
      Clamp,
      Wrap,
      Mirror,
      Border,
      
      // Provided for size comparisons.
      AddressMode_Size,
    };
 
    enum FilterMode
    {
      MinMagMipPoint,
      MinMagMipLinear,
 
      ComparisonMinMagMipPoint,
      ComparisonMinMagMipLinear,
 
      // Provided for size comparisons.
      FilterMode_Size,
    };
 
    enum ComparisonFunction
    {
      Never,
      Less,
      Equal,
      LessEqual,
      Greater,
      NotEqual,
      GreaterEqual,
      Always,
 
      // Provided for size comparisons.
      ComparisonFunction_Size,
    };
 
    AddressMode addressModeS;
    AddressMode addressModeT;
    AddressMode addressModeW;
 
    FilterMode filter;
 
    ComparisonFunction comparisonFunction;
 
    unsigned int maxAnisotropy;
 
    float borderColor[4];
 
    static SamplerState & DefaultState() {
      static SamplerState samplerState = {
        Wrap,
        Wrap,
        Wrap,
        MinMagMipLinear,
        Never,
        1,
        { 0, 0, 0, 1 }
      };
 
      return samplerState;
    }
  };
}
 
namespace std
{
  template<>
  struct hash<Cogs::SamplerState>
  {
    std::size_t operator()(const Cogs::SamplerState & state) const
    {
      static std::hash<size_t> hashFunction;
 
      size_t result = hashFunction(static_cast<size_t>(state.addressModeS));
      result = result * 16777619 + hashFunction(static_cast<size_t>(state.addressModeT));
      result = result * 16777619 + hashFunction(static_cast<size_t>(state.addressModeW));
      result = result * 16777619 + hashFunction(static_cast<size_t>(state.filter));
      result = result * 16777619 + hashFunction(static_cast<size_t>(state.comparisonFunction));
      result = result * 16777619 + hashFunction(static_cast<size_t>(state.maxAnisotropy));
 
      return result;
    }
  };
 
  template<>
  struct equal_to<Cogs::SamplerState>
  {
    bool operator()(const Cogs::SamplerState & lhs, const Cogs::SamplerState & rhs) const
    {
      return lhs.addressModeS == rhs.addressModeS &&
        lhs.addressModeT == rhs.addressModeT &&
        lhs.addressModeW == rhs.addressModeW &&
        lhs.filter == rhs.filter &&
        lhs.comparisonFunction == rhs.comparisonFunction &&
        lhs.maxAnisotropy == rhs.maxAnisotropy;
    }
  };
}