texture.h

#ifndef __TEXTURE_H__
#define __TEXTURE_H__
 
#include "app.h"
#include "image.h"
 
namespace sgltk {

class Texture {
    EXPORT static std::map<std::string, std::shared_ptr<Texture> > textures;
public:
    EXPORT static void add_path(std::string path);
    GLenum target;
    GLuint texture;
    unsigned int width;
    unsigned int height;
    unsigned int num_layers;
 
    EXPORT Texture();
    EXPORT ~Texture();

    EXPORT void set_parameter(GLenum name, int parameter);
    EXPORT void set_parameter(GLenum name, float parameter);
    EXPORT void set_parameter(GLenum name, float *parameter);

    EXPORT static bool store_texture(std::string name, std::shared_ptr<Texture> texture);
    EXPORT static std::shared_ptr<Texture> find_texture(std::string name);
    virtual void bind(unsigned int texture_unit = 0) = 0;
    virtual void unbind(unsigned int texture_unit = 0) = 0;
    EXPORT void bind_image(GLuint unit, GLint level,
                   GLboolean layered, GLint layer,
                   GLenum access, GLenum format);
};
 

class Texture_1d : public Texture {
public:
    EXPORT Texture_1d();
    EXPORT Texture_1d(const std::string& path);
    EXPORT Texture_1d(const sgltk::Image& image);
    EXPORT Texture_1d(unsigned int res,
              GLenum internal_format,
              GLenum type, GLenum format);
    EXPORT ~Texture_1d();

    EXPORT void create_empty(unsigned int res,
                 GLenum internal_format,
                 GLenum type,
                 GLenum format);
    EXPORT bool load(const sgltk::Image& image);
    EXPORT bool load(const std::string& path);
    EXPORT void bind(unsigned int texture_unit = 0);
    EXPORT void unbind(unsigned int texture_unit = 0);
};
 

class Texture_1d_Array : public Texture {
public:
    EXPORT Texture_1d_Array();
    EXPORT Texture_1d_Array(const std::vector<std::string>& paths);
    EXPORT Texture_1d_Array(const std::vector<sgltk::Image>& images);
    EXPORT Texture_1d_Array(unsigned int res,
                unsigned int num_layers,
                GLenum internal_format,
                GLenum type, GLenum format);
    EXPORT ~Texture_1d_Array();

    EXPORT void create_empty(unsigned int res,
                 unsigned int num_layers,
                 GLenum internal_format,
                 GLenum type,
                 GLenum format);
    EXPORT bool load(const std::vector<sgltk::Image>& images);
    EXPORT bool load(const std::vector<std::string>& paths);
    EXPORT void bind(unsigned int texture_unit = 0);
    EXPORT void unbind(unsigned int texture_unit = 0);
};
 

class Texture_2d : public Texture {
public:
    EXPORT Texture_2d();
    EXPORT Texture_2d(const std::string& path);
    EXPORT Texture_2d(const sgltk::Image& image);
    EXPORT Texture_2d(unsigned int res_x,
              unsigned int res_y,
              GLenum internal_format,
              GLenum type, GLenum format);
    EXPORT ~Texture_2d();

    EXPORT void create_empty(unsigned int res_x,
                 unsigned int res_y,
                 GLenum internal_format,
                 GLenum type,
                 GLenum format);
    EXPORT bool load(const sgltk::Image& image);
    EXPORT bool load(const std::string& path);
    EXPORT void bind(unsigned int texture_unit = 0);
    EXPORT void unbind(unsigned int texture_unit = 0);
};

class Texture_2d_Array : public Texture {
public:
    EXPORT Texture_2d_Array();
    EXPORT Texture_2d_Array(const std::vector<std::string>& paths);
    EXPORT Texture_2d_Array(const std::vector<sgltk::Image>& images);
    EXPORT Texture_2d_Array(unsigned int res_x,
                unsigned int res_y,
                unsigned int num_layers,
                GLenum internal_format,
                GLenum type, GLenum format);
    EXPORT ~Texture_2d_Array();

    EXPORT void create_empty(unsigned int res_x,
                 unsigned int res_y,
                 unsigned int num_layers,
                 GLenum internal_format,
                 GLenum type,
                 GLenum format);
    EXPORT bool load(const std::vector<sgltk::Image>& images);
    EXPORT bool load(const std::vector<std::string>& paths);
    EXPORT void bind(unsigned int texture_unit = 0);
    EXPORT void unbind(unsigned int texture_unit = 0);
};

class Texture_3d : public Texture {
public:
    EXPORT Texture_3d();
    EXPORT Texture_3d(const std::vector<std::string>& paths);
    EXPORT Texture_3d(const std::vector<sgltk::Image>& images);
    EXPORT Texture_3d(unsigned int res_x,
              unsigned int res_y,
              unsigned int res_z,
              GLenum internal_format,
              GLenum type,
              GLenum format);
    EXPORT ~Texture_3d();

    EXPORT void create_empty(unsigned int res_x,
                 unsigned int res_y,
                 unsigned int res_z,
                 GLenum internal_format,
                 GLenum type,
                 GLenum format);
    EXPORT bool load(const std::vector<sgltk::Image>& images);
    EXPORT bool load(const std::vector<std::string>& paths);
    EXPORT void bind(unsigned int texture_unit = 0);
    EXPORT void unbind(unsigned int texture_unit = 0);
};

class Cubemap : public Texture {
public:
    EXPORT Cubemap();
    EXPORT Cubemap(unsigned int res_x,
               unsigned int res_y,
               GLenum internal_format,
               GLenum type,
               GLenum format);
    EXPORT Cubemap(const sgltk::Image& pos_x, const sgltk::Image& neg_x,
               const sgltk::Image& pos_y, const sgltk::Image& neg_y,
               const sgltk::Image& pos_z, const sgltk::Image& neg_z);
    EXPORT ~Cubemap();

    EXPORT void create_empty(unsigned int res_x,
                 unsigned int res_y,
                 GLenum internal_format,
                 GLenum type,
                 GLenum format);
    EXPORT bool load(const std::string& pos_x, const std::string& neg_x,
             const std::string& pos_y, const std::string& neg_y,
             const std::string& pos_z, const std::string& neg_z);
    EXPORT bool load(const sgltk::Image& pos_x, const sgltk::Image& neg_x,
             const sgltk::Image& pos_y, const sgltk::Image& neg_y,
             const sgltk::Image& pos_z, const sgltk::Image& neg_z);
    EXPORT void bind(unsigned int texture_unit = 0);
    EXPORT void unbind(unsigned int texture_unit = 0);
};
}
 
#endif