Multi-Sample-Anti-Alias.

include/JGL/JGL.h

@@ -82,8 +82,12 @@ namespace JGL {
         /// 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);
 
-        void DrawRenderTargetAsSprite(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
+        /// Draws a render target to the screen.
+        void DrawRenderTarget(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
+                              const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+        void DrawSprite(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),
                 const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
+
         /// 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

include/JGL/types/Enums.h

@@ -17,7 +17,7 @@ namespace JGL {
         return (u8)a & (u8)b;
     }
 
-    static std::string to_string(JGL::Direction direction) {
+    static std::string to_string(const JGL::Direction& direction) {
         switch (direction) {
             case JGL::Direction::None:
                 return "None";
@@ -33,4 +33,40 @@ namespace JGL {
                 return "Unknown";
         }
     }
+
+    enum class MSAA_SAMPLE_RATE : u8 {
+        MSAA_NONE = 0,
+        MSAA_2X = 1,
+        MSAA_4X = 2,
+        MSAA_8X = 3
+    };
+
+    static std::string to_string(const JGL::MSAA_SAMPLE_RATE& sample_rate) {
+        switch (sample_rate) {
+            case MSAA_SAMPLE_RATE::MSAA_NONE:
+                return "No MSAA";
+            case MSAA_SAMPLE_RATE::MSAA_2X:
+                return "MSAA 2x";
+            case MSAA_SAMPLE_RATE::MSAA_4X:
+                return "MSAA 4x";
+            case MSAA_SAMPLE_RATE::MSAA_8X:
+                return "MSAA 8x";
+            default:
+                return "Unknown";
+        }
+    }
+    static int to_int(const JGL::MSAA_SAMPLE_RATE& sample_rate) {
+        switch (sample_rate) {
+            case MSAA_SAMPLE_RATE::MSAA_NONE:
+                return 0;
+            case MSAA_SAMPLE_RATE::MSAA_2X:
+                return 2;
+            case MSAA_SAMPLE_RATE::MSAA_4X:
+                return 4;
+            case MSAA_SAMPLE_RATE::MSAA_8X:
+                return 8;
+            default:
+                return 0;
+        }
+    }
 }

include/JGL/types/RenderTarget.h

@@ -3,12 +3,14 @@
 #include <JGL/types/Texture.h>
 #include <Color4.hpp>
 #include <Colors.hpp>
+#include <JGL/types/Enums.h>
 
 namespace JGL {
     class RenderTarget;
 }
 
 //TODO copy constructor for this. Copying this as it is and then that copy going out of scope will crash the program as it sits.
+//If you do copy it you're doing it wrong. But still.
 
 class JGL::RenderTarget {
 private:
@@ -20,19 +22,30 @@ private:
     GLuint framebuffer_object = 0;
     GLuint depth_buffer = 0;
     Texture* texture = nullptr;
+    MSAA_SAMPLE_RATE msaa_sample_rate = MSAA_SAMPLE_RATE::MSAA_NONE;
+    GLuint msaa_framebuffer_object = 0;
+    GLuint msaa_depth_buffer = 0;
+    GLuint msaa_render_buffer = 0;
     void Erase();
 public:
     static GLuint GetActiveGLFramebufferHandle();
     static void SetActiveGLRenderTarget(const RenderTarget& render_target);
 
-    /** Change the size of the renderable area of the Render Target.
-    * If the new size is larger than the non-renderable area the texture will be resized to fit. */
+    /** Change the size of the renderable area of the Render Target. **/
     /// @param new_size new size in px.
-    /// @param clear whether or not the data currently in the RenderTarget is to be kept.
-    /// @note Clearing the FBO on Resize is *much* faster than keeping the data because we don't have to read back.
     void Resize(const Vector2& new_size);
+    void SetMSAAEnabled(MSAA_SAMPLE_RATE sample_rate);
+    /// Blits the MSAA FBO onto the regular FBO if MSAA is enabled.
+    /// Does nothing is MSAA is not enabled or if the color attachment is a texture not created by the RenderTarget.
+    void Blit() const;
+    [[nodiscard]] bool TextureCreatedByRenderTarget() const;
 public:
     [[nodiscard]] Vector2 GetDimensions() const;
+    [[nodiscard]] MSAA_SAMPLE_RATE GetMSAASampleRate() const;
+    /// Returns whether or not MSAA is enabled, If it is and you're not using J2D || J3D Begin / End,
+    /// You need to run "Blit()" after rendering to your FBO before you show it.
+    /// @note Also, If the texture wasn't made by the RenderTarget you don't want this. It would destroy the texture.
+    [[nodiscard]] bool MSAAEnabled() const;
     [[nodiscard]] Texture* GetJGLTexture() const;
     [[nodiscard]] GLuint GetGLTextureHandle() const;
     [[nodiscard]] GLuint GetGLFramebufferObjectHandle() const;
@@ -44,6 +57,6 @@ public:
     /// Create a render target for a texture that already exists. For adding to an existing texture.
     explicit RenderTarget(Texture* texture, const Color4& clear_color = Colors::Black);
     /// Create a Render Target with a brand new texture. Want to render JGL elements onto a texture and display it as a sprite?
-    explicit RenderTarget(const Vector2& size,  const Color4& clear_color = Colors::Black, bool use_depth = false);
+    explicit RenderTarget(const Vector2& size, const Color4& clear_color = Colors::Black, bool use_depth = false, MSAA_SAMPLE_RATE sample_rate = MSAA_SAMPLE_RATE::MSAA_NONE);
     ~RenderTarget();
 };

include/JGL/types/Texture.h

@@ -37,7 +37,7 @@ namespace JGL {
         void load(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
     public:
         /// Load a texture from a file,
-        Texture(const std::string& file, TextureFilteringMode filtering_mode = TextureFilteringMode::BILINEAR, TextureWrappingMode wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE, const TextureFlag& flags = TextureFlag::INVERT_Y);
+        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(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
         /* Initialize a texture filled with trash data
         this is primarily for the RenderTarget */