]> git.tdb.fi Git - libs/gl.git/blob - source/texture.h
1b80e950f08d93e54debd3bdc8b14ae4c7f458ac
[libs/gl.git] / 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         PixelFormat ifmt;
113         TextureFilter min_filter;
114         TextureFilter mag_filter;
115         float max_anisotropy;
116         TextureWrap wrap_s;
117         TextureWrap wrap_t;
118         TextureWrap wrap_r;
119         bool gen_mipmap;
120         bool compare;
121         Predicate cmp_func;
122         mutable int dirty_params;
123
124         Texture(GLenum, ResourceManager * = 0);
125         Texture(const Texture &);
126         Texture &operator=(const Texture &);
127 public:
128         ~Texture();
129
130 protected:
131         static DataType get_alloc_type(PixelFormat);
132         void set_internal_format(PixelFormat);
133
134         void update_parameter(int) const;
135         void set_parameter_i(GLenum, int) const;
136         void set_parameter_f(GLenum, float) const;
137 public:
138         void set_min_filter(TextureFilter);
139         void set_mag_filter(TextureFilter);
140
141         /** Sets filter for both minification and magnification.  Since mipmapping
142         is not applicable to magnification, LINEAR is used instead. */
143         void set_filter(TextureFilter);
144
145         void set_max_anisotropy(float);
146
147         /** Sets the wrapping mode for all coordinates. */
148         void set_wrap(TextureWrap);
149
150         void set_wrap_s(TextureWrap);
151         void set_wrap_t(TextureWrap);
152         void set_wrap_r(TextureWrap);
153
154         /** Sets automatic mipmap generation.  If enabled, mipmaps are generated
155         when a texture image is uploaded. */
156         void set_generate_mipmap(bool);
157
158 protected:
159         void auto_generate_mipmap();
160
161 public:
162         /** Sets depth texture comparison.  Has no effect on other formats.  When
163         comparison is enabled, the third component of the texture coordinate is
164         compared against the texel value, and the result is returned as the texture
165         sample. */
166         void set_compare_enabled(bool);
167
168         /** Sets the function to use for depth comparison. */
169         void set_compare_func(Predicate);
170
171         /// Loads a Graphics::Image from a file and uploads it to the texture.
172         virtual void load_image(const std::string &, bool srgb = false);
173
174         /** Uploads an image to the texture.  If storage has not been defined, it
175         will be set to match the image.  Otherwise the image must be compatible
176         with the defined storage.  Semantics depend on the type of texture.
177
178         If srgb is true and storage is determined by this call, then an sRGB pixel
179         format will be used. */
180         virtual void image(const Graphics::Image &, bool srgb = false) = 0;
181
182         GLenum get_target() const { return target; }
183         unsigned get_id() const { return id; }
184
185         void bind() const { bind_to(0); }
186         void bind_to(unsigned) const;
187
188         static const Texture *current(unsigned = 0);
189         static void unbind() { unbind_from(0); }
190         static void unbind_from(unsigned);
191
192         virtual UInt64 get_data_size() const { return 0; }
193 };
194
195
196 bool is_mipmapped(TextureFilter);
197
198 } // namespace GL
199 } // namespace Msp
200
201 #endif