texture.h

#pragma once
#include<glad/glad.h>
#include <stb_image.h>
#include<vector>
#include<memory>
#include"../../source/res-management/resource.h"
#define NO_HANDLE -1
namespace Aire {
    enum TextureType
    {
        DIFFUSE_MAP,
        SPECULAR_MAP,
        NORMAL_MAP,
        HEIGHT_MAP,
        NO_TEXTURE
    };
 
    class Texture: public Resource {
    protected:
        GLuint handle;
        unsigned char* imageData;
        
    public:
        Texture();
 
        int texWidth;
 
        int texHeight;
 
        int texChannels;
 
        std::string dir;
 
        uint32_t getSize();
 
        GLuint getHandle() const;
 
        virtual ~Texture() = 0;//< Keep this pure virtual so that the class remains abstract and cannot be isntantiated.
 
        void bindTexUnit(GLint textureUnit);
 
        void setFiltering(GLint minFilter, GLint maxFilter);
 
        void setWrapping(GLint wrapS, GLint wrapT, GLint wrapR);
 
        unsigned char* getImageData();
 
        void setImageData(unsigned char*);
    };
 
    class Texture2D : public Texture {
    public:
        Texture2D(int width, int height, GLsizei levels, GLenum internalformat);
 
        void setData(
            int xOffset, 
            int yOffset, 
            int width, 
            int height, 
            const unsigned char* data, 
            GLenum format = GL_RGBA, 
            GLenum type = GL_UNSIGNED_BYTE,
            int level = 0
        );
 
        void generateMipmaps();
 
        virtual ~Texture2D() override;
 
        // Delete copy constructor and assignment operator
        Texture2D(const Texture2D&) = delete;
        Texture2D& operator=(const Texture2D&) = delete;
    };
 
    class TextureCubemap : public Texture {
    public:
 
        std::vector<unsigned char*> texDataList;
 
        int texWidth[6];
        int texHeight[6];
        int texChannels[6];
        TextureCubemap(int width, int height, GLsizei levels, GLenum internalformat);
 
        void setData(
            int face,
            int xOffset,
            int yOffset,
            int width,
            int height,
            const unsigned char* data,
            GLenum format = GL_RGBA,
            GLenum type = GL_UNSIGNED_BYTE,
            int level = 0
        );
 
        void generateMipmaps();
 
        // Destroy the Cubemap Texture
        virtual ~TextureCubemap() override;
 
        // Delete copy constructor and assignment operator
        TextureCubemap(const TextureCubemap&) = delete;
        TextureCubemap& operator=(const TextureCubemap&) = delete;
    };
 
    //##########################################//
    //######## INLINE DEFINITIONS BELOW ########//
    //##########################################//
 
    inline Texture::Texture() :
        handle(0)
    {
        imageData = nullptr;
 
        texWidth = 0;
        texHeight = 0;
        texChannels = 0;
    }
 
    inline GLuint Texture::getHandle() const {
        return handle;
    }
 
    inline Texture::~Texture() {
        // Empty destructor, but body still required
        if (imageData != nullptr)
        {
            //stbi_image_free(imageData);
        }
    };
 
    inline void Texture2D::generateMipmaps() {
        glGenerateTextureMipmap(handle);
    }
 
    inline Texture2D::~Texture2D() {
        if (handle != 0) {
            glDeleteTextures(1, &handle);
        }
    }
 
    inline TextureCubemap::~TextureCubemap() {
        if (handle != 0) {
            glDeleteTextures(1, &handle);
        }
    }
 
    inline void TextureCubemap::generateMipmaps() {
        glGenerateTextureMipmap(handle);
    }
 
    using TextureHandle = int;
    using CubeMapHandle = int;
    using TexturePtr = std::shared_ptr<Texture>;
    using CubeMapPtr = std::shared_ptr<TextureCubemap>;
 
}