sampler.h

Go to the documentation of this file.

#ifndef ION_GFX_SAMPLER_H_
#define ION_GFX_SAMPLER_H_

#include "ion/base/referent.h"
#include "ion/gfx/resourceholder.h"

namespace ion {
namespace gfx {

class ION_API Sampler : public ResourceHolder {
 public:
  enum Changes {
    kAutoMipmappingChanged = kNumBaseChanges,
    kCompareFunctionChanged,
    kCompareModeChanged,
    kMagFilterChanged,
    kMaxAnisotropyChanged,
    kMaxLodChanged,
    kMinFilterChanged,
    kMinLodChanged,
    kWrapRChanged,
    kWrapSChanged,
    kWrapTChanged,
    kNumChanges
  };

  enum CompareFunction {
    kAlways,
    kEqual,
    kGreater,
    kGreaterOrEqual,
    kLess,
    kLessOrEqual,
    kNever,
    kNotEqual
  };

  enum CompareMode {
    kCompareToTexture,
    kNone
  };

  enum FilterMode {
    kNearest,
    kLinear,
    kNearestMipmapNearest,
    kNearestMipmapLinear,
    kLinearMipmapNearest,
    kLinearMipmapLinear
  };

  enum WrapMode {
    kClampToEdge,
    kRepeat,
    kMirroredRepeat
  };

  Sampler();

  void SetAutogenerateMipmapsEnabled(bool enable) {
    auto_mipmapping_enabled_.Set(enable);
  }
  bool IsAutogenerateMipmapsEnabled() const {
    return auto_mipmapping_enabled_.Get();
  }

  void SetCompareMode(CompareMode mode) {
    compare_mode_.Set(mode);
  }
  CompareMode GetCompareMode() const { return compare_mode_.Get(); }

  void SetCompareFunction(CompareFunction func) {
    compare_function_.Set(func);
  }
  CompareFunction GetCompareFunction() const { return compare_function_.Get(); }

  void SetMaxAnisotropy(float aniso) {
    max_anisotropy_.Set(aniso);
  }
  float GetMaxAnisotropy() const { return max_anisotropy_.Get(); }

  void SetMinFilter(const FilterMode& mode) {
    min_filter_.Set(mode);
  }
  FilterMode GetMinFilter() const { return min_filter_.Get(); }

  void SetMagFilter(const FilterMode& mode) {
    mag_filter_.Set(mode);
  }
  FilterMode GetMagFilter() const { return mag_filter_.Get(); }

  void SetMinLod(float lod) {
    min_lod_.Set(lod);
  }
  float GetMinLod() const { return min_lod_.Get(); }

  void SetMaxLod(float lod) {
    max_lod_.Set(lod);
  }
  float GetMaxLod() const { return max_lod_.Get(); }

  void SetWrapR(const WrapMode& mode) {
    wrap_r_.Set(mode);
  }
  WrapMode GetWrapR() const { return wrap_r_.Get(); }

  void SetWrapS(const WrapMode& mode) {
    wrap_s_.Set(mode);
  }
  WrapMode GetWrapS() const { return wrap_s_.Get(); }

  void SetWrapT(const WrapMode& mode) {
    wrap_t_.Set(mode);
  }
  WrapMode GetWrapT() const { return wrap_t_.Get(); }

 protected:
  ~Sampler() override;

 private:
  Field<bool> auto_mipmapping_enabled_;
  RangedField<float> max_anisotropy_;
  Field<float> min_lod_;
  Field<float> max_lod_;
  RangedField<CompareFunction> compare_function_;
  RangedField<CompareMode> compare_mode_;
  RangedField<FilterMode> min_filter_;
  RangedField<FilterMode> mag_filter_;
  RangedField<WrapMode> wrap_r_;
  RangedField<WrapMode> wrap_s_;
  RangedField<WrapMode> wrap_t_;
};

typedef base::ReferentPtr<Sampler>::Type SamplerPtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_SAMPLER_H_