Mirror Sprite and Cleanup

include/JGL/JGL.h

@@ -62,12 +62,12 @@ namespace JGL {
     /// 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).
+        /// 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.
         /// It is recommended to always open a JGL 2D context to render your content, then close when completed.
         /// This keeps our code from, say, clobbering the OpenGL rendering context driving 3D content in between our calls.
         void Begin();
-        /// Closes a 2-D rendering context with the underlying graphics system (In this case & by default OpenGL).
+        /// Closes a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
         /// @see Begin().
         void End();
 
@@ -86,8 +86,8 @@ namespace JGL {
         void DrawLine(const Color4& color, float x1, float y1, float x2, float y2, float thickness = 1);
 
         ///Draws a line with a gradient that transitions across it.
-        void DrawGradientLine(const Color4& color1, const Color4& color2, const Vector2& A, const Vector2& B, float thickness = 1);
-        void DrawGradientLine(const Color4& color1, const Color4& color2, float x, float y, float w, float h, float thickness = 1);
+        void DrawGradientLine(const Color4& color_a, const Color4& color_b, const Vector2& A, const Vector2& B, float thickness = 1);
+        void DrawGradientLine(const Color4& color_a, const Color4& color_b, float x, float y, float w, float h, float thickness = 1);
 
         /// Draws an outline of a rectangle on the screen.
         void OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness = 1);
@@ -102,14 +102,14 @@ namespace JGL {
         /// @param inversion inverts the texture only.
         /// @see class Texture
         void DrawSprite(const Texture& texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),
-                        const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Inversion inversion = Inversion::None);
+                        const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);
         void DrawSprite(const Texture& texture,
                         float positionX, float positionY,
                         float rad_rotation = 0,
                         float originX = 0, float originY = 0,
                         float scaleX = 1, float scaleY = 1,
                         const Color4& color = Colors::White,
-                        Inversion inversion = Inversion::None);
+                        Direction inversion = Direction::None);
 
         /// Draws a piece of a sprite to the screen, similar to DrawSprite.
         /// @param texture
@@ -121,36 +121,29 @@ namespace JGL {
         /// @param color
         /// @param inversion
         void DrawPartialSprite(const Texture& texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,
-                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Inversion inversion = Inversion::None);
+                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);
         void DrawPartialSprite(const Texture& texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,
-                               float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Inversion inversion = Inversion::None);
+                               float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);
 
-
-        /// Draws a non axis-aligned fill rect to the screen.
+        /// To save v-ram, Use if a sprite would be identical if mirrored horizontally, vertically, or both. For example, a circle.
+        /// Assumes the input texture is the top left quadrant. You can use "SoftwareTexture" to invert it correctly so that's the case.
+        /// @param texture
+        /// @param position
+        /// @param mirror_axis The axes to mirror across, Vertical and Horizontal or both only.
+        /// @param rad_rotation The rotation of the final result.
+        /// @param origin The point at which transformations are done about.
+        /// @param scale
         /// @param color
-        /// @param v1 top-left vertex.
-        /// @param v2 bottom-left vertex.
-        /// @param v3 bottom-right vertex.
-        /// @param v4 top-right vertex.
-        void FillQuad(const Color4& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4);
-
-        /// Draws a non axis-aligned outline rect to the screen.
-        /// @param color
-        /// @param v1 top-left vertex.
-        /// @param v2 bottom-left vertex.
-        /// @param v3 bottom-right vertex.
-        /// @param v4 top-right vertex.
-        /// @param thickness the thickness of the GL_LINES to be connected together.
-        void OutlineQuad(const Color4& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float thickness = 1);
+        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 Gradient& gradient, const Vector2& pos, const Vector2& size);
+        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);
+        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);

include/JGL/types/Texture.h

@@ -38,12 +38,13 @@ namespace JGL {
         Texture(const std::string& file, const TextureFlag& flags, TextureFilteringMode filtering_mode = TextureFilteringMode::BILINEAR, TextureWrappingMode wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE);
         Texture() = default;
     public:
-        GLuint GetGLTextureHandle() const;
-        Vector2 GetDimensions() const;
-        TextureFilteringMode GetFilteringMode() const;
-        TextureFlag GetFlags() const;
-        TextureFormat GetFormat() const;
-        std::vector<Color4> GetPixelData() const;
+        [[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;
 
         void SetTextureHandle(GLuint handle);
         void Erase();

include/JGL/types/enums.h

@@ -1,33 +1,19 @@
 #pragma once
 
 namespace JGL {
-    enum class Inversion : u8 {
+    enum class Direction : u8 {
         None = 0,
         Vertical = 1,
         Horizontal = 2,
+        Diagonal_NWSE = 3, // North West -> South East.
+        Diagonal_SWNE = 4 // South West -> North East.
     };
 
-    inline Inversion operator|(Inversion a, Inversion b) {
-        return static_cast<Inversion>(static_cast<int>(a) | static_cast<int>(b));
-    }
-    inline bool operator&(Inversion a, Inversion b) {
-        return (u8)a & (u8)b;
-    }
-}
-
-namespace JGL {
-    enum class Gradient : u8 {
-        Vertical = 0,
-        Horizontal = 1,
-        DiagonalTopLeft = 2,
-        DiagonalBottomLeft = 4
-    };
-
-    inline Gradient operator|(Gradient a, Gradient b) {
-        return static_cast<Gradient>(static_cast<int>(a) | static_cast<int>(b));
+    inline Direction operator|(Direction a, Direction b) {
+        return static_cast<Direction>(static_cast<int>(a) | static_cast<int>(b));
     }
 
-    inline bool operator&(Gradient a, Gradient b) {
+    inline bool operator&(Direction a, Direction b) {
         return (u8)a & (u8)b;
     }
 }