webgl1es2_texture.h

// © Joseph Cameron - All Rights Reserved

#ifndef GDK_GFX_WEBGL1ES2_TEXTURE_H
#define GDK_GFX_WEBGL1ES2_TEXTURE_H

#include <gdk/opengl.h>
#include <gdk/texture.h>
#include <jfc/unique_handle.h>

#include <array>
#include <cstddef>
#include <string>
#include <vector>

namespace gdk
{
    class webgl1es2_texture final : public texture
    {
    public:
    //
        virtual void update_data(const image_data_2d_view &) override;
        
        virtual void update_data(const image_data_2d_view &, const size_t offsetX, const size_t offsetY) override;

        enum class format
        {
            rgba, 
            rgb, 
            luminance_alpha, 
            luminance, 
            a, 
            depth_component, 
        };

        enum class minification_filter
        {
            linear,
            
            nearest,
            
            nearest_mipmap_nearest,

            linear_mipmap_nearest,

            nearest_mipmap_linear,

            linear_mipmap_linear
        };

        enum class magnification_filter
        {
            nearest,
            
            linear
        };

        enum class wrap_mode
        {
            clamp_to_edge, 

            repeat,

            mirrored_repeat
        };

        enum class bind_target
        {
            texture_2d, 
            cube_map 
        };

        //TODO make use of this
        struct webgl1es2_texture_cubic_data_view_type
        {
            size_t width; 
            size_t height; 

            webgl1es2_texture::format format; 

            std::array<std::byte *, 6> data; 
        };
    
    public:
        //TODO consider abstracting this away. Currently only used by Shader, to bind the webgl1es2_texture. Exposing the raw handle
        // like this makes it trivial to put a webgl1es2_texture into an unintended state for example by getting the handle and deleting it.)
        GLuint getHandle() const;

        bool operator==(const webgl1es2_texture &) const;
        bool operator!=(const webgl1es2_texture &) const;

        webgl1es2_texture &operator=(webgl1es2_texture &&) = default;
        webgl1es2_texture(webgl1es2_texture &&) = default;

        //TODO: consider supporting copy semantics. How useful are they to a user? they are expensive. need to read about usecases.

        webgl1es2_texture(const image_data_2d_view &,
            const minification_filter minFilter = minification_filter::linear,
            const magnification_filter magFilter = magnification_filter::nearest,
            const wrap_mode wrapMode = wrap_mode::repeat);

        //webgl1es2_texture(

        //TODO cubic ctor

        static const std::shared_ptr<gdk::webgl1es2_texture> GetCheckerboardOfDeath(); 

        static webgl1es2_texture make_from_png_rgba32(const std::vector<std::underlying_type<std::byte>::type> aRGBA32PNGData);

    private:
        GLenum m_BindTarget;

        jfc::unique_handle<GLuint> m_Handle;

        size_t m_CurrentDataWidth;
        size_t m_CurrentDataHeight;
        GLint m_CurrentDataFormat;
    };
}

#endif