source/texture.h

   1 #ifndef MSP_GL_TEXTURE_H_
   2 #define MSP_GL_TEXTURE_H_
   3
   4 #include <msp/datafile/objectloader.h>
   5 #include <msp/graphics/image.h>
   6 #include "datatype.h"
   7 #include "gl.h"
   8 #include "pixelformat.h"
   9 #include "predicate.h"
  10 #include "resource.h"
  11
  12 namespace Msp {
  13 namespace GL {
  14
  15 enum TextureFilter
  16 {
  17         /// No filtering
  18         NEAREST = GL_NEAREST,
  19
  20         /// Bilinear filtering
  21         LINEAR = GL_LINEAR,
  22
  23         /// Mipmapping without filtering
  24         NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST,
  25
  26         /// Linear filtering between two mipmap levels
  27         NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR,
  28
  29         /// Bilinear filtering on the closest mipmap level
  30         LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
  31
  32         /// Trilinear filtering between two mipmap levels
  33         LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
  34 };
  35
  36
  37 enum TextureWrap
  38 {
  39         /// Tile the texture infinitely
  40         REPEAT = GL_REPEAT,
  41
  42         /// Extend the texels at the edge of the texture to infinity
  43         CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,
  44
  45         /// Tile the texture, with every other repetition mirrored
  46         MIRRORED_REPEAT = GL_MIRRORED_REPEAT
  47 };
  48
  49
  50 /**
  51 Base class for textures.  This class only defines operations common for all
  52 texture types and is not instantiable.  For specifying images for textures, see
  53 one of the dimensioned texture classes.
  54
  55 A texture is generally rendered at a size that's either smaller or larger than
  56 its native size, so that the texture coordinates do not exactly correspond to
  57 the texels of the texture.  The kind of filtering used, if any, is determined
  58 by the minification and magnification filter parameters.  The default is LINEAR
  59 for magnification and NEAREST_MIPMAP_LINEAR for minification.
  60
  61 When a mipmapped filter is in use, the texture consists of a stack of mipmap
  62 images.  Level 0 is the base image.  Each level above 0 has half the size of
  63 the previous level, rounded down and clamped to 1.  The level with size 1 in
  64 all dimensions is the last mipmap level.  All levels must be allocated for the
  65 texture to be usable.
  66
  67 If texture coordinates fall outside of the principal range of the texture,
  68 wrapping is applied.  The default for all directions is REPEAT.
  69 */
  70 class Texture: public Resource
  71 {
  72 protected:
  73         class Loader: public DataFile::CollectionObjectLoader<Texture>
  74         {
  75         protected:
  76                 bool srgb;
  77
  78         public:
  79                 Loader(Texture &);
  80                 Loader(Texture &, Collection &);
  81         private:
  82                 void init();
  83
  84                 void external_image(const std::string &);
  85                 void filter(TextureFilter);
  86                 void generate_mipmap(bool);
  87                 void image_data(const std::string &);
  88                 void mag_filter(TextureFilter);
  89                 void max_anisotropy(float);
  90                 void min_filter(TextureFilter);
  91                 void wrap(TextureWrap);
  92                 void wrap_r(TextureWrap);
  93                 void wrap_s(TextureWrap);
  94                 void wrap_t(TextureWrap);
  95         };
  96
  97         enum ParameterMask
  98         {
  99                 MIN_FILTER = 1,
 100                 MAG_FILTER = 2,
 101                 WRAP_S = 4,
 102                 WRAP_T = 8,
 103                 WRAP_R = 16,
 104                 GENERATE_MIPMAP = 32,
 105                 COMPARE = 64,
 106                 COMPARE_FUNC = 128,
 107                 MAX_ANISOTROPY = 256
 108         };
 109
 110         unsigned id;
 111         GLenum target;
 112         TextureFilter min_filter;
 113         TextureFilter mag_filter;
 114         float max_anisotropy;
 115         TextureWrap wrap_s;
 116         TextureWrap wrap_t;
 117         TextureWrap wrap_r;
 118         bool gen_mipmap;
 119         bool compare;
 120         Predicate cmp_func;
 121         mutable int dirty_params;
 122
 123         Texture(GLenum, ResourceManager * = 0);
 124         Texture(const Texture &);
 125         Texture &operator=(const Texture &);
 126 public:
 127         ~Texture();
 128
 129 protected:
 130         static DataType get_alloc_type(PixelFormat);
 131
 132         void update_parameter(int) const;
 133         void set_parameter_i(GLenum, int) const;
 134         void set_parameter_f(GLenum, float) const;
 135 public:
 136         void set_min_filter(TextureFilter);
 137         void set_mag_filter(TextureFilter);
 138
 139         /** Sets filter for both minification and magnification.  Since mipmapping
 140         is not applicable to magnification, LINEAR is used instead. */
 141         void set_filter(TextureFilter);
 142
 143         void set_max_anisotropy(float);
 144
 145         /** Sets the wrapping mode for all coordinates. */
 146         void set_wrap(TextureWrap);
 147
 148         void set_wrap_s(TextureWrap);
 149         void set_wrap_t(TextureWrap);
 150         void set_wrap_r(TextureWrap);
 151
 152         /** Sets automatic mipmap generation.  If enabled, mipmaps are generated
 153         when a texture image is uploaded. */
 154         void set_generate_mipmap(bool);
 155
 156 protected:
 157         void auto_generate_mipmap();
 158
 159 public:
 160         /** Sets depth texture comparison.  Has no effect on other formats.  When
 161         comparison is enabled, the third component of the texture coordinate is
 162         compared against the texel value, and the result is returned as the texture
 163         sample. */
 164         void set_compare_enabled(bool);
 165
 166         /** Sets the function to use for depth comparison. */
 167         void set_compare_func(Predicate);
 168
 169         /// Loads a Graphics::Image from a file and uploads it to the texture.
 170         virtual void load_image(const std::string &, bool srgb = false);
 171
 172         /** Uploads an image to the texture.  If storage has not been defined, it
 173         will be set to match the image.  Otherwise the image must be compatible
 174         with the defined storage.  Semantics depend on the type of texture.
 175
 176         If srgb is true and storage is determined by this call, then an sRGB pixel
 177         format will be used. */
 178         virtual void image(const Graphics::Image &, bool srgb = false) = 0;
 179
 180         GLenum get_target() const { return target; }
 181         unsigned get_id() const { return id; }
 182
 183         void bind() const { bind_to(0); }
 184         void bind_to(unsigned) const;
 185
 186         static const Texture *current(unsigned = 0);
 187         static void unbind() { unbind_from(0); }
 188         static void unbind_from(unsigned);
 189
 190         virtual UInt64 get_data_size() const { return 0; }
 191 };
 192
 193
 194 bool is_mipmapped(TextureFilter);
 195
 196 } // namespace GL
 197 } // namespace Msp
 198
 199 #endif