#ifndef MSP_GL_TEXTURE_H_
#define MSP_GL_TEXTURE_H_
-#include <msp/core/attributes.h>
+#include <msp/datafile/dynamicobjectloader.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"
+#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<Texture>
{
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);
+ void raw_data(const std::string &);
};
- enum ParameterMask
+public:
+ class GenericLoader: public DataFile::DynamicObjectLoader<Texture>
{
- FORMAT_SWIZZLE = 512
+ friend class Texture;
+
+ public:
+ GenericLoader(Collection &c): DynamicObjectLoader<Texture>(&c) { }
+
+ protected:
+ virtual const TypeRegistry &get_type_registry() const { return get_texture_registry(); }
};
+protected:
enum FormatSwizzle
{
NO_SWIZZLE,
RGB_TO_BGR
};
- 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[];
+ Texture(unsigned);
- Texture(GLenum, ResourceManager * = 0);
- Texture(const Texture &);
- Texture &operator=(const Texture &);
-public:
- ~Texture();
-
-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; }
+ PixelFormat get_format() const { return format; }
- DEPRECATED void set_min_filter(TextureFilter);
- DEPRECATED void set_mag_filter(TextureFilter);
+ using TextureBackend::generate_mipmap;
- /** Sets filter for both minification and magnification. Since mipmapping
- is not applicable to magnification, LINEAR is used instead. */
- DEPRECATED void set_filter(TextureFilter);
+ /** 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;
- DEPRECATED void set_mipmap_levels(unsigned) { }
-
- DEPRECATED void set_max_anisotropy(float);
-
- /** Sets the wrapping mode for all coordinates. */
- DEPRECATED void set_wrap(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_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. */
- DEPRECATED void set_compare_enabled(bool);
-
- /** Sets the function to use for depth comparison. */
- DEPRECATED void set_compare_func(Predicate);
-
- /// 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