Bugfix + Begin work on RenderTarget

Fixed an issue that'd sometimes cause declaring a new texture to change to that texture.

CMakeLists.txt

@@ -32,7 +32,7 @@ CPMAddPackage(
 
 CPMAddPackage(
         NAME GLAD
-        URL https://git.redacted.cc/Redacted/glad/archive/v2.1ext_mt.zip
+        URL https://git.redacted.cc/Redacted/glad/archive/v2.1ext_fbo.zip
 )
 
 CPMAddPackage(

include/JGL/JGL.h

@@ -13,12 +13,9 @@
 #pragma once
 
 #include <string>
-#include <iostream>
-#include <Color3.hpp>
 #include <Color4.hpp>
-#include <Colors.hpp>
 #include <JGL/types/Texture.h>
-#include <JGL/types/enums.h>
+#include <JGL/types/Enums.h>
 #include <JGL/types/FontCache.h>
 #include <JGL/types/Font.h>
 #include <J3ML/LinearAlgebra.hpp>
@@ -26,41 +23,19 @@
 #include <J3ML/LinearAlgebra/Vector3.hpp>
 #include <J3ML/Geometry/Sphere.hpp>
 #include <J3ML/Geometry/Capsule.hpp>
-#include <J3ML/Geometry/TriangleMesh.hpp>
+#include <J3ML/Geometry/Triangle2D.hpp>
 #include <JGL/Logger.h>
 
-
-/// OpenGL Wrapper for rendering 2D graphics primitives in both a 2D and 3D context
+/// OpenGL Wrapper for rendering 2D & 3D graphics in both a 2D and 3D context.
 namespace JGL {
     using namespace J3ML::LinearAlgebra;
     using namespace J3ML::Geometry;
 
-    /// TODO: Implement HSV and other color representation conversions
-    struct HSV {
-        float hue;
-        float saturation;
-        float value;
-    };
-
-    /// TODO: Migrate to using J3ML's definition once finished (hint hint)
-    struct Triangle2D
-    {
-        Vector2 A;
-        Vector2 B;
-        Vector2 C;
-    };
-
     void Update(const Vector2& window_size);
-    void PurgeFontCache();
-
-    // TODO: Implement
-    void SetActiveFont(const Font& font);
-
-    // TODO: Overrides specifically for Color3 are not **strictly** necessary, Color3 and Color4 should implicitly convert back and forth.
-
+    inline void PurgeFontCache() { fontCache.purgeCache(); }
+    std::vector<GLfloat> OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far);
 
     /// Drawing functions for primitive 2D Shapes.
-    /// Each function is overloaded with Color3 and Color4 for optional transparency.
     namespace J2D {
         /// Open a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
         /// @note This call may not strictly be necessary on some setups, but is provided to keep the API constant.
@@ -92,6 +67,15 @@ namespace JGL {
         /// Draws an outline of a rectangle on the screen.
         void OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness = 1);
 
+        /// Draws a filled rectangle on the screen.
+        void FillRect(const Color4& color, const Vector2& pos, const Vector2& size);
+
+        /// Draws a filled rectangle where the color transitions across it.
+        void FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size);
+
+        /// Draws a filled rectangle with rounded corners on the screen.
+        void FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, unsigned int subdivisions = 8);
+
         /// Draws a sprite to the screen by passing a G̶L̶u̶i̶n̶t̶ JGL Texture that represents a handle to a loaded texture.
         /// @param texture
         /// @param position
@@ -136,15 +120,6 @@ namespace JGL {
         /// @param color
         void DrawMirrorSprite(const Texture& texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);
 
-        /// Draws a filled rectangle on the screen.
-        void FillRect(const Color4& color, const Vector2& pos, const Vector2& size);
-
-        /// Draws a filled rectangle where the color transitions across it.
-        void FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size);
-
-        /// Draws a filled rectangle with rounded corners on the screen.
-        void FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, unsigned int subdivisions = 8);
-
         /// Draws an outline of a circle on the screen.
         void OutlineCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 16, float thickness = 1);
 
@@ -165,16 +140,15 @@ namespace JGL {
         /// Draws a triangle where each corner is defined by a given color, Smoothly transitioning between them.
         void FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Triangle2D& tri);
 
-
-        /// Draws a text string on the screen with a given point-size and font.
-        void DrawString(const Color4& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font);
-
         void DrawCubicBezierCurve(const Color4& color, const Vector2& controlA, const Vector2& pointA, const Vector2& pointB, const Vector2& controlB,
                                   int subdivisions = 10, float thickness = 1);
 
         /// Draws a series of points where the last point always connects to the first point.
         void OutlinePolygon(const Color4& color, const std::vector<Vector2>& points, float thickness = 1);
 
+        /// Draws a text string on the screen with a given point-size and font.
+        void DrawString(const Color4& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font);
+
         /// TODO Implement the following. These ones are going to be extremely annoying.
         void FillPolygon(const Color4& color, const std::vector<Vector2>& points);
         void FillTexturedPolygon();

include/JGL/types/RenderTarget.h

@@ -0,0 +1,25 @@
+#pragma once
+#include <glad/glad.h>
+#include <JGL/types/Texture.h>
+#include <Color4.hpp>
+#include <Colors.hpp>
+
+namespace JGL {
+    class RenderTarget;
+}
+
+class JGL::RenderTarget {
+private:
+    Color4 background_color = {0,0,0,0};
+    GLuint framebuffer_object = 0;
+    GLuint depth_buffer = 0;
+    Texture texture;
+public:
+    static GLuint GetActiveGLRenderTargetHandle();
+    static void SetActiveGLRenderTarget(const RenderTarget& render_target);
+public:
+    [[nodiscard]] Texture GetGLTexture();
+    [[nodiscard]] GLuint GetGLTextureHandle();
+    [[nodiscard]] GLuint GetGLFramebufferObjectHandle();
+    [[nodiscard]] GLuint GetGLDepthBufferHandle();
+};

include/JGL/types/Texture.h

@@ -32,10 +32,16 @@ namespace JGL {
         ReTexture::TextureFormat texture_format;
         TextureFilteringMode texture_filtering_mode;
         TextureWrappingMode texture_wrapping_mode;
-        virtual void load(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
+        void load(SoftwareTexture* 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);
         Texture(const std::string& file, const TextureFlag& flags, TextureFilteringMode filtering_mode = TextureFilteringMode::BILINEAR, TextureWrappingMode wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE);
+        /* Initialize a texture filled with trash data
+        this is primarily for the RenderTarget */
+        explicit Texture(const Vector2& size);
+        /* Initialize a texture that is a single color */
+        Texture(const Color4& color, const Vector2& size);
         Texture() = default;
     public:
         [[nodiscard]] GLuint GetGLTextureHandle() const;

src/JGL.cpp

@@ -4,7 +4,6 @@
 
 #include <JGL/JGL.h>
 #include <glad/glad.h>
-#include <Color3.hpp>
 #include <jlog/Logger.hpp>
 #include <J3ML/Algorithm/Bezier.hpp>
 
@@ -30,6 +29,7 @@ namespace JGL {
         glViewport(0, 0, (int) wS.x, (int) wS.y);
     }
 
+#pragma region J2D
     void J2D::Begin() {
         glMatrixMode(GL_PROJECTION);
         glPushMatrix();
@@ -135,6 +135,130 @@ namespace JGL {
         inJ2D = false;
     }
 
+    void J2D::DrawPoint(const Color4& color, const Vector2& coordinates, float radius) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        Vector2 vertices[] = {coordinates};
+
+        glPointSize(radius);
+        glColor4ubv(color.ptr());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_POINTS, 0, 1);
+        glColor4fv(baseColor);
+    }
+
+    void J2D::DrawPoint(const Color4& color, float x, float y, float radius) {
+        DrawPoint(color, {x, y}, radius);
+    }
+
+    void J2D::DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+        Vector2 vertices[] = {A, B};
+
+        glLineWidth(thickness);
+        glColor4ubv(color.ptr());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_LINES, 0, 2);
+        glColor4fv(baseColor);
+    }
+
+    void J2D::DrawLine(const Color4& color, float x, float y, float w, float h, float thickness) {
+        J2D::DrawLine(color, {x, y}, {w, h}, thickness);
+    }
+
+    void J2D::DrawGradientLine(const Color4& color1, const Color4& color2, const Vector2& A, const Vector2& B, float thickness) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        Vector2 vertices[] = {A, B};
+        GLfloat colors[8] = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),
+                             color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized() };
+
+        glEnableClientState(GL_COLOR_ARRAY);
+        glLineWidth(thickness);
+        glColorPointer(4,GL_FLOAT,sizeof(Color4), colors);
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_LINES, 0, 2);
+        glDisableClientState(GL_COLOR_ARRAY);
+        glColor4fv(baseColor);
+    }
+
+    void DrawGradientLine(const Color4& color1, const Color4& color2, float x, float y, float w, float h, float thickness) {
+        J2D::DrawGradientLine(color1, color2, {x, y}, {w, h}, thickness);
+    }
+
+    void J2D::OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
+
+        glLineWidth(thickness);
+        glColor4ubv(color.ptr());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_LINE_LOOP, 0, 4);
+        glColor4fv(baseColor);
+    }
+
+    void J2D::FillRect(const Color4& color, const Vector2& pos, const Vector2& size) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
+        glColor4ubv(color.ptr());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_QUADS, 0, 4);
+        glColor4fv(baseColor);
+    }
+
+    void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
+        std::vector<GLfloat> colors{};
+
+        if (gradient == Direction::Horizontal)
+            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),
+                      color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(), color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized()};
+
+        else if (gradient == Direction::Vertical)
+            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(),
+                      color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(), color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized()};
+
+        else if (gradient == Direction::Diagonal_SWNE)
+            colors = {(color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f, (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f,
+                      color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), (color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f,
+                      (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f, color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized()};
+
+        else if (gradient == Direction::Diagonal_NWSE)
+            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),(color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f,
+                      (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f, color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(),
+                      (color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f, (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f,(color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f};
+
+        glEnableClientState(GL_COLOR_ARRAY);
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glColorPointer(4, GL_FLOAT, 0, colors.data());
+        glDrawArrays(GL_QUADS, 0, 4);
+        glDisableClientState(GL_COLOR_ARRAY);
+        glColor4fv(baseColor);
+    }
+
+    void J2D::FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius, unsigned int subdivisions) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        J2D::FillRect(color, {pos.x + radius, pos.y}, {size.x - 2 * radius, size.y});
+        J2D::FillRect(color, {pos.x, pos.y + radius}, {size.x, size.y - 2 * radius});
+
+        J2D::FillCircle(color, {pos.x + radius, pos.y + radius}, radius, subdivisions);
+        J2D::FillCircle(color, {pos.x + size.x - radius, pos.y + radius}, radius, subdivisions);
+        J2D::FillCircle(color, {pos.x + radius, pos.y + size.y - radius}, radius, subdivisions);
+        J2D::FillCircle(color, {pos.x + size.x - radius, pos.y + size.y - radius}, radius, subdivisions);
+    }
+
     void J2D::DrawSprite(const Texture& texture, const Vector2& pos, float rad_rotation, const Vector2& origin,
                          const Vector2& scale, const Color4& color, Direction inversion) {
         if (!inJ2D)
@@ -336,144 +460,6 @@ namespace JGL {
         glColor4fv(baseColor);
     }
 
-    void J2D::FillRect(const Color4& color, const Vector2& pos, const Vector2& size) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
-        glColor4ubv(color.ptr());
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-        glDrawArrays(GL_QUADS, 0, 4);
-        glColor4fv(baseColor);
-    }
-
-    void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
-        std::vector<GLfloat> colors{};
-
-        if (gradient == Direction::Horizontal)
-            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),
-                      color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(), color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized()};
-
-        else if (gradient == Direction::Vertical)
-            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(),
-                      color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(), color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized()};
-
-        else if (gradient == Direction::Diagonal_SWNE)
-            colors = {(color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f, (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f,
-                      color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), (color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f,
-                      (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f, color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized()};
-
-        else if (gradient == Direction::Diagonal_NWSE)
-            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),(color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f,
-                      (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f, color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(),
-                      (color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f, (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f,(color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f};
-
-        glEnableClientState(GL_COLOR_ARRAY);
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-        glColorPointer(4, GL_FLOAT, 0, colors.data());
-        glDrawArrays(GL_QUADS, 0, 4);
-        glDisableClientState(GL_COLOR_ARRAY);
-        glColor4fv(baseColor);
-    }
-
-    void J2D::FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius, unsigned int subdivisions) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        J2D::FillRect(color, {pos.x + radius, pos.y}, {size.x - 2 * radius, size.y});
-        J2D::FillRect(color, {pos.x, pos.y + radius}, {size.x, size.y - 2 * radius});
-
-        J2D::FillCircle(color, {pos.x + radius, pos.y + radius}, radius, subdivisions);
-        J2D::FillCircle(color, {pos.x + size.x - radius, pos.y + radius}, radius, subdivisions);
-        J2D::FillCircle(color, {pos.x + radius, pos.y + size.y - radius}, radius, subdivisions);
-        J2D::FillCircle(color, {pos.x + size.x - radius, pos.y + size.y - radius}, radius, subdivisions);
-    }
-
-    void J2D::OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
-
-        glLineWidth(thickness);
-        glColor4ubv(color.ptr());
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-        glDrawArrays(GL_LINE_LOOP, 0, 4);
-        glColor4fv(baseColor);
-    }
-
-    void J2D::DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-        Vector2 vertices[] = {A, B};
-
-        glLineWidth(thickness);
-        glColor4ubv(color.ptr());
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-        glDrawArrays(GL_LINES, 0, 2);
-        glColor4fv(baseColor);
-    }
-
-    void J2D::DrawLine(const Color4& color, float x, float y, float w, float h, float thickness) {
-        J2D::DrawLine(color, {x, y}, {w, h}, thickness);
-    }
-
-    void J2D::DrawGradientLine(const Color4& color1, const Color4& color2, const Vector2& A, const Vector2& B, float thickness) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        Vector2 vertices[] = {A, B};
-        GLfloat colors[8] = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),
-                             color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized() };
-
-        glEnableClientState(GL_COLOR_ARRAY);
-        glLineWidth(thickness);
-        glColorPointer(4,GL_FLOAT,sizeof(Color4), colors);
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-        glDrawArrays(GL_LINES, 0, 2);
-        glDisableClientState(GL_COLOR_ARRAY);
-        glColor4fv(baseColor);
-    }
-
-    void DrawGradientLine(const Color4& color1, const Color4& color2, float x, float y, float w, float h, float thickness) {
-        J2D::DrawGradientLine(color1, color2, {x, y}, {w, h}, thickness);
-    }
-
-    void J2D::OutlinePolygon(const Color4 &color, const std::vector<Vector2>& points, float thickness) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        if (points.front() != points.back())
-            throw std::runtime_error("J2D::OutlinePolygon: The first point and the last point must connect.");
-
-        glLineWidth(thickness);
-        glColor4ubv(color.ptr());
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), points.data());
-        glDrawArrays(GL_LINE_LOOP, 0, (int) points.size());
-        glColor4fv(baseColor);
-    }
-
-    void J2D::DrawPoint(const Color4& color, const Vector2& coordinates, float radius) {
-        if (!inJ2D)
-            jlog::Error("Drawing J2D element before J2D begin.");
-
-        Vector2 vertices[] = {coordinates};
-
-        glPointSize(radius);
-        glColor4ubv(color.ptr());
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-        glDrawArrays(GL_POINTS, 0, 1);
-        glColor4fv(baseColor);
-    }
-
-    void J2D::DrawPoint(const Color4& color, float x, float y, float radius) {
-        DrawPoint(color, {x, y}, radius);
-    }
-
     void J2D::OutlineCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions, float thickness) {
         if (!inJ2D)
             jlog::Error("Drawing J2D element before J2D begin.");
@@ -502,12 +488,10 @@ namespace JGL {
         GLfloat angle, x, y;
         float step =  (2.f * Math::Pi) / (float) subdivisions;
         std::vector<Vector2> vertices{};
-
         for (angle = 0.0f; angle < (2.f * Math::Pi); angle += step)
                 x = radius * std::sin(angle) + center.x,
                 y = radius * std::cos(angle) + center.y,
                 vertices.emplace_back(x, y);
-
         glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
         glDrawArrays(GL_TRIANGLE_FAN, 0, (int) vertices.size());
@@ -574,15 +558,31 @@ namespace JGL {
         DrawLine(color, last, first, thickness);
     }
 
-    //The 3D projection.
-    std::vector<GLfloat> perspective(float fov, float aspect, float nearPlane, float farPlane) {
-        std::vector<float> result(16);
-        float f = 1.0f / std::tan(fov * 0.5f * Math::Pi / 180.0f);
+    void J2D::OutlinePolygon(const Color4 &color, const std::vector<Vector2>& points, float thickness) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        if (points.front() != points.back())
+            throw std::runtime_error("J2D::OutlinePolygon: The first point and the last point must connect.");
+
+        glLineWidth(thickness);
+        glColor4ubv(color.ptr());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), points.data());
+        glDrawArrays(GL_LINE_LOOP, 0, (int) points.size());
+        glColor4fv(baseColor);
+    }
+
+#pragma endregion
+
+#pragma region J3D
+    std::vector<GLfloat> OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far) {
+        std::vector<GLfloat> result(16);
+        GLfloat f = 1.0f / std::tan(fovY * 0.5f * Math::Pi / 180.0f);
         result[0] = f / aspect;
         result[5] = f;
-        result[10] = (farPlane + nearPlane) / (nearPlane - farPlane);
+        result[10] = (z_far + z_near) / (z_near - z_far);
         result[11] = -1.0f;
-        result[14] = (2.0f * farPlane * nearPlane) / (nearPlane - farPlane);
+        result[14] = (2.0f * z_far * z_near) / (z_near - z_far);
         return result;
     }
 
@@ -612,7 +612,7 @@ namespace JGL {
         auto aspect = (float) wS.x / (float) wS.y;
         glMatrixMode(GL_PROJECTION);
         glLoadIdentity();
-        glMultMatrixf(perspective(j3d_fov, aspect, 0.001, j3d_far_plane).data());
+        glMultMatrixf(OpenGLPerspectiveProjectionRH(j3d_fov, aspect, 0.001, j3d_far_plane).data());
         glMatrixMode(GL_MODELVIEW);
 
         //Get what the draw color was before we did anything.
@@ -695,4 +695,5 @@ namespace JGL {
         glDrawArrays(GL_LINES, 0, 2);
         glColor4fv(baseColor);
     }
+#pragma endregion
 }

src/TextRendering.cpp

@@ -18,11 +18,6 @@
 #include <JGL/Logger.h>
 
 namespace JGL {
-
-    void PurgeFontCache() {
-        fontCache.purgeCache();
-    }
-
     CachedFont* CacheFont(const Font& font, u32 size) {
         CachedFont* cachedFont;
         FT_Set_Pixel_Sizes(font.face, 0, size);
@@ -78,13 +73,14 @@ namespace JGL {
             GLfloat v0 = 0.0f;
             GLfloat v1 = (GLfloat)g->bitmap.rows / cachedFont->getTextureHeight();
 
-            std::array<GLfloat, 12> texcoords = {
-                    u0, v0,
-                    u0, v1,
-                    u1, v1,
-                    u0, v0,
-                    u1, v1,
-                    u1, v0
+            std::array<GLfloat, 12> texcoords
+            {
+                u0, v0,
+                u0, v1,
+                u1, v1,
+                u0, v0,
+                u1, v1,
+                u1, v0
             };
 
             cachedFont->appendGlyph(new CachedGlyph((char)charcode, texcoords, g->bitmap_left, g->bitmap_top, g->bitmap.width, g->bitmap.rows, (g->advance.x >> 6), (g->advance.y >> 6)));
@@ -128,7 +124,8 @@ namespace JGL {
             x += glyph->advanceX * scale;
             y += glyph->advanceY * scale;
 
-            std::array<GLfloat, 12> glyph_vertices = {
+            std::array<GLfloat, 12> glyph_vertices
+            {
                 x2,     y2,
                 x2,     y2 + h,
                 x2 + w, y2 + h,
@@ -184,13 +181,14 @@ namespace JGL {
             float w = glyph->w * scale;
             float h = glyph->h * scale;
 
-            std::array<GLfloat, 18> glyph_vertices = {
-                    x2,     y2,     z,
-                    x2,     y2 + h, z,
-                    x2 + w, y2 + h, z,
-                    x2,     y2,     z,
-                    x2 + w, y2 + h, z,
-                    x2 + w, y2,     z
+            std::array<GLfloat, 18> glyph_vertices
+            {
+                x2,     y2,     z,
+                x2,     y2 + h, z,
+                x2 + w, y2 + h, z,
+                x2,     y2,     z,
+                x2 + w, y2 + h, z,
+                x2 + w, y2,     z
             };
 
             vertices[i] = glyph_vertices;

src/types/RenderTarget.cpp

@@ -0,0 +1,28 @@
+#include <JGL/types/RenderTarget.h>
+
+JGL::Texture JGL::RenderTarget::GetGLTexture() {
+    return texture;
+}
+
+GLuint JGL::RenderTarget::GetGLTextureHandle() {
+    return texture.GetGLTextureHandle();
+}
+
+GLuint JGL::RenderTarget::GetGLFramebufferObjectHandle() {
+    return framebuffer_object;
+}
+
+GLuint JGL::RenderTarget::GetGLDepthBufferHandle() {
+    return depth_buffer;
+}
+
+GLuint JGL::RenderTarget::GetActiveGLRenderTargetHandle() {
+    GLuint fbo;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &fbo);
+    return fbo;
+}
+
+void JGL::RenderTarget::SetActiveGLRenderTarget(const RenderTarget& render_target) {
+    RenderTarget rt = render_target;
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, rt.GetGLFramebufferObjectHandle());
+}

src/types/Texture.cpp

@@ -5,29 +5,91 @@ using namespace ReTexture;
 
 namespace JGL
 {
-    Texture::Texture(const std::string &file, const ReTexture::TextureFlag &flags, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode)
+    Texture::Texture(const std::string& file, const ReTexture::TextureFlag& flags, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode)
     {
         auto *t = new ReTexture::SoftwareTexture(file, flags);
 
+        GLuint previous_texture;
+        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
 
-        load(t, {(float) t->getWidth(), (float) t->getHeight()}, t->getTextureFormat(), filtering_mode,
-             wrapping_mode);
+        load(t, {(float) t->getWidth(), (float) t->getHeight()}, t->getTextureFormat(), filtering_mode, wrapping_mode);
         texture_flags = flags;
 
         delete t;
+
+        glBindTexture(GL_TEXTURE_2D, previous_texture);
     }
 
-    Texture::Texture(const std::string &file, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
-        auto *t = new SoftwareTexture(file);
+    Texture::Texture(const std::string& file, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
+        GLuint previous_texture;
+        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
 
-        load(t, {(float) t->getWidth(), (float) t->getHeight()}, t->getTextureFormat(), filtering_mode,
-             wrapping_mode);
+        auto* t = new SoftwareTexture(file);
+
+        load(t, {(float) t->getWidth(), (float) t->getHeight()}, t->getTextureFormat(), filtering_mode, wrapping_mode);
         texture_flags = TextureFlag::NONE;
 
         delete t;
+        glBindTexture(GL_TEXTURE_2D, previous_texture);
     }
 
-    void Texture::load(SoftwareTexture *software_texture, const Vector2 &size, const TextureFormat &format,
+    Texture::Texture(const Color4& color, const Vector2& size) {
+        GLuint previous_texture;
+        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
+
+        glGenTextures(1, &texture_handle);
+        glBindTexture(GL_TEXTURE_2D, texture_handle);
+
+        //Bilinear
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        //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);
+
+        auto* pixel_data = new std::vector<Color4>(size.x * size.y);
+
+        for (unsigned int i = 0; i < (unsigned int) (size.x * size.y); i++)
+            pixel_data->at(i) = color;
+
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (int) size.x, (int) size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixel_data->data());
+        delete pixel_data;
+
+        texture_format = TextureFormat::RGBA;
+        texture_size = size;
+        texture_filtering_mode = TextureFilteringMode::BILINEAR;
+        texture_wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE;
+        texture_flags = TextureFlag::NONE;
+
+        glBindTexture(GL_TEXTURE_2D, previous_texture);
+    }
+
+    Texture::Texture(const Vector2& size) {
+        GLuint previous_texture;
+        glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
+
+        glGenTextures(1, &texture_handle);
+        glBindTexture(GL_TEXTURE_2D, texture_handle);
+
+        //Bilinear
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        //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, (int) size.x, (int) size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+        texture_format = TextureFormat::RGBA;
+        texture_size = size;
+        texture_filtering_mode = TextureFilteringMode::BILINEAR;
+        texture_wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE;
+        texture_flags = TextureFlag::NONE;
+
+        glBindTexture(GL_TEXTURE_2D, previous_texture);
+    }
+
+    void Texture::load(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format,
                            TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
             glGenTextures(1, &texture_handle);
             glBindTexture(GL_TEXTURE_2D, texture_handle);
@@ -92,22 +154,20 @@ namespace JGL
 
                 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);
+                    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);
+                    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);
+                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
                 delete m1;
                 delete m2;
                 delete m3;
             }
-            glBindTexture(GL_TEXTURE_2D, 0);
-
             texture_size = size;
             texture_format = format;
             texture_filtering_mode = filtering_mode;