Texture platte finished with gl textures but untested

include/render/textures.h

@@ -11,24 +11,34 @@
 #include <utility>
 #include <stb/stb_image.h>
 #include "stb/stb_image_resize.h"
+#include <util/settings.h>
+#include <unordered_map>
+#include <vector>
+#include <render/gl.h>
 
 namespace fp::texture {
     
-    class texture {
+    class file_texture {
         private:
             std::string m_Name;
             std::string m_Path;
             int width = 0, height = 0, channels = 0;
             unsigned char* m_Data = nullptr;
         public:
-            texture(std::string name, std::string path): m_Name(std::move(name)), m_Path(std::move(path)) {}
+            /**
+             * @param path path to the texture file
+             * @param name reference name for this texture. If empty the texture will use path as its identifier
+             */
+            explicit file_texture(const std::string& path, const std::string& name = ""): m_Name(name.empty() ? path : name), m_Path(path) {}
             
-            static texture* load(texture* texture) {
+            static file_texture* load(file_texture* texture) {
                 stbi_load(texture->m_Path.c_str(), &texture->width, &texture->height, &texture->channels, 4);
                 return texture;
             }
             
-            static texture* resize(texture* texture, int target_width, int target_height) {
+            static file_texture* resize(file_texture* texture, int target_width, int target_height) {
+                if (target_width == texture->width && target_height == texture->height)
+                    return texture;
                 // since stb is a c lib we must use malloc, otherwise we'd have to deal with using the right free on destruction
                 auto* output_Data = (unsigned char*) malloc(target_width * target_height * texture->channels);
                 
@@ -36,7 +46,7 @@ namespace fp::texture {
                         texture->m_Data, texture->width, texture->height, texture->width * texture->channels, output_Data, target_width,
                         target_height, target_width * texture->channels, texture->channels
                 );
-
+                
                 stbi_image_free(texture->m_Data);
                 texture->m_Data = output_Data;
                 texture->width = target_width;
@@ -47,23 +57,145 @@ namespace fp::texture {
                 return m_Data;
             }
             
-            ~texture() {
+            [[nodiscard]] const std::string& getName() {
+                return m_Name;
+            }
+            
+            ~file_texture() {
                 stbi_image_free(m_Data);
             }
     };
     
+    struct gl_texture {
+        protected:
+            unsigned int textureID = 0;
+            GLint textureBindType;
+            GLint textureColorMode;
+            int m_width, m_height;
+            
+            gl_texture(int width, int height, GLint bind_type = GL_TEXTURE_2D, GLint color_mode = GL_RGBA):
+                    m_width(width), m_height(height), textureBindType(bind_type), textureColorMode(color_mode) {
+                glGenTextures(1, &textureID);
+            }
+        public:
+            void bind() const {
+                glBindTexture(textureBindType, textureID);
+            }
+            
+            void unbind() const {
+                glBindTexture(textureBindType, 0);
+            }
+            
+            void setDefaults() const {
+                bind();
+                glTexParameteri(textureBindType, GL_TEXTURE_WRAP_S, GL_REPEAT);
+                glTexParameteri(textureBindType, GL_TEXTURE_WRAP_T, GL_REPEAT);
+                // nearest preserves the pixely look
+                glTexParameteri(textureBindType, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+                glTexParameteri(textureBindType, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                unbind();
+            }
+            
+            void generateMipmaps() const {
+                // it's a little inefficient binding and unbinding for these small calls, they really should be done in the constructor or data upload
+                bind();
+                glGenerateMipmap(textureBindType);
+                unbind();
+            }
+            
+            [[nodiscard]] unsigned int getTextureID() const {
+                return textureID;
+            }
+            
+            ~gl_texture() {
+                glDeleteTextures(1, &textureID);
+            }
+    };
+    
+    struct gl_texture2D : public gl_texture {
+        public:
+            gl_texture2D(int width, int height, GLint colorMode = GL_RGBA): gl_texture(width, height, GL_TEXTURE_2D, colorMode) {
+                bind();
+                glTexStorage2D(textureBindType, std::stoi(fp::settings::get("MIPMAP_LEVELS")), colorMode, width, height);
+            }
+            
+            void upload(void* data, int level = 0, int x_offset = 0, int y_offset = 0, int sub_width = -1, int sub_height = -1) const {
+                if (sub_width < 0)
+                    sub_width = m_width;
+                if (sub_height < 0)
+                    sub_height = m_height;
+                glTexSubImage2D(textureBindType, level, x_offset, y_offset, sub_width, sub_height, textureColorMode, GL_UNSIGNED_BYTE, data);
+            }
+    };
+    
+    struct gl_texture2D_array : public gl_texture {
+        protected:
+            int m_layers;
+        public:
+            gl_texture2D_array(int width, int height, int layers, GLint colorMode = GL_RGBA):
+                    gl_texture(width, height, GL_TEXTURE_2D_ARRAY, colorMode), m_layers(layers) {
+                bind();
+                glTexStorage3D(textureBindType, std::stoi(fp::settings::get("MIPMAP_LEVELS")), colorMode, width, height, layers);
+            }
+        
+            void upload(void* data, int index, int level = 0, int x_offset = 0, int y_offset = 0, int sub_width = -1, int sub_height = -1) const {
+                if (sub_width < 0)
+                    sub_width = m_width;
+                if (sub_height < 0)
+                    sub_height = m_height;
+                glTexSubImage3D(textureBindType, level, x_offset, y_offset, index, sub_width, sub_height, 1, textureColorMode, GL_UNSIGNED_BYTE, data);
+            }
+    };
+    
     class palette {
         private:
+            union negDInt {
+                int i = -1;
+            };
             // as of GL3.0 this limit is 256. (4.5 extends it to 2048.)
             static constexpr int MAX_ARRAY_LAYERS = 256;
+        
+            gl_texture2D_array* texture_array = nullptr;
             
-            int m_CurrentTextureCount = 0;
+            std::unordered_map<std::string, negDInt> textureIndices;
-            unsigned int textureID = 0;
+            std::vector<file_texture*> textures;
         
         public:
-            palette() {
+            palette() = default;
             
+            void generateGLTexture() {
+                delete texture_array;
+                auto texture_size = std::stoi(fp::settings::get("TEXTURE_SIZE"));
+                texture_array = new gl_texture2D_array(texture_size, texture_size, (int)textures.size());
+                for (const auto t : textures)
+                    texture_array->upload(t->data(), textureIndices[t->getName()].i);
+                texture_array->setDefaults();
+                texture_array->generateMipmaps();
             }
+            
+            void registerTexture(file_texture* texture) {
+                auto texture_size = std::stoi(fp::settings::get("TEXTURE_SIZE"));
+                texture = file_texture::resize(texture, texture_size, texture_size);
+                
+                textureIndices[texture->getName()].i = (int) textures.size();
+                textures.push_back(texture);
+            }
+            
+            bool hasTexture(const std::string& name) {
+                return textureIndices[name].i >= 0;
+            }
+            
+            int getTexture(const std::string& name) {
+                return textureIndices[name].i;
+            }
+            
+            unsigned int getTextureID() {
+                return texture_array->getTextureID();
+            }
+            
+            ~palette() {
+                delete texture_array;
+            };
     };
     
     

libraries/BLT

@@ -1 +1 @@
-Subproject commit b95359a3111eb332fd5f651ec4ae13fead1b6f59
+Subproject commit d72441f1703fa44d397b960e4e9e761f07786505

src/render/textures.cpp

@@ -5,4 +5,4 @@
  */
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_RESIZE_IMPLEMENTATION
-#include <render/textures.h>
+#include <render/textures.h>

src/util/settings.cpp

@@ -14,6 +14,7 @@ std::unordered_map<std::string, std::string> properties;
 // will be overwritten if the file has something different.
 void write_default_values(){
     properties["TEXTURE_SIZE"] = std::to_string(32);
+    properties["MIPMAP_LEVELS"] = std::to_string(3);
 }
 
 void fp::settings::load(const std::string& file) {