#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: public Resource
{
class Loader: public DataFile::CollectionObjectLoader<Texture>
{
protected:
- bool srgb;
+ unsigned levels;
public:
Loader(Texture &);
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 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,
- COMPARE = 64,
- COMPARE_FUNC = 128,
- MAX_ANISOTROPY = 256,
- FORMAT_SWIZZLE = 512,
- MIPMAP_LEVELS = 1024
+ FORMAT_SWIZZLE = 512
};
enum FormatSwizzle
{
NO_SWIZZLE,
R_TO_LUMINANCE,
- RG_TO_LUMINANCE_ALPHA
+ RG_TO_LUMINANCE_ALPHA,
+ RGB_TO_BGR
};
unsigned id;
GLenum target;
- PixelFormat ifmt;
+ PixelFormat format;
+ PixelFormat storage_fmt;
FormatSwizzle swizzle;
- TextureFilter min_filter;
- TextureFilter mag_filter;
- unsigned mipmap_levels;
- float max_anisotropy;
- TextureWrap wrap_s;
- TextureWrap wrap_t;
- TextureWrap wrap_r;
+ bool use_srgb_format;
bool auto_gen_mipmap;
- bool compare;
- Predicate cmp_func;
- mutable int dirty_params;
+ Sampler default_sampler;
static int swizzle_orders[];
~Texture();
protected:
- static DataType get_alloc_type(PixelFormat);
- void set_internal_format(PixelFormat);
- PixelFormat get_upload_format(PixelFormat) const;
-
- void update_parameter(int) const;
+ void set_format(PixelFormat);
+ void apply_swizzle();
void set_parameter_i(GLenum, int) const;
- void set_parameter_f(GLenum, float) 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. */
- void set_filter(TextureFilter);
+ DEPRECATED void set_filter(TextureFilter);
- void set_mipmap_levels(unsigned);
+ DEPRECATED void set_mipmap_levels(unsigned) { }
- void set_max_anisotropy(float);
+ 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();
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 &, bool srgb = false);
+ 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.
+ with the defined storage. Semantics depend on the type of texture. */
+ virtual void image(const Graphics::Image &, unsigned = 0) = 0;
- If srgb is true and storage is determined by this call, then an sRGB pixel
- format will be used. */
- virtual void image(const Graphics::Image &, bool srgb = false) = 0;
+ DEPRECATED void image(const Graphics::Image &, bool srgb);
GLenum get_target() const { return target; }
unsigned get_id() const { return id; }
virtual UInt64 get_data_size() const { return 0; }
};
-
-bool is_mipmapped(TextureFilter);
-
} // namespace GL
} // namespace Msp
projects / libs / gl.git / blobdiff