X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Ftexture.h;h=9c43b76911ecb5d00fcf517847f6a04001ed6241;hp=cccf35b038a461e5d3335dca0ca1d9b050d5f4c7;hb=eacacdda1dc40bb655a3df14b59260ce06329fb6;hpb=84bc56b96c21c831104a22e0cbd0f3b72ab5d8c3 diff --git a/source/texture.h b/source/texture.h index cccf35b0..9c43b769 100644 --- a/source/texture.h +++ b/source/texture.h @@ -1,56 +1,214 @@ #ifndef MSP_GL_TEXTURE_H_ #define MSP_GL_TEXTURE_H_ -#include -#include "types.h" +#include +#include +#include "datatype.h" +#include "gl.h" +#include "pixelformat.h" +#include "predicate.h" +#include "resource.h" namespace Msp { namespace GL { enum TextureFilter { - NEAREST = GL_NEAREST, - LINEAR = GL_LINEAR, + /// No filtering + NEAREST = GL_NEAREST, + + /// Bilinear filtering + LINEAR = GL_LINEAR, + + /// Mipmapping without filtering NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST, - NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR, - LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST, - LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR + + /// 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 TextureFormat + +enum TextureWrap { - LUMINANCE8, - LUMINANCE8_ALPHA8, - RGB8, - RGBA8, - BGR8, - BGRA8 + /// 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 }; -class Texture -{ -public: - ~Texture(); - void bind() const; - void parameter(GLenum, int); - void parameter(GLenum, float); - void set_min_filter(TextureFilter f) { parameter(GL_TEXTURE_MIN_FILTER, f); } - void set_mag_filter(TextureFilter f) { parameter(GL_TEXTURE_MAG_FILTER, f); } - GLenum get_target() const { return target; } - uint get_id() const { return id; } +/** +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. - static void unbind(); +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. +*/ +class Texture: public Resource +{ protected: - uint id; + class Loader: public DataFile::CollectionObjectLoader + { + protected: + bool srgb; + + public: + Loader(Texture &); + Loader(Texture &, Collection &); + private: + void init(); + + void external_image(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 wrap(TextureWrap); + void wrap_r(TextureWrap); + void wrap_s(TextureWrap); + void wrap_t(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, + MAX_ANISOTROPY = 256, + FORMAT_SWIZZLE = 512 + }; + + enum FormatSwizzle + { + NO_SWIZZLE, + R_TO_LUMINANCE, + RG_TO_LUMINANCE_ALPHA + }; + + unsigned id; GLenum target; + PixelFormat ifmt; + FormatSwizzle swizzle; + TextureFilter min_filter; + TextureFilter mag_filter; + float max_anisotropy; + TextureWrap wrap_s; + TextureWrap wrap_t; + TextureWrap wrap_r; + bool gen_mipmap; + bool compare; + Predicate cmp_func; + mutable int dirty_params; + + static int swizzle_orders[]; - Texture(); + Texture(GLenum, ResourceManager * = 0); Texture(const Texture &); Texture &operator=(const Texture &); - void maybe_bind() const; +public: + ~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_parameter_i(GLenum, int) const; + void set_parameter_f(GLenum, float) const; +public: + void set_min_filter(TextureFilter); + 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); + + void set_max_anisotropy(float); + + /** Sets the wrapping mode for all coordinates. */ + void set_wrap(TextureWrap); + + void set_wrap_s(TextureWrap); + void set_wrap_t(TextureWrap); + void set_wrap_r(TextureWrap); + + static bool can_generate_mipmap(); + + /** Sets automatic mipmap generation. If enabled, mipmaps are generated + when a texture image is uploaded. */ + void set_generate_mipmap(bool); + +protected: + void auto_generate_mipmap(); + +public: + /** 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); + + /** Sets the function to use for depth comparison. */ + 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); + + /** 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. + + 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; + + GLenum get_target() const { return target; } + unsigned get_id() const { return id; } + + void bind() const { bind_to(0); } + void bind_to(unsigned) const; + + 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; } }; + +bool is_mipmapped(TextureFilter); + } // namespace GL } // namespace Msp