Check the flat qualifier from the correct member

[libs/gl.git] / source / core / texture.h

diff --git a/source/core/texture.h b/source/core/texture.h
index c593c0ad5236657ac4f08b45ded75f8c3a144f4b..96b17b8910752e0f0f46f7466b2acf7d014e2746 100644 (file)
--- a/source/core/texture.h
+++ b/source/core/texture.h
@@ -12,13 +12,20 @@ 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 TextureBackend, public Resource
 {
@@ -42,12 +49,12 @@ 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 external_data(const std::string &);
+               void external_image(bool, const std::string &);
                void generate_mipmap(bool);
                void image_data(const std::string &);
                void mipmap_levels(unsigned);
+               void raw_data(const std::string &);
        };
 
 public:
@@ -63,35 +70,37 @@ public:
        };
 
 protected:
-       enum FormatSwizzle
-       {
-               NO_SWIZZLE,
-               R_TO_LUMINANCE,
-               RG_TO_LUMINANCE_ALPHA,
-               RGB_TO_BGR
-       };
-
-       PixelFormat format;
-       PixelFormat storage_fmt;
-       FormatSwizzle swizzle;
-       bool use_srgb_format;
-       bool auto_gen_mipmap;
+       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;
 
        Texture(unsigned);
 
        void set_format(PixelFormat);
+       static unsigned count_levels(unsigned);
+
+       void stage_pixels(void *, const void *, std::size_t);
 
 public:
        PixelFormat get_format() const { return format; }
 
        using TextureBackend::generate_mipmap;
 
-       /// Loads a Graphics::Image from a file and uploads it to the texture.
+       /** 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 an image into the texture from a file. */
        virtual void load_image(const std::string &, unsigned = 0);
 
-       /** 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;
 
        virtual std::size_t get_data_size() const { return 0; }