#ifndef MSP_GL_TEXTURE_H_
#define MSP_GL_TEXTURE_H_
+#include <msp/core/attributes.h>
#include <msp/datafile/objectloader.h>
+#include <msp/graphics/image.h>
+#include "datatype.h"
#include "gl.h"
+#include "pixelformat.h"
#include "predicate.h"
+#include "sampler.h"
+#include "resource.h"
namespace Msp {
namespace GL {
-enum TextureFilter
-{
- /// No filtering
- NEAREST = GL_NEAREST,
-
- /// Bilinear filtering
- LINEAR = GL_LINEAR,
-
- /// Mipmapping without filtering
- NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST,
-
- /// Linear filtering between two mipmap levels
- NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR,
-
- /// Bilinear filtering on the closest mipmap level
- LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
-
- /// Trilinear filtering between two mipmap levels
- LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR
-};
-
-
-enum TextureWrap
-{
- /// Tile the texture infinitely
- REPEAT = GL_REPEAT,
-
- /// Extend the texels at the edge of the texture to infinity
- CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,
-
- /// Tile the texture, with every other repetition mirrored
- MIRRORED_REPEAT = GL_MIRRORED_REPEAT
-};
-
-
/**
Base class for textures. This class only defines operations common for all
-texture types and is not instantiable. For specifying images for textures, see
-one of the dimensioned texture classes.
-
-A texture is generally rendered at a size that's either smaller or larger than
-its native size, so that the texture coordinates do not exactly correspond to
-the texels of the texture. The kind of filtering used, if any, is determined
-by the minification and magnification filter parameters. The default is LINEAR
-for magnification and NEAREST_MIPMAP_LINEAR for minification.
-
-When a mipmapped filter is in use, the texture consists of a stack of mipmap
-images. Level 0 is the base image. Each level above 0 has half the size of
-the previous level, rounded down and clamped to 1. The level with size 1 in
-all dimensions is the last mipmap level. All levels must be allocated for the
-texture to be usable.
-
-If texture coordinates fall outside of the principal range of the texture,
-wrapping is applied. The default for all directions is REPEAT.
+texture types and is not instantiable. For specifying images for textures,
+see one of the dimensioned texture classes.
+
+A texture can consinst of a stack of images, called a mipmap. The dimensions
+of each mipmap level are half that of the previous level. The mipmap stack
+can be used for texture minification; see the Sampler class for details.
*/
-class Texture
+class Texture: public Resource
{
protected:
- class Loader: public DataFile::ObjectLoader<Texture>
+ class Loader: public DataFile::CollectionObjectLoader<Texture>
{
+ protected:
+ unsigned levels;
+
public:
Loader(Texture &);
+ Loader(Texture &, Collection &);
+ private:
+ void init();
+
+ unsigned get_levels() const;
+ protected:
+ void load_external_image(Graphics::Image &, const std::string &);
+
+ private:
+ void external_image(const std::string &);
+ void external_image_srgb(const std::string &);
+ void external_image_common(const std::string &);
+ void filter(TextureFilter);
void generate_mipmap(bool);
+ void image_data(const std::string &);
void mag_filter(TextureFilter);
+ void max_anisotropy(float);
void min_filter(TextureFilter);
+ void mipmap_levels(unsigned);
+ void sampler();
void wrap(TextureWrap);
void wrap_r(TextureWrap);
void wrap_s(TextureWrap);
enum ParameterMask
{
- MIN_FILTER = 1,
- MAG_FILTER = 2,
- WRAP_S = 4,
- WRAP_T = 8,
- WRAP_R = 16,
- GENERATE_MIPMAP = 32,
- COMPARE = 64,
- COMPARE_FUNC = 128
+ FORMAT_SWIZZLE = 512
+ };
+
+ enum FormatSwizzle
+ {
+ NO_SWIZZLE,
+ R_TO_LUMINANCE,
+ RG_TO_LUMINANCE_ALPHA,
+ RGB_TO_BGR
};
unsigned id;
GLenum target;
- TextureFilter min_filter;
- TextureFilter mag_filter;
- TextureWrap wrap_s;
- TextureWrap wrap_t;
- TextureWrap wrap_r;
- bool gen_mipmap;
- bool compare;
- Predicate cmp_func;
- mutable int dirty_params;
-
- Texture(GLenum);
+ PixelFormat format;
+ PixelFormat storage_fmt;
+ FormatSwizzle swizzle;
+ bool use_srgb_format;
+ bool auto_gen_mipmap;
+ Sampler default_sampler;
+
+ static int swizzle_orders[];
+
+ Texture(GLenum, ResourceManager * = 0);
Texture(const Texture &);
Texture &operator=(const Texture &);
public:
~Texture();
protected:
- void update_parameter(int) const;
+ void set_format(PixelFormat);
+ void apply_swizzle();
+ void set_parameter_i(GLenum, int) const;
+
public:
- void set_min_filter(TextureFilter);
- void set_mag_filter(TextureFilter);
+ Sampler &get_default_sampler() { return default_sampler; }
+ const Sampler &get_default_sampler() const { return default_sampler; }
+
+ DEPRECATED void set_min_filter(TextureFilter);
+ DEPRECATED void set_mag_filter(TextureFilter);
+
+ /** Sets filter for both minification and magnification. Since mipmapping
+ is not applicable to magnification, LINEAR is used instead. */
+ DEPRECATED void set_filter(TextureFilter);
+
+ DEPRECATED void set_mipmap_levels(unsigned) { }
+
+ DEPRECATED void set_max_anisotropy(float);
/** Sets the wrapping mode for all coordinates. */
- void set_wrap(TextureWrap);
+ DEPRECATED void set_wrap(TextureWrap);
- void set_wrap_s(TextureWrap);
- void set_wrap_t(TextureWrap);
- void set_wrap_r(TextureWrap);
+ DEPRECATED void set_wrap_s(TextureWrap);
+ DEPRECATED void set_wrap_t(TextureWrap);
+ DEPRECATED void set_wrap_r(TextureWrap);
+
+ static bool can_generate_mipmap();
+
+ void generate_mipmap();
/** Sets automatic mipmap generation. If enabled, mipmaps are generated
when a texture image is uploaded. */
- void set_generate_mipmap(bool);
+ void set_auto_generate_mipmap(bool);
+
+ /// Deprecated. Use set_auto_generate_mipmap instead.
+ DEPRECATED void set_generate_mipmap(bool g) { set_auto_generate_mipmap(g); }
/** Sets depth texture comparison. Has no effect on other formats. When
comparison is enabled, the third component of the texture coordinate is
compared against the texel value, and the result is returned as the texture
sample. */
- void set_compare_enabled(bool);
+ DEPRECATED void set_compare_enabled(bool);
/** Sets the function to use for depth comparison. */
- void set_compare_func(Predicate);
+ DEPRECATED void set_compare_func(Predicate);
+
+ /// Loads a Graphics::Image from a file and uploads it to the texture.
+ virtual void load_image(const std::string &, unsigned = 0);
+
+ DEPRECATED void load_image(const std::string &, bool srgb);
+
+ /** Uploads an image to the texture. If storage has not been defined, it
+ will be set to match the image. Otherwise the image must be compatible
+ with the defined storage. Semantics depend on the type of texture. */
+ virtual void image(const Graphics::Image &, unsigned = 0) = 0;
+
+ DEPRECATED void image(const Graphics::Image &, bool srgb);
GLenum get_target() const { return target; }
unsigned get_id() const { return id; }
- void bind() const;
+ void bind() const { bind_to(0); }
void bind_to(unsigned) const;
- static const Texture *current();
- static void unbind();
+ static const Texture *current(unsigned = 0);
+ static void unbind() { unbind_from(0); }
static void unbind_from(unsigned);
+
+ virtual UInt64 get_data_size() const { return 0; }
};
} // namespace GL
projects / libs / gl.git / blobdiff