X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fcore%2Ftexture.h;h=96b17b8910752e0f0f46f7466b2acf7d014e2746;hp=bca0d409b105d9177ea7a108efc498e25c180769;hb=HEAD;hpb=2e7f0e8b226fdeea3306e2e0eef22a8f200ae16b diff --git a/source/core/texture.h b/source/core/texture.h index bca0d409..96b17b89 100644 --- a/source/core/texture.h +++ b/source/core/texture.h @@ -1,30 +1,36 @@ #ifndef MSP_GL_TEXTURE_H_ #define MSP_GL_TEXTURE_H_ -#include +#include #include #include -#include "datatype.h" -#include "gl.h" #include "pixelformat.h" -#include "predicate.h" -#include "sampler.h" #include "resource.h" +#include "texture_backend.h" namespace Msp { namespace GL { /** -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. +Base class for textures. Most operations are defined in subclasses. -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. +Memory must be allocated for the texture by calling storage(). Each subclass +provides this function with parameters appropriate to that type of texture. +Contents can then be modified using the image() and sub_image() functions +provided by subclasses. + +Most types of textures can consist of a pyramid of images, called a mipmap. +The dimensions of each mipmap level are half that of the previous level. + +Textures can be used as either a data source or target for draw commands. To +read from a texture in a shader, it must be paired with a Sampler to determine +how the texels are accessed. To draw into a texture, it must be attached to a +Framebuffer. */ -class Texture: public Resource +class Texture: public TextureBackend, public Resource { + friend TextureBackend; + protected: class Loader: public DataFile::CollectionObjectLoader { @@ -32,134 +38,77 @@ protected: unsigned levels; public: - Loader(Texture &); - Loader(Texture &, Collection &); + Loader(Texture &t): Loader(t, 0) { } + Loader(Texture &t, Collection &c): Loader(t, &c) { } private: - void init(); + Loader(Texture &, Collection *); + + virtual void finish(); - 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 external_data(const std::string &); + void external_image(bool, const std::string &); 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); - void wrap_t(TextureWrap); - }; - - enum ParameterMask - { - FORMAT_SWIZZLE = 512 + void raw_data(const std::string &); }; - enum FormatSwizzle +public: + class GenericLoader: public DataFile::DynamicObjectLoader { - NO_SWIZZLE, - R_TO_LUMINANCE, - RG_TO_LUMINANCE_ALPHA, - RGB_TO_BGR - }; + friend class Texture; - unsigned id; - GLenum target; - PixelFormat format; - PixelFormat storage_fmt; - FormatSwizzle swizzle; - bool use_srgb_format; - bool auto_gen_mipmap; - Sampler default_sampler; - - static int swizzle_orders[]; + public: + GenericLoader(Collection &c): DynamicObjectLoader(&c) { } - Texture(GLenum, ResourceManager * = 0); - Texture(const Texture &); - Texture &operator=(const Texture &); -public: - ~Texture(); + protected: + virtual const TypeRegistry &get_type_registry() const { return get_texture_registry(); } + }; protected: - void generate_id(); - void set_format(PixelFormat); - void apply_swizzle(); - void set_parameter_i(GLenum, int) const; - -public: - 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); + PixelFormat format = NO_PIXELFORMAT; + PixelFormat storage_fmt = NO_PIXELFORMAT; + ComponentSwizzle swizzle = NO_SWIZZLE; + unsigned n_levels = 0; + bool use_srgb_format = false; + bool auto_gen_mipmap = false; - /** Sets the wrapping mode for all coordinates. */ - DEPRECATED void set_wrap(TextureWrap); + Texture(unsigned); - 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(); + void set_format(PixelFormat); + static unsigned count_levels(unsigned); - /** Sets automatic mipmap generation. If enabled, mipmaps are generated - when a texture image is uploaded. */ - void set_auto_generate_mipmap(bool); + void stage_pixels(void *, const void *, std::size_t); - /// Deprecated. Use set_auto_generate_mipmap instead. - DEPRECATED void set_generate_mipmap(bool g) { set_auto_generate_mipmap(g); } +public: + PixelFormat get_format() const { return format; } - /** 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. */ - DEPRECATED void set_compare_enabled(bool); + using TextureBackend::generate_mipmap; - /** Sets the function to use for depth comparison. */ - DEPRECATED void set_compare_func(Predicate); + /** Replaces contents of an entire mipmap level. Allocated storage must + exist. The image data is interpreted according to the storage format and + must have size matching the selected mipmap level. */ + virtual void image(unsigned level, const void *) = 0; - /// Loads a Graphics::Image from a file and uploads it to the texture. + /** Loads an image into the texture from a file. */ 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. */ + /** Sets the texture's contents from an image. If storage has not been + allocated yet, it will be set to match the image. Otherwise the image must + be compatible with the existing storage. Subclasses may impose restrictions + on the image's dimensions. */ 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 { bind_to(0); } - void bind_to(unsigned) const; + virtual std::size_t get_data_size() const { return 0; } - static const Texture *current(unsigned = 0); - static void unbind() { unbind_from(0); } - static void unbind_from(unsigned); + using TextureBackend::set_debug_name; - virtual UInt64 get_data_size() const { return 0; } +private: + static GenericLoader::TypeRegistry &get_texture_registry(); }; } // namespace GL