JGL/include/JGL/JGL.h

/// Josh's Graphics Library
/// A C++20 Library for rendering 2D and 3D primitives in an OpenGL context.
/// Developed and Maintained by Josh O'Leary @ Redacted Software.
/// Special Thanks to William Tomasine II and Maxine Hayes.
/// (c) 2024 Redacted Software
/// This work is dedicated to the public domain.

/// @file JGL.h
/// @desc All JGL usable functions are defined here. This is the public API.
/// @edit 2024-07-16


#pragma once

#include <string>
#include <Color4.hpp>
#include <JGL/types/Texture.h>
#include <JGL/types/Enums.h>
#include <JGL/types/FontCache.h>
#include <JGL/types/Font.h>
#include <JGL/types/RenderTarget.h>
#include <J3ML/LinearAlgebra.hpp>
#include <J3ML/LinearAlgebra/Vector2.hpp>
#include <J3ML/LinearAlgebra/Vector3.hpp>
#include <J3ML/Geometry/Sphere.hpp>
#include <J3ML/Geometry/Capsule.hpp>
#include <J3ML/Geometry/Triangle2D.hpp>

/// OpenGL Wrapper for rendering 2D & 3D graphics in both a 2D and 3D context.
namespace JGL {
    using namespace J3ML::LinearAlgebra;
    using namespace J3ML::Geometry;

    void Update(const Vector2& window_size);
    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.
    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.
        /// 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(RenderTarget* render_target = nullptr, bool clear_buffers = false);
        /// Closes a 2-D rendering context with the underlying graphics system (In this case&  by default OpenGL).
        /// @see Begin().
        void End();

        /// Plots a single pixel on the screen.
        /// @param color  A 3-or-4 channel color value. @see class Color3, class Color4
        /// @param coordinates The pixel-point on-screen at which to plot the pixel.
        void DrawPoint(const Color4& color, const Vector2& coordinates, float radius = 1.f);
        void DrawPoint(const Color4& color, float x, float y, float radius = 1.f);

        /// Plots a line (segment) on the screen.
        /// @param color A 3-or-4 channel color value. @see classes Color3, Color4.
        /// @param A The starting point of the line segment.
        /// @param B The end point of the line segment.
        /// @param thickness The width at which to render the line.
        void DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness = 1);
        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& 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);

        /// 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);

        void DrawRenderTargetAsSprite(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
        /// @param origin The center point around which the image should have all transformations applied to it.
        /// @param scale The scale transformation for the image. X and Y axis are independently-scalable.
        /// @param rad_rotation A float representing the rotation of the sprite where 0 is no rotation and 1 is the maximum rotation (would look the same as 0).
        /// @param color A 32-bit RGBA value represented as four unsigned 8-bit integers.
        /// @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, 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,
                        Direction inversion = Direction::None);

        /// Draws a piece of a sprite to the screen, similar to DrawSprite.
        /// @param texture
        /// @param position
        /// @param sub_texture_position The top left corner of the sub-texture to be drawn.
        /// @param sub_texture_size The size of the sub-texture in px.
        /// @param origin
        /// @param scale
        /// @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, 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, Direction inversion = Direction::None);

        /// 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
        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 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);

        /// Draws a filled circle on the screen.
        void FillCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 8);

        /// Draws an outline of a triangle on the screen.
        /// @param color
        /// @param tri
        /// @param thickness
        void OutlineTriangle(const Color4& color, const Triangle2D& tri, float thickness = 1);
        void OutlineTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC, float thickness = 1);

        /// Draws a filled triangle on the screen.
        void FillTriangle(const Color4& color, const Triangle2D& tri);
        void FIllTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC);

        /// 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);

        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();
        void OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);
        void FillTexturedTriangle();
    }

    /// Drawing functions for primitive 3D Shapes.
    namespace J3D {
        void Init(const Vector2& window_size, float fov, float far_plane);
        void ChangeFOV(float fov);
        void ChangeFarPlane(float far_plane);
        void Begin();
        void End();
        void SetMatrix(const std::vector<GLfloat>& matrix, const Vector2& window_size);
        void DrawLine(const Color4& color, const Vector3& A, const Vector3& B, float thickness = 1);
        void FillSphere(const Color3& color, const Sphere& sphere);
        void WireframeSphere(const Color3& color, const Sphere& sphere, float thickness = 1);
        void FillOBB(const Color3& color, const OBB& obb);
        void WireframeOBB(const Color3& color, const OBB& obb, float thickness = 1);
        void FillCapsule(const Color3& color, const Capsule& capsule);
        void WireframeCapsule(const Color3& color, const Capsule& cap, float thickness = 1);
        void FillTriangleMesh(const Color3& color, const TriangleMesh& mesh);
        void WireframeTriangleMesh(const Color3& color, const TriangleMesh& mesh, float thickness = 1);
        void DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font, const EulerAngle& angle = {0, 0, 0}, bool draw_back_face = false);
        void DrawSprite();
        void DrawMatrixGizmo     (const Matrix3x3&, const Vector3&);
        void DrawMatrixGizmo     (const Matrix4x4&);
        void DrawAxisAngleGizmo  (const AxisAngle&,  const Vector3&);
        void DrawQuaternionGizmo (const Quaternion&, const Vector3&);
    }
}