source/texture.h

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