Cleanup & remove ReImage

CMakeLists.txt

@@ -40,11 +40,6 @@ CPMAddPackage(
         URL https://git.redacted.cc/josh/jlog/Prerelease-16.zip
 )
 
-CPMAddPackage(
-        NAME ReImage
-        URL https://git.redacted.cc/Redacted/ReImage/archive/Release-2.0.zip
-)
-
 if (WIN32)
     CPMAddPackage(
             NAME freetype
@@ -57,7 +52,7 @@ endif()
 file(COPY "assets" DESTINATION "${PROJECT_BINARY_DIR}")
 file(GLOB_RECURSE ASSETS  "assets/*")
 file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp"            )
-file(GLOB_RECURSE SOURCES "src/*.c" "src/*.cpp" "src/renderer/OpenGL/internals/*.h")
+file(GLOB_RECURSE SOURCES "src/*.c" "src/*.cpp" "src/*.h")
 
 if (UNIX AND NOT APPLE)
     find_package(Freetype REQUIRED)
@@ -78,7 +73,6 @@ include_directories(
 
 target_include_directories(JGL PUBLIC
         ${PROJECT_SOURCE_DIR}/include
-        ${ReImage_SOURCE_DIR}/include
         ${mcolor_SOURCE_DIR}/include
         ${J3ML_SOURCE_DIR}/include
         ${jlog_SOURCE_DIR}/include
@@ -91,13 +85,13 @@ add_executable(JGL_Demo main.cpp)
 if (UNIX AND NOT APPLE)
     target_include_directories(JGL PRIVATE ${FREETYPE_INCLUDE_DIRS} )
     target_link_libraries(JGL PRIVATE ${FREETYPE_LIBRARIES})
-    target_link_libraries(JGL PUBLIC mcolor J3ML jlog ReImage glad)
+    target_link_libraries(JGL PUBLIC mcolor J3ML jlog glad)
 endif()
 
 if (WIN32)
     target_include_directories(JGL PRIVATE ${freetype_SOURCE_DIR}/include)
     target_link_libraries(JGL PRIVATE freetype)
-    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReImage glad)
+    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog glad)
 endif()
 
 target_link_libraries(JGL_Demo PUBLIC JGL ReWindow Event glad)

include/JGL/types/RenderTarget.h

@@ -76,10 +76,10 @@ public:
     [[nodiscard]] bool MSAAEnabled() const;
 
     /// @returns The JGL texture this Render Target draws on.
-    [[nodiscard]] const Texture* GetJGLTexture() const;
+    [[nodiscard]] const Texture* GetTexture() const;
 
     /// @returns The OpenGL handle for the texture this Render Target draws on.
-    [[nodiscard]] GLuint GetGLTextureHandle() const;
+    [[nodiscard]] GLuint GetTextureHandle() const;
 
     /// @returns The OpenGL handle for this Render Target.
     [[nodiscard]] GLuint GetGLFramebufferObjectHandle() const;

include/JGL/types/Texture.h

@@ -1,13 +1,14 @@
 #pragma once
-#include <ReImage/Image.h>
-#include <J3ML/LinearAlgebra.hpp>
+#include<vector>
+#include <filesystem>
+#include <J3ML/LinearAlgebra/Vector2i.hpp>
 #include <Color3.hpp>
 #include <Color4.hpp>
-#include <glad/glad.h>
 
 namespace JGL {
-    using namespace ReImage;
-    enum class TextureFilteringMode : u8 {
+    using J3ML::LinearAlgebra::Vector2i;
+
+    enum class FilteringMode : u8 {
         NEAREST = 0, // Fastest for 2D, Sometimes causes graphical issues.
         BILINEAR = 1, // Fast and pretty, The best for 2D.
 
@@ -16,44 +17,59 @@ namespace JGL {
         MIPMAP_TRILINEAR = 4 // The prettiest. Still decent speed. Uses more vram.
     };
 
-    enum class TextureWrappingMode : u8 {
+    enum class WrappingMode : u8 {
         REPEAT = 0,
         MIRRORED_REPEAT = 1,
         CLAMP_TO_EDGE = 2,
         CLAMP_TO_BORDER = 3 // Effectively the same as clamp_to_edge
     };
+    enum class ColorFormat : bool { RGB = false, RGBA = true };
+    class Texture;
+}
 
-    /// Represents texture data loaded on the GPU. Contains a handle that can be passed to OpenGL draw calls.
-    class Texture {
-    private:
-        void Erase();
-    protected:
-        GLuint texture_handle = 0;
-        Vector2 texture_size = {0, 0};
-        ReImage::TextureFlag texture_flags;
-        ReImage::TextureFormat texture_format;
-        TextureFilteringMode texture_filtering_mode;
-        TextureWrappingMode texture_wrapping_mode;
-        void load(Image* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
-    public:
-        /// Load a texture from a file,
-        explicit Texture(const std::string& file, TextureFilteringMode filtering_mode = TextureFilteringMode::BILINEAR, TextureWrappingMode wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE, const TextureFlag& flags = TextureFlag::INVERT_Y);
-        Texture(Image* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
-        // Texture atlas.
-        Texture(const Texture* textures, const size_t& texture_count);
-        /* Initialize a texture filled with trash data
-        this is primarily for the RenderTarget */
-        explicit Texture(const Vector2& size);
-        Texture(const Texture& rhs);
-        ~Texture();
-    public:
-        [[nodiscard]] GLuint GetGLTextureHandle() const;
-        [[nodiscard]] Vector2 GetDimensions() const;
-        [[nodiscard]] TextureFilteringMode GetFilteringMode() const;
-        [[nodiscard]] TextureWrappingMode GetWrappingMode() const;
-        [[nodiscard]] TextureFlag GetFlags() const;
-        [[nodiscard]] TextureFormat GetFormat() const;
-        [[nodiscard]] std::vector<Color4> GetPixelData() const;
-    };
+/// TODO handle the case of a texture being loaded that exceeds the max texture size.
+/// Represents texture data loaded on the GPU. Contains a handle that can be passed to OpenGL draw calls.
+class JGL::Texture {
+protected:
+    unsigned int texture_handle = 0;
+    bool invert_y = false;
+    Vector2i size = {0, 0};
+    ColorFormat format =  ColorFormat::RGBA;
+    FilteringMode filtering_mode;
+    WrappingMode wrapping_mode;
+    void load(const unsigned char* pixels);
+    std::vector<unsigned char> png(const std::filesystem::path& file);
+    std::vector<unsigned char> bmp(const std::filesystem::path& file);
+public:
+    /// @returns A handle used to identify this texture.
+    [[nodiscard]] unsigned int GetHandle() const;
+    /// @returns The size of this texture.
+    [[nodiscard]] Vector2i GetDimensions() const;
+    /// @returns The filtering mode this texture is using.
+    [[nodiscard]] FilteringMode GetFilteringMode() const;
+    /// @returns The way this texture behaves when used on geometry of different sizes.
+    [[nodiscard]] WrappingMode GetWrappingMode() const;
+    /// @returns The orientation of this texture in v-ram.
+    /// @note true is right-side-up because OpenGL defaults to upside-down.
+    [[nodiscard]] bool Inverted() const;
+    [[nodiscard]] ColorFormat GetFormat() const;
+    /// @returns The raw pixels this texture is made up of.
+    /// @note This will read-back from the GPU. Slow.
+    [[nodiscard]] std::vector<Color4> GetPixelData() const;
+public:
+    /// Load a texture from a file,
+    explicit Texture(const std::filesystem::path& file, FilteringMode filtering_mode = FilteringMode::BILINEAR, WrappingMode wrapping_mode = WrappingMode::CLAMP_TO_EDGE, bool invert_y = true);
+    /// Load a texture from raw pixels.
+    Texture(const Color4* pixels, const Vector2i& size, const ColorFormat& format, FilteringMode filtering_mode, WrappingMode wrapping_mode);
+    /// Load a texture from raw pixels.
+    Texture(const Color3* pixels, const Vector2i& size, const ColorFormat& format, FilteringMode filtering_mode, WrappingMode wrapping_mode);
+    /// Construct a Texture Atlas from many different textures.
+    /// @note THIS IS UNFINISHED.
+    Texture(const Texture* textures, const size_t& texture_count);
+    /// Initialize a texture filled with trash data.
+    /// @see RenderTarget
+    explicit Texture(const Vector2i& size);
 
-}
+    Texture(const Texture& rhs);
+    ~Texture();
+};

main.cpp

@@ -128,9 +128,9 @@ public:
         glEnable(GL_DEPTH_TEST);
         glDepthFunc(GL_LESS);
         glDepthMask(GL_TRUE);
-        image = new Texture("assets/sprites/Re3D.png", TextureFilteringMode::BILINEAR);
+        image = new Texture("assets/sprites/Re3D.png", FilteringMode::BILINEAR);
         image_mask = new Texture("assets/sprites/alpha_mask_2.png");
-        j2d_render_target = new RenderTarget({540, 540}, {0,0,0,0}, false, MSAA_SAMPLE_RATE::MSAA_NONE);
+        j2d_render_target = new RenderTarget({540, 500}, {0,0,0,0}, false, MSAA_SAMPLE_RATE::MSAA_NONE);
 
         //Texture::MultiplyByAlphaMask(*image, *image_mask);
     }
@@ -191,7 +191,7 @@ public:
             J2D::FillRect(Colors::Blue, {0,52}, {100,100});
             J2D::DrawSprite(image, {300, 400}, sprite_radians * 0.10f, {0.5,0.5}, {1, 1}, Colors::White);
             J2D::DrawMirrorSprite(image, {400, 300}, Direction::Horizontal | Direction::Vertical, sprite_radians, {0.5,0.5}, {1, 1}, Colors::White);
-            J2D::DrawPartialSprite(image, {225, 300}, image->GetDimensions() * 0.25, image->GetDimensions() * 0.75, sprite_radians, {0.5, 0.5}, {1,1}, Colors::White);
+            J2D::DrawPartialSprite(image, Vector2(225, 300), Vector2(image->GetDimensions()) * 0.25, Vector2(image->GetDimensions()) * 0.75, sprite_radians, {0.5, 0.5}, {1,1}, Colors::White);
             J2D::FillRect(Colors::Pinks::HotPink, {68, 120}, {32, 32});
             J2D::FillGradientRect(Colors::Red, Colors::Blue, Direction::Diagonal_SWNE, {100,52}, {100,100});
             J2D::FillRoundedRect(Colors::Red, {200, 52}, {100, 100}, 8, 8);

src/renderer/OpenGL/J2D.cpp

@@ -12,7 +12,7 @@ void JGL::J2D::Begin(RenderTarget* rt, bool clear_buffers) {
         OpenGLState::current_fbo = JGL::RenderTarget::GetActiveGLFramebufferHandle();
         JGL::RenderTarget::SetActiveGLRenderTarget(*rt);
 
-        if (!(rt->GetJGLTexture()->GetFlags() & INVERT_Y))
+        if (!rt->GetTexture()->Inverted())
             Logger::Warning("You're rendering onto a texture that is upside-down. Your draw commands won't work how you'd expect.");
     }
     glMatrixMode(GL_PROJECTION);
@@ -401,16 +401,16 @@ void JGL::J2D::DrawSprite(const JGL::RenderTarget& rt, const Vector2& position,
 
     //Correct for the render-target being upside-down.
     Direction d{};
-    if (inversion == Direction::None && !(rt.GetJGLTexture()->GetFlags() & INVERT_Y))
+    if (inversion == Direction::None && !rt.GetTexture()->Inverted())
         d = Direction::Vertical;
     else if (inversion == Direction::Horizontal) {
         d = Direction::Horizontal;
-        if (!(rt.GetJGLTexture()->GetFlags() & INVERT_Y))
+        if (!rt.GetTexture()->Inverted())
             d = Direction::Horizontal | Direction::Vertical;
     }
     else if (inversion& Direction::Horizontal && inversion& Direction::Vertical) {
         d = Direction::Horizontal;
-        if (!(rt.GetJGLTexture()->GetFlags() & INVERT_Y))
+        if (!rt.GetTexture()->Inverted())
             d = Direction::Horizontal | Direction::Vertical;
     }
 
@@ -419,13 +419,13 @@ void JGL::J2D::DrawSprite(const JGL::RenderTarget& rt, const Vector2& position,
         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
     auto r_position = Vector2(Math::Floor(position.x), Math::Floor(position.y));
-    JGL::J2D::DrawPartialSprite(*rt.GetJGLTexture(), r_position, {0, 0}, Vector2(rt.GetDimensions()), rad_rotation, origin, scale, color, d);
+    JGL::J2D::DrawPartialSprite(*rt.GetTexture(), r_position, {0, 0}, Vector2(rt.GetDimensions()), rad_rotation, origin, scale, color, d);
 
     if (rt.OwnsTexture())
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
-void JGL::J2D::DrawSprite(const Texture& texture, const Texture &alpha_mask, const Vector2& position, float rad_rotation,
+void JGL::J2D::DrawSprite(const Texture& texture, const Texture& alpha_mask, const Vector2& position, float rad_rotation,
                      const Vector2& origin, const Vector2& scale,const Color4& color, JGL::Direction inversion) {
     if (!inJ2D)
         Logger::Error("Drawing J2D element before J2D begin.");
@@ -435,11 +435,9 @@ void JGL::J2D::DrawSprite(const Texture& texture, const Texture &alpha_mask, con
 
     const Vector2 size = Vector2(texture.GetDimensions());
 
-    std::array<Vector2, 4> textureCoordinates{};
-    if (texture.GetFlags() & INVERT_Y)
+    std::array<Vector2, 4> textureCoordinates = { Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 0) };
+    if (texture.Inverted())
         textureCoordinates = {Vector2(0, 1), Vector2(0, 0), Vector2(1, 0), Vector2(1, 1)};
-    else
-        textureCoordinates = {Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 0)};
 
     // TODO: Kind of a mess, refactor to be more sensible later.
     // Factors in scaling and origin correctly.
@@ -481,7 +479,7 @@ void JGL::J2D::DrawSprite(const Texture& texture, const Texture &alpha_mask, con
     // Texture 0.
     glEnable(GL_TEXTURE_2D);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-    glBindTexture(GL_TEXTURE_2D, texture.GetGLTextureHandle());
+    glBindTexture(GL_TEXTURE_2D, texture.GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
     glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), textureCoordinates.data());
 
@@ -493,7 +491,7 @@ void JGL::J2D::DrawSprite(const Texture& texture, const Texture &alpha_mask, con
     glEnableClientState(GL_VERTEX_ARRAY);
     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
-    glBindTexture(GL_TEXTURE_2D, alpha_mask.GetGLTextureHandle());
+    glBindTexture(GL_TEXTURE_2D, alpha_mask.GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
     glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), textureCoordinates.data());
 
@@ -535,17 +533,17 @@ void JGL::J2D::DrawPartialRenderTarget(const JGL::RenderTarget& rt, const Vector
 
     //Correct for the render-target being upside-down.
     Direction d{};
-    if (inversion == Direction::None && !(rt.GetJGLTexture()->GetFlags() & INVERT_Y))
+    if (inversion == Direction::None && !rt.GetTexture()->Inverted())
         d = Direction::Vertical;
 
     else if (inversion == Direction::Horizontal) {
         d = Direction::Horizontal;
-        if (!(rt.GetJGLTexture()->GetFlags() & INVERT_Y))
+        if (!rt.GetTexture()->Inverted())
             d = Direction::Horizontal | Direction::Vertical;
     }
     else if (inversion& Direction::Horizontal && inversion& Direction::Vertical) {
         d = Direction::Horizontal;
-        if (!(rt.GetJGLTexture()->GetFlags() & INVERT_Y))
+        if (!rt.GetTexture()->Inverted())
             d = Direction::Horizontal | Direction::Vertical;
     }
 
@@ -556,7 +554,7 @@ void JGL::J2D::DrawPartialRenderTarget(const JGL::RenderTarget& rt, const Vector
     auto r_position = Vector2(Math::Floor(position.x), Math::Floor(position.y));
     auto r_sub_texture_position = Vector2(Math::Floor(sub_texture_position.x), Math::Floor(sub_texture_position.y));
 
-    JGL::J2D::DrawPartialSprite(*rt.GetJGLTexture(), r_position, r_sub_texture_position, sub_texture_size, rad_rotation, origin, scale, color, d);
+    JGL::J2D::DrawPartialSprite(*rt.GetTexture(), r_position, r_sub_texture_position, sub_texture_size, rad_rotation, origin, scale, color, d);
 
     if (rt.OwnsTexture())
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -576,7 +574,7 @@ void JGL::J2D::DrawSprite(const Texture& texture, const Vector2& pos, float rad_
     const Vector2 size = Vector2(texture.GetDimensions());
 
     std::array<Vector2, 4> textureCoordinates{};
-    if (texture.GetFlags() & INVERT_Y)
+    if (texture.Inverted())
         textureCoordinates = {Vector2(0, 1), Vector2(0, 0), Vector2(1, 0), Vector2(1, 1)};
     else
         textureCoordinates = {Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 0)};
@@ -618,7 +616,7 @@ void JGL::J2D::DrawSprite(const Texture& texture, const Vector2& pos, float rad_
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     glEnable(GL_TEXTURE_2D);
     glColor4ubv(color.ptr());
-    glBindTexture(GL_TEXTURE_2D, texture.GetGLTextureHandle());
+    glBindTexture(GL_TEXTURE_2D, texture.GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
     glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), textureCoordinates.data());
     glDrawArrays(GL_QUADS, 0, 4);
@@ -648,7 +646,7 @@ void JGL::J2D::DrawPartialSprite(const Texture& texture, const Vector2& position
     const Vector2 textureSize = Vector2(texture.GetDimensions());
     std::array<GLfloat, 8> textureCoordinates{};
     // Calculate texture coordinates (relative to the whole texture)
-    if (!(texture.GetFlags() & INVERT_Y))
+    if (!texture.Inverted())
         textureCoordinates = {
                 sub_texture_position.x / textureSize.x,
                 sub_texture_position.y / textureSize.y,
@@ -707,7 +705,7 @@ void JGL::J2D::DrawPartialSprite(const Texture& texture, const Vector2& position
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     glEnable(GL_TEXTURE_2D);
     glColor4ubv(color.ptr());
-    glBindTexture(GL_TEXTURE_2D, texture.GetGLTextureHandle());
+    glBindTexture(GL_TEXTURE_2D, texture.GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
     glTexCoordPointer(2, GL_FLOAT, 0, textureCoordinates.data());
     glDrawArrays(GL_QUADS, 0, 4);
@@ -734,14 +732,14 @@ void JGL::J2D::DrawMirrorSprite(const Texture& texture, const Vector2& position,
     if (mirror_axis == Direction::None)
         Logger::Warning("Drawing non-mirrored sprite with JGL::J2D::DrawMirrorSprite?");
 
-    glBindTexture(GL_TEXTURE_2D, texture.GetGLTextureHandle());
+    glBindTexture(GL_TEXTURE_2D, texture.GetHandle());
     Vector2 size = Vector2(texture.GetDimensions());
 
     std::array<Vector2, 4> textureCoordinates  = {Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 0)};
     if (mirror_axis == Direction::Horizontal) {
         size.x *= 2;
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
-        if (texture.GetFlags() & INVERT_Y)
+        if (texture.Inverted())
             textureCoordinates = {Vector2(0, 1), Vector2(0, 0), Vector2(2, 0), Vector2(2, 1)};
         else
             textureCoordinates = {Vector2(0, 0), Vector2(0, 1), Vector2(2, 1), Vector2(2, 0)};
@@ -750,7 +748,7 @@ void JGL::J2D::DrawMirrorSprite(const Texture& texture, const Vector2& position,
     else if (mirror_axis == Direction::Vertical) {
         size.y *= 2;
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
-        if (texture.GetFlags() & INVERT_Y)
+        if (texture.Inverted())
             textureCoordinates = {Vector2(0, 2), Vector2(0, 0), Vector2(1, 0), Vector2(1, 2)};
         else
             textureCoordinates = {Vector2(0, 0), Vector2(0, 2), Vector2(1, 2), Vector2(1, 0)};
@@ -760,7 +758,7 @@ void JGL::J2D::DrawMirrorSprite(const Texture& texture, const Vector2& position,
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
         size *= 2;
-        if (texture.GetFlags() & INVERT_Y)
+        if (texture.Inverted())
             textureCoordinates = {Vector2(0, 2), Vector2(0, 0), Vector2(2, 0), Vector2(2, 2)};
         else
             textureCoordinates = {Vector2(0, 0), Vector2(0, 2), Vector2(2, 2), Vector2(2, 0)};
@@ -795,15 +793,16 @@ void JGL::J2D::DrawMirrorSprite(const Texture& texture, const Vector2& position,
     glDrawArrays(GL_QUADS, 0, 4);
 
     //Reset the wrapping mode.
-    if (texture.GetWrappingMode() == TextureWrappingMode::CLAMP_TO_EDGE)
+    if (texture.GetWrappingMode() == WrappingMode::CLAMP_TO_EDGE)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    else if (texture.GetWrappingMode() == TextureWrappingMode::REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    else if (texture.GetWrappingMode() == WrappingMode::REPEAT)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    else if (texture.GetWrappingMode() == TextureWrappingMode::CLAMP_TO_BORDER)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    else if (texture.GetWrappingMode() == WrappingMode::CLAMP_TO_BORDER)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+
     glBindTexture(GL_TEXTURE_2D, 0);
     glColor4fv(OpenGLState::baseColor);
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);

src/renderer/OpenGL/TextRendering.cpp

@@ -4,8 +4,8 @@
 
 #if __linux__
     #include <freetype2/ft2build.h>
-    #include FT_FREETYPE_H"freetype/freetype.h""freetype/freetype.h"
-    #include FT_OUTLINE_H"freetype/ftoutln.h""freetype/ftoutln.h"
+    #include FT_FREETYPE_H
+    #include FT_OUTLINE_H
 #endif
 
 #if _WIN32

src/types/RenderTarget.cpp

@@ -3,12 +3,12 @@
 #include <JGL/logger/logger.h>
 #include <stdexcept>
 
-const JGL::Texture* JGL::RenderTarget::GetJGLTexture() const {
+const JGL::Texture* JGL::RenderTarget::GetTexture() const {
     return texture;
 }
 
-GLuint JGL::RenderTarget::GetGLTextureHandle() const {
-    return texture->GetGLTextureHandle();
+GLuint JGL::RenderTarget::GetTextureHandle() const {
+    return texture->GetHandle();
 }
 
 GLuint JGL::RenderTarget::GetGLFramebufferObjectHandle() const {
@@ -64,7 +64,7 @@ JGL::RenderTarget::RenderTarget(const JGL::Texture* texture, const Color4& clear
     glGenFramebuffers(1, &framebuffer_object);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_object);
     glViewport(0,0, size.x, size.y);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetGLTextureHandle(), 0);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetHandle(), 0);
 
     if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
         throw std::runtime_error("A new framebuffer could not be allocated.");
@@ -85,11 +85,11 @@ JGL::RenderTarget::RenderTarget(const Vector2i& size, const Color4& clear_color,
     glGetIntegerv(GL_VIEWPORT, viewport);
     //Textures behave strangely if they're not square aaaaaaaaaaaaa.
 
-    texture = new Texture(Vector2(size.x, size.y));
+    texture = new Texture(size);
     glGenFramebuffers(1, &framebuffer_object);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_object);
     glViewport(0,0, size.x, size.y);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetGLTextureHandle(), 0);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetHandle(), 0);
 
     if (use_depth) {
         GLuint depthBuffer;
@@ -171,8 +171,8 @@ void JGL::RenderTarget::Resize(const Vector2i& new_size) {
     glClearColor(cc.RedChannelNormalized(), cc.GreenChannelNormalized(), cc.BlueChannelNormalized(), cc.AlphaChannelNormalized());
     glViewport(0,0, size.x, size.y);
 
-    texture = new Texture(Vector2(new_size.x, new_size.y));
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetGLTextureHandle(), 0);
+    texture = new Texture(new_size);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->GetHandle(), 0);
 
     glBindFramebuffer(GL_FRAMEBUFFER, current_fbo);
     glClearColor(old_clear_color[0], old_clear_color[1], old_clear_color[2], old_clear_color[3]);
@@ -285,13 +285,13 @@ void JGL::RenderTarget::MSAABlit() const {
     }
 
     // Fixes using render targets on a texture that has mipmaps.
-    if (GetJGLTexture()->GetFilteringMode() == TextureFilteringMode::MIPMAP_NEAREST
-        || GetJGLTexture()->GetFilteringMode() == TextureFilteringMode::MIPMAP_BILINEAR ||
-        GetJGLTexture()->GetFilteringMode() == TextureFilteringMode::MIPMAP_TRILINEAR) {
+    if (GetTexture()->GetFilteringMode() == FilteringMode::MIPMAP_NEAREST
+        || GetTexture()->GetFilteringMode() == FilteringMode::MIPMAP_BILINEAR ||
+        GetTexture()->GetFilteringMode() == FilteringMode::MIPMAP_TRILINEAR) {
         GLint current_texture = 0;
         glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
-        glBindTexture(GL_TEXTURE_2D, GetJGLTexture()->GetGLTextureHandle());
+        glBindTexture(GL_TEXTURE_2D, GetTexture()->GetHandle());
         glGenerateMipmap(GL_TEXTURE_2D);
 
         glBindTexture(GL_TEXTURE_2D, current_texture);

src/types/Texture.cpp

@@ -1,212 +1,258 @@
 #include <JGL/types/Texture.h>
-#include <iostream>
 #include <JGL/types/RenderTarget.h>
+#include <JGL/logger/logger.h>
+#include <glad/glad.h>
+#include <fstream>
 
-using namespace ReImage;
+#define STB_IMAGE_IMPLEMENTATION
+#include "internals/stb_image.h"
 
-namespace JGL
-{
-    Texture::Texture(const std::string& file, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode, const TextureFlag& flags)
-    {
-        auto* t = new ReImage::Image(file, flags);
-        GLuint previous_texture;
-        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
+using namespace JGL;
 
-        load(t, {(float) t->getWidth(), (float) t->getHeight()}, t->getTextureFormat(), filtering_mode, wrapping_mode);
-        texture_flags = flags;
+Texture::Texture(const std::filesystem::path& file, FilteringMode filtering_mode, WrappingMode wrapping_mode, bool invert_y) :
+invert_y(invert_y), filtering_mode(filtering_mode), wrapping_mode(wrapping_mode) {
+    std::vector<unsigned char> pixels{};
 
-        delete t;
+    std::ifstream ifStream(file, std::ios::in | std::ios::binary);
+    if (!ifStream.is_open())
+        Logger::Fatal("Trying to load a texture from: " + file.string() + "but we couldn't read the file.");
+
+    unsigned char bmpFileHeader[14];
+
+    ifStream.read(reinterpret_cast<char*>(bmpFileHeader), 14);
+    if (bmpFileHeader[0] == 'B' && bmpFileHeader[1] == 'M')
+        pixels = bmp(file);
+
+    //TODO determine if it's a PNG using the file header instead.
+    else if (file.string().ends_with(".png"))
+        pixels = png(file);
+    ifStream.close();
+
+    load(pixels.data());
+}
+
+std::vector<unsigned char> Texture::png(const std::filesystem::path& file) {
+    std::vector<unsigned char> result{};
+    int channels;
+
+    unsigned char* image_data = stbi_load(file.c_str(), &size.x, &size.y, &channels, 0);
+    if (!image_data)
+        Logger::Fatal("Trying to load a texture from: " + file.string() + "but we couldn't read the file.");
+
+    if (channels == 4)
+        format = ColorFormat::RGBA;
+    else if (channels == 3)
+        format = ColorFormat::RGB;
+
+    if (image_data)
+        result.assign(image_data, image_data + size.x * size.y * channels);
+
+    stbi_image_free(image_data);
+    return result;
+}
+
+std::vector<unsigned char> Texture::bmp(const std::filesystem::path& file) {
+    std::vector<unsigned char> result{};
+    std::ifstream bmp_file(file, std::ios::in | std::ios::binary);
+
+    unsigned char bmpFileHeader[14];
+    unsigned char bmpInfoHeader[40];
+
+    bmp_file.read(reinterpret_cast<char *>(bmpFileHeader), 14);
+    bmp_file.read(reinterpret_cast<char *>(bmpInfoHeader), 40);
+
+    size.x = bmpInfoHeader[4] + (bmpInfoHeader[5] << 8) + (bmpInfoHeader[6] << 16) + (bmpInfoHeader[7] << 24);
+    size.y = bmpInfoHeader[8] + (bmpInfoHeader[9] << 8) + (bmpInfoHeader[10] << 16) + (bmpInfoHeader[11] << 24);
+
+    int row_padded = (size.x * 3 + 3) & (~3);
+    result.resize(size.x * size.y * 3);
+
+    std::vector<unsigned char> rowData(row_padded);
+    for (int y = size.y - 1; y >= 0; --y) {
+        bmp_file.read(reinterpret_cast<char *>(rowData.data()), row_padded);
+        for (int x = 0; x < size.x; ++x) {
+            result[(y * size.x + x) * 3 + 2] = rowData[x * 3 + 0];
+            result[(y * size.x + x) * 3 + 1] = rowData[x * 3 + 1];
+            result[(y * size.x + x) * 3 + 0] = rowData[x * 3 + 2];
+        }
     }
 
-    Texture::Texture(const Vector2& size) {
-        GLuint previous_texture;
-        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
+    bmp_file.close();
+    format = ColorFormat::RGB;
+    return result;
+}
 
-        glGenTextures(1, &texture_handle);
-        glBindTexture(GL_TEXTURE_2D, texture_handle);
-        //NEAREST
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        //Clamp
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+Texture::Texture(const Vector2i& size) : invert_y(true), format(ColorFormat::RGBA), size(size), filtering_mode(FilteringMode::NEAREST), wrapping_mode(WrappingMode::CLAMP_TO_EDGE) {
+    GLuint previous_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
+
+    glGenTextures(1, &texture_handle);
+    glBindTexture(GL_TEXTURE_2D, texture_handle);
+    //NEAREST
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    //Clamp
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.x, size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    glBindTexture(GL_TEXTURE_2D, previous_texture);
+}
+
+void Texture::load(const unsigned char* pixels) {
+    GLuint previous_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
+
+    glGenTextures(1, &texture_handle);
+    glBindTexture(GL_TEXTURE_2D, texture_handle);
+
+    if (format == ColorFormat::RGBA)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.x, size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    else if (format == ColorFormat::RGB)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
+
+    if (wrapping_mode == WrappingMode::CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE),
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (int) size.x, (int) size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    else if (wrapping_mode == WrappingMode::REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT),
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
-        texture_format = TextureFormat::RGBA;
-        texture_size = size;
-        texture_filtering_mode = TextureFilteringMode::NEAREST;
-        texture_wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE;
-        // Because in vram it'll be right side up.
-        texture_flags = TextureFlag::INVERT_Y;
+    else if (wrapping_mode == WrappingMode::MIRRORED_REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT),
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
 
-        glBindTexture(GL_TEXTURE_2D, previous_texture);
+    else if (wrapping_mode == WrappingMode::CLAMP_TO_BORDER)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER),
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
 
+    if (filtering_mode == FilteringMode::NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST),
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+    else if (filtering_mode == FilteringMode::BILINEAR)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR),
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    else if (filtering_mode == FilteringMode::MIPMAP_NEAREST ||
+            filtering_mode == FilteringMode::MIPMAP_BILINEAR ||
+            filtering_mode == FilteringMode::MIPMAP_TRILINEAR) {
+
+        glGenerateMipmap(GL_TEXTURE_2D);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+
+        if (filtering_mode == FilteringMode::MIPMAP_NEAREST)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST),
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+        else if (filtering_mode == FilteringMode::MIPMAP_BILINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST),
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        else if (filtering_mode == FilteringMode::MIPMAP_TRILINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR),
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     }
+    glBindTexture(GL_TEXTURE_2D, previous_texture);
+}
 
-    void Texture::load(Image* software_texture, const Vector2& size, const TextureFormat& format,
-                           TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
+std::vector<Color4> JGL::Texture::GetPixelData() const {
+    GLint current_texture;
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
-        GLuint previous_texture;
-        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
-
-            glGenTextures(1, &texture_handle);
-            glBindTexture(GL_TEXTURE_2D, texture_handle);
-
-            if (format == TextureFormat::RGBA)
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (int) size.x, (int) size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                             software_texture->pixel_data.data());
-
-            else if (format == TextureFormat::RGB)
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (int) size.x, (int) size.y, 0, GL_RGB, GL_UNSIGNED_BYTE,
-                             software_texture->pixel_data.data());
-
-            if (wrapping_mode == TextureWrappingMode::CLAMP_TO_EDGE)
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-            else if (wrapping_mode == TextureWrappingMode::REPEAT)
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-
-            else if (wrapping_mode == TextureWrappingMode::MIRRORED_REPEAT)
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
-
-            else if (wrapping_mode == TextureWrappingMode::CLAMP_TO_BORDER)
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-            if (filtering_mode == TextureFilteringMode::NEAREST)
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-            else if (filtering_mode == TextureFilteringMode::BILINEAR)
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR),
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-            else if (filtering_mode == TextureFilteringMode::MIPMAP_NEAREST ||
-                     filtering_mode == TextureFilteringMode::MIPMAP_BILINEAR ||
-                     filtering_mode == TextureFilteringMode::MIPMAP_TRILINEAR) {
-
-                glGenerateMipmap(GL_TEXTURE_2D);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-
-                if (filtering_mode == TextureFilteringMode::MIPMAP_NEAREST)
-                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST),
-                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-
-                else if (filtering_mode == TextureFilteringMode::MIPMAP_BILINEAR)
-                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST),
-                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-                else if (filtering_mode == TextureFilteringMode::MIPMAP_TRILINEAR)
-                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR),
-                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            }
-            texture_size = size;
-            texture_format = format;
-            texture_filtering_mode = filtering_mode;
-            glBindTexture(GL_TEXTURE_2D, previous_texture);
-    }
-
-    std::vector<Color4> JGL::Texture::GetPixelData() const {
-        GLint current_texture;
-        glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
-
-        std::vector<Color4> result((size_t) (texture_size.x * texture_size.y));
-        glBindTexture(GL_TEXTURE_2D, texture_handle);
-
-        if (texture_format == TextureFormat::RGBA) {
-            glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.data());
-            glBindTexture(GL_TEXTURE_2D, current_texture);
-            return result;
-        }
-
-        //if RGB
-        std::vector<Color3> color3((size_t) (texture_size.x * texture_size.y));
-        glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, color3.data());
-        for (const auto &c: color3)
-            result.emplace_back(c);
+    std::vector<Color4> result((size_t) (size.x * size.y));
+    glBindTexture(GL_TEXTURE_2D, texture_handle);
 
+    if (format == ColorFormat::RGBA) {
+        glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.data());
         glBindTexture(GL_TEXTURE_2D, current_texture);
         return result;
     }
 
-    void Texture::Erase() {
-        if (texture_handle != 0)
-            glDeleteTextures(1, &texture_handle);
-        texture_handle = 0;
+    //if RGB
+    std::vector<Color3> color3((size_t) (size.x * size.y));
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGB, GL_UNSIGNED_BYTE, color3.data());
+    for (const auto &c: color3)
+        result.emplace_back(c);
+
+    glBindTexture(GL_TEXTURE_2D, current_texture);
+    return result;
+}
+
+GLuint Texture::GetHandle() const {
+    return texture_handle;
+}
+
+Vector2i Texture::GetDimensions() const {
+    return size;
+}
+
+bool Texture::Inverted() const {
+    return invert_y;
+}
+
+ColorFormat Texture::GetFormat() const {
+    return format;
+}
+
+FilteringMode Texture::GetFilteringMode() const {
+    return filtering_mode;
+}
+
+WrappingMode Texture::GetWrappingMode() const {
+    return wrapping_mode;
+}
+
+Texture::Texture(const Color4* pixels, const Vector2i& size, const ColorFormat& format, FilteringMode filtering_mode, WrappingMode wrapping_mode) :
+ size(size), format(format), filtering_mode(filtering_mode), wrapping_mode(wrapping_mode) {
+    load((unsigned char*) pixels);
+}
+
+Texture::Texture(const Color3* pixels, const Vector2i& size, const ColorFormat& format, FilteringMode filtering_mode, WrappingMode wrapping_mode) :
+size(size), format(format), filtering_mode(filtering_mode), wrapping_mode(wrapping_mode) {
+    load((unsigned char*) pixels);
+}
+
+Texture::~Texture() {
+    if (texture_handle != 0)
+        glDeleteTextures(1, &texture_handle);
+    texture_handle = 0;
+}
+
+Texture::Texture(const Texture& rhs) {
+    auto* this_texture = new Texture(rhs.GetDimensions());
+    auto this_render_target = RenderTarget(this_texture);
+    auto rhs_render_target = RenderTarget(&rhs);
+
+    RenderTarget::Blit(rhs_render_target, &this_render_target);
+
+    this->texture_handle = this_texture->texture_handle;
+    this->size = this_texture->size;
+    this->invert_y = this_texture->invert_y;
+    this->format = this_texture->format;
+    this->filtering_mode = this_texture->filtering_mode;
+    this->wrapping_mode = this_texture->wrapping_mode;
+    operator delete(this_texture);
+}
+
+Texture::Texture(const Texture* textures, const size_t& texture_count) {
+    int length = 0;
+    int biggest_y = 0;
+
+    for (int i = 0; i < texture_count; i++) {
+        if (biggest_y < textures[i].size.y)
+            biggest_y = textures[i].size.y;
+        length += textures[i].size.x;
     }
 
-    GLuint Texture::GetGLTextureHandle() const {
-        return texture_handle;
+    auto* result = new Texture(Vector2i(length, biggest_y));
+    auto render_target = RenderTarget(result);
+
+    int next_x = 0;
+    for (int i = 0; i < texture_count; i++) {
+        RenderTarget::Blit(&textures[i], &render_target, Vector2i(next_x, 0));
+        next_x += textures[i].GetDimensions().x;
     }
-
-    Vector2 Texture::GetDimensions() const {
-        return texture_size;
-    }
-
-    TextureFlag Texture::GetFlags() const {
-        return texture_flags;
-    }
-
-    TextureFormat Texture::GetFormat() const {
-        return texture_format;
-    }
-
-    TextureFilteringMode Texture::GetFilteringMode() const {
-        return texture_filtering_mode;
-    }
-
-    TextureWrappingMode Texture::GetWrappingMode() const {
-        return texture_wrapping_mode;
-    }
-
-    Texture::Texture(Image* software_texture, const Vector2& size, const TextureFormat& format,
-                     TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
-        load(software_texture, size, format, filtering_mode, wrapping_mode);
-    }
-
-    Texture::~Texture() {
-        Erase();
-    }
-
-    Texture::Texture(const Texture& rhs) {
-        auto* this_texture = new Texture(rhs.GetDimensions());
-        auto this_render_target = RenderTarget(this);
-        auto rhs_render_target = RenderTarget(&rhs);
-
-        RenderTarget::Blit(rhs_render_target, &this_render_target);
-
-        this->texture_handle = this_texture->texture_handle;
-        this->texture_size = this_texture->texture_size;
-        this->texture_flags = this_texture->texture_flags;
-        this->texture_format = this_texture->texture_format;
-        this->texture_filtering_mode = this_texture->texture_filtering_mode;
-        this->texture_wrapping_mode = this_texture->texture_wrapping_mode;
-
-        // Free the memory of "this_texture" without calling the destructor.
-        // In 99% of cases you wouldn't want this. But in this scenario we do.
-        operator delete(this_texture);
-    }
-
-    Texture::Texture(const Texture* textures, const size_t& texture_count) {
-        float length = 0;
-        float biggest_y = 0;
-
-        for (int i = 0; i < texture_count; i++) {
-            if (biggest_y < textures[i].texture_size.y)
-                biggest_y = textures[i].texture_size.y;
-            length += textures[i].texture_size.x;
-        }
-
-        auto* result = new Texture(Vector2(length, biggest_y));
-        auto render_target = RenderTarget(result);
-
-        int next_x = 0;
-        for (int i = 0; i < texture_count; i++) {
-            RenderTarget::Blit(&textures[i], &render_target, Vector2i(next_x, 0));
-            next_x += textures[i].GetDimensions().x;
-        }
-    }
-}
+}