Texture.hpp

#ifndef TEXTURE_H
#define TEXTURE_H
#include "pch.hpp"
#include "stb_image.h"
 
namespace Engine {
  struct TextureCoord {
    TextureCoord(glm::vec2 pos, glm::vec2 size): tex_pos(pos), tex_size(size) {};
    TextureCoord(const TextureCoord&) = default;
    TextureCoord() = default;
    glm::vec2 tex_pos;
    glm::vec2 tex_size;
  };
 
  struct TextureMap {
    std::vector<Ref<TextureCoord>> mapping = std::vector<Ref<TextureCoord>>();
    static Ref<TextureMap> Map2D(float width, float height, float x, float y);
    static Ref<TextureMap> CubeMap() {
      auto map = CreateRef<TextureMap>();
      auto map2d = TextureMap::Map2D(1, 1, 0, 0)->mapping;
      for (int i = 0; i < 6; i++) {
        for (auto a : map2d) {
          map->mapping.emplace_back(a);
        }
      }
      return map;
    }
  };
 
  struct ColorMap {
    std::vector<glm::vec4> mapping;
  };
 
 
  class Texture {
    friend TextureMap;
  public:
    virtual ~Texture() = default;
    virtual uint32_t getID() const {return 0;};
    virtual float getWidth() const {return -1;};
    virtual float getHeight() const {return -1;};
    virtual void setWidth(float width) {};
    virtual void setHeight(float height) {};
    virtual void setSize(float width, float height) {};
    virtual void setID(uint32_t id) {};
    virtual void Bind(uint32_t slot = 0) const {};
    virtual Ref<TextureMap> getDefaultMapping() const {return nullptr;};
    int renderSlot = -1;
  };
 
  class Texture2D : public Texture {
  public:
    static Ref<Texture2D> Create(const std::string& path);
    static Ref<Texture2D> Create();
    virtual Ref<Texture> genClip(uint32_t width, uint32_t height, uint32_t x, uint32_t y) const {return nullptr;};
    virtual void loadTextureData(stbi_uc *data, const int w, const int h, uint type) { };
  };
 
  struct TextureLookup {
    TextureLookup(const Ref <Texture> &tex, const Ref <Engine::TextureMap> &map, uint width, uint height);
    Ref<Texture> tex;
    Ref<TextureMap> map;
    uint width;
    uint height;
  };
 
}
#endif