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 <iostream>
#include <Color3.hpp>
#include <Color4.hpp>
#include <Colors.hpp>
#include <JGL/Texture.h>
#include <JGL/enums.h>
#include <JGL/FontCache.h>
#include <JGL/Font.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/TriangleMesh.hpp>


/// OpenGL Wrapper for rendering 2D graphics primitives 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.


    /// 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.
        /// 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).
        /// @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 Color3& color, const Vector2& coordinates, float radius = 1.f);
        void DrawPoint(const Color3& color, float x, float y, float radius = 1.f);
        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 Color3& color, const Vector2& A, const Vector2& B, float thickness = 1);
        void DrawLine(const Color3& color, float x, float y, float w, float h, float thickness = 1);
        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& color1, const Color4& color2, const Vector2& A, const Vector2& B, float thickness = 1);
        void DrawGradientLine(const Color3& color1, const Color3& 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 Color3& color1, const Color3& color2, 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);
        void OutlineRect(const Color3& color, const Vector2& pos, const Vector2& size, float thickness = 1);

        /// Draws a sprite to the screen by passing a GLuint 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 color A 32-bit RGBA value represented as four unsigned 8-bit integers.
        /// @param inversion
        /// @see class Texture
        void DrawSprite(const Texture& texture,
                        const Vector2& position,
                        const Vector2& origin = Vector2(0,0),
                        const Vector2& scale = Vector2(1,1),
                        const Color4& color = Colors::White,
                        Inversion inversion = Inversion::None);
        void DrawSprite(const Texture& texture,
                        float positionX, float positionY,
                        float originX = 0, float originY = 0,
                        float scaleX = 1, float scaleY = 1,
                        const Color4& color = Colors::White,
                        Inversion inversion = Inversion::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,
                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Inversion inversion = Inversion::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 originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Inversion inversion = Inversion::None);


        /// Draws a non axis-aligned fill 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.
        void FillQuad(const Color4& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4);
        void FillQuad(const Color3& 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 OutlineQuad(const Color3& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float thickness = 1);

        /// Draws a filled rectangle on the screen.
        void FillRect(const Color4& color, const Vector2& pos, const Vector2& size);
        void FillRect(const Color3& 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 Color3& color1, const Color3& color2, const Gradient& 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 Color3& 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);
        void OutlineCircle(const Color3& 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);
        void FillCircle(const Color3& 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 Color3& color, const Triangle2D& tri, float thickness = 1);
        void OutlineTriangle(const Color4& color,
                             const Vector2& triA, const Vector2& triB, const Vector2& triC,
                             float thickness = 1);
        void OutlineTriangle(const Color3& color,
                             const Vector2& triA, const Vector2& triB, const Vector2& triC,
                             float thickness = 1);
        // TODO: Take more Focalin

        /// 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);
        void FillTriangle(const Color3& color, const Triangle2D& tri);

        /// 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 FillGradientTriangle(const Color3& a_color, const Color3& b_color, const Color3& c_color, const Triangle2D& tri);
        // TODO: Implement an overload that simply takes 3 Vector3's


        /// 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 DrawString(const Color3& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font);

        // TODO: Implement the following:
        void FillTexturedTriangle();
        void FillTexturedPolygon();


        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 lines where the last line will *always* connect to the beginning of the first.
        void OutlinePolygon    (const Color4& color, const std::vector<Vector2>& points, float thickness = 1);
        void FillPolygon       (const Color4& color, std::vector<Vector2> points);
        void OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);
    }

    /// 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 DrawLine(const Color3& 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, const Vector3& angle, float scale, u32 size, const Font& font);
        void DrawSprite();
        void DrawMatrixGizmo     (const Matrix3x3&, const Vector3&);
        void DrawMatrixGizmo     (const Matrix4x4&);
        void DrawAxisAngleGizmo  (const AxisAngle&,  const Vector3&);
        void DrawQuaternionGizmo (const Quaternion&, const Vector3&);
    }
}