source/core/sampler.h

   1 #ifndef MSP_GL_SAMPLER_H_
   2 #define MSP_GL_SAMPLER_H_
   3
   4 #include <msp/datafile/objectloader.h>
   5 #include "color.h"
   6 #include "gl.h"
   7 #include "predicate.h"
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 enum TextureFilter
  13 {
  14         /// No filtering
  15         NEAREST = GL_NEAREST,
  16
  17         /// Bilinear filtering
  18         LINEAR = GL_LINEAR,
  19
  20         /// Mipmapping without filtering
  21         NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST,
  22
  23         /// Linear filtering between two mipmap levels
  24         NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR,
  25
  26         /// Bilinear filtering on the closest mipmap level
  27         LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
  28
  29         /// Trilinear filtering between two mipmap levels
  30         LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
  31 };
  32
  33
  34 enum TextureWrap
  35 {
  36         /// Tile the texture infinitely
  37         REPEAT = GL_REPEAT,
  38
  39         /// Extend the texels at the edge of the texture to infinity
  40         CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,
  41
  42         /// Sampling outside the texture will return border color
  43         CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER,
  44
  45         /// Tile the texture, with every other repetition mirrored
  46         MIRRORED_REPEAT = GL_MIRRORED_REPEAT
  47 };
  48
  49 class Texture;
  50
  51
  52 /**
  53 Samplers are used to access texture data in shaders.  To use a sampler with a
  54 texture, bind it to the same texture unit.  Each texture has a default sampler
  55 which is used if no external sampler is bound.
  56
  57 A texture is generally rendered at a size that's either smaller or larger than
  58 its native size, so that the texture coordinates do not exactly correspond to
  59 the texels of the texture.  The kind of filtering used, if any, is determined
  60 by the minification and magnification filter parameters.  The default is LINEAR
  61 for magnification and NEAREST_MIPMAP_LINEAR for minification.
  62
  63 If texture coordinates fall outside of the principal range of the texture,
  64 wrapping is applied.  The default for all directions is REPEAT.
  65 */
  66 class Sampler
  67 {
  68 public:
  69         class Loader: public DataFile::ObjectLoader<Sampler>
  70         {
  71         public:
  72                 Loader(Sampler &);
  73         private:
  74                 void init();
  75
  76                 void border_color(float, float, float, float);
  77                 void compare(Predicate);
  78                 void filter(TextureFilter);
  79                 void mag_filter(TextureFilter);
  80                 void max_anisotropy(float);
  81                 void min_filter(TextureFilter);
  82                 void wrap(TextureWrap);
  83                 void wrap_r(TextureWrap);
  84                 void wrap_s(TextureWrap);
  85                 void wrap_t(TextureWrap);
  86         };
  87
  88 private:
  89         enum ParameterMask
  90         {
  91                 MIN_FILTER = 1,
  92                 MAG_FILTER = 2,
  93                 MAX_ANISOTROPY = 4,
  94                 WRAP_S = 8,
  95                 WRAP_T = 16,
  96                 WRAP_R = 32,
  97                 BORDER_COLOR = 64,
  98                 COMPARE = 128
  99         };
 100
 101         unsigned id;
 102         TextureFilter min_filter;
 103         TextureFilter mag_filter;
 104         float max_anisotropy;
 105         TextureWrap wrap_s;
 106         TextureWrap wrap_t;
 107         TextureWrap wrap_r;
 108         Color border_color;
 109         bool compare;
 110         Predicate cmp_func;
 111         mutable int dirty_params;
 112
 113 public:
 114         Sampler();
 115
 116 private:
 117         void update_parameter(int) const;
 118         void set_parameter_i(unsigned, int) const;
 119         void set_parameter_f(unsigned, float) const;
 120         void set_parameter_fv(unsigned, const float *) const;
 121
 122 public:
 123         void set_min_filter(TextureFilter);
 124         void set_mag_filter(TextureFilter);
 125
 126         /** Sets filter for both minification and magnification.  If a mipmapping
 127         filter is specified, LINEAR is used for magnification. */
 128         void set_filter(TextureFilter);
 129
 130         TextureFilter get_min_filter() const { return min_filter; }
 131         TextureFilter get_mag_filter() const { return mag_filter; }
 132
 133         void set_max_anisotropy(float);
 134         float get_max_anisotropy() const { return max_anisotropy; }
 135
 136         /** Sets the wrapping mode for all coordinates. */
 137         void set_wrap(TextureWrap);
 138
 139         void set_wrap_s(TextureWrap);
 140         void set_wrap_t(TextureWrap);
 141         void set_wrap_r(TextureWrap);
 142
 143         void set_border_color(const Color &);
 144         const Color &get_border_color() const { return border_color; }
 145
 146         /** Disables depth comparison. */
 147         void disable_compare();
 148
 149         /** Enables depth comparison and sets the compare function.  Only has an
 150         effect when used with a depth texture.  When depth comparison is enabled,
 151         the third component of the texture coordinate is compared against the texel
 152         value, and the result is returned as the texture sample.*/
 153         void set_compare(Predicate);
 154
 155         bool is_compare_enabled() const { return compare; }
 156         Predicate get_compare_function() const { return cmp_func; }
 157
 158         void bind() const { bind_to(0); }
 159         void bind_to(unsigned) const;
 160
 161         static const Sampler *current(unsigned = 0);
 162         static void unbind() { unbind_from(0); }
 163         static void unbind_from(unsigned);
 164
 165         void set_debug_name(const std::string &);
 166 };
 167
 168
 169 bool is_mipmapped(TextureFilter);
 170
 171 void operator>>(const LexicalConverter &, TextureFilter &);
 172 void operator>>(const LexicalConverter &, TextureWrap &);
 173
 174 } // namespace GL
 175 } // namespace Msp
 176
 177 #endif