Bugfix + Begin work on RenderTarget

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

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;