Rotate sprite & sub-sprite about origin

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.18..3.27)
 project(JGL
     VERSION 1.0
     LANGUAGES CXX
@@ -17,17 +17,17 @@ include(cmake/CPM.cmake)
 
 CPMAddPackage(
         NAME mcolor
-        URL https://git.redacted.cc/maxine/mcolor/archive/Prerelease-3.zip
+        URL https://git.redacted.cc/maxine/mcolor/archive/Prerelease-4.zip
 )
 
 CPMAddPackage(
         NAME J3ML
-        URL https://git.redacted.cc/josh/j3ml/archive/Release-3.0.zip
+        URL https://git.redacted.cc/josh/j3ml/archive/Release-3.1.zip
 )
 
 CPMAddPackage(
         NAME ReWindow
-        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-12.zip
+        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-13.zip
 )
 
 CPMAddPackage(
@@ -109,4 +109,4 @@ if (WIN32)
     target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML ReWindowLibrary glad jlog Event ReTexture)
 endif()
 
-target_link_libraries(JGL_Demo PUBLIC JGL)
+target_link_libraries(JGL_Demo PUBLIC JGL)

assets/shader_programs/test_fragment.glsl

@@ -0,0 +1,5 @@
+#version 120
+
+void main() {
+        gl_FragColor = vec4(1, 1, 1, 1);
+}

assets/shader_programs/test_vertex.glsl

@@ -0,0 +1,7 @@
+#version 120
+
+attribute vec2 position;
+
+void main() {
+    gl_Position = vec4(position.x, position.y, 1.0, 1.0);
+}

include/JGL/JGL.h

@@ -17,21 +17,21 @@
 #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 <JGL/types/Texture.h>
+#include <JGL/types/enums.h>
+#include <JGL/types/FontCache.h>
+#include <JGL/types/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>
+#include <JGL/Logger.h>
 
 
 /// OpenGL Wrapper for rendering 2D graphics primitives in both a 2D and 3D context
 namespace JGL {
-
     using namespace J3ML::LinearAlgebra;
     using namespace J3ML::Geometry;
 
@@ -62,7 +62,6 @@ 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).
         /// @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.
@@ -75,8 +74,6 @@ namespace JGL {
         /// 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);
 
@@ -85,117 +82,111 @@ namespace JGL {
         /// @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.
+        /// 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
+        /// @param inversion inverts the texture only.
         /// @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, 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);
         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);
 
+        /// 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, 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 rad_rotation = 0, 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.
-        /// The order of the vertices must be such that if you were to connect them you'd never go diagonally across the quad.
+        /// @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.
-        /// The order of the vertices must be such that if you were to connect them you'd never go diagonally across the quad.
+        /// @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
+        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);
-        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 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);
+
+        /// 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 DrawPartialSprite();
-
-
-        void DrawCubicBezierCurve(const Color4& color,
-                                  const Vector2& controlA, const Vector2& pointA,
-                                  const Vector2& pointB, const Vector2& controlB,
-                                  int subdivisions = 10,
-                                  float thickness = 1);
-
-        void OutlinePolygon    (const Color4& color, std::vector<Vector2> points);
-        void FillPolygon       (const Color4& color, std::vector<Vector2> points, float thickness = 1);
         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.
@@ -207,7 +198,6 @@ namespace JGL {
         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);
@@ -216,7 +206,7 @@ namespace JGL {
         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 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&);

include/JGL/Logger.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <jlog/Logger.hpp>
+
+namespace JGL::Logger {
+    using namespace jlog;
+
+    extern GenericLogger Fatal;
+    extern GenericLogger Debug;
+    extern GenericLogger Error;
+}

include/JGL/types/FontCache.h

@@ -27,7 +27,7 @@ public:
     //CachedGlyph(GLuint texture_id, char c);
     CachedGlyph(char c, std::array<GLfloat, 12> texcoords, float x2o, float y2o, float w, float h, float advX, float advY);
     char getCharacter();
-    const std::array<GLfloat, 12> getTexCoords() const;
+    [[nodiscard]] const std::array<GLfloat, 12> getTexCoords() const;
 };
 
 /// Represents a Font object as it exists in the font-cache.
@@ -45,14 +45,14 @@ public:
     CachedGlyph* getGlyph(char c);
     std::map<char, CachedGlyph*> getGlyphs();
     const GLuint* getTexture();
-    GLsizei getTextureWidth() const;
-    GLsizei getTextureHeight() const;
+    [[nodiscard]] GLsizei getTextureWidth() const;
+    [[nodiscard]] GLsizei getTextureHeight() const;
     CachedFont(GLuint texture_id, GLsizei texture_width, GLsizei texture_height, unsigned int font_size, unsigned int font_index);
 };
 
 class JGL::FontCache {
 private:
-    std::vector<CachedFont*> cachedFonts = {};
+    std::vector<CachedFont*> cachedFonts{};
 public:
     std::vector<CachedFont*> getFonts();
     CachedFont* getFont(unsigned int font_size, unsigned int font_index);

main.cpp

@@ -2,9 +2,10 @@
 #include <JGL/JGL.h>
 #include <rewindow/types/window.h>
 #include <Colors.hpp>
+#include <chrono>
 #include <J3ML/LinearAlgebra/Vector2.hpp>
-#include <JGL/Font.h>
-#include <jlog/jlog.hpp>
+#include <JGL/types/Font.h>
+#include <JGL/Logger.h>
 #include <ReTexture/Texture.h>
 
 using J3ML::LinearAlgebra::Vector2;
@@ -139,9 +140,17 @@ public:
 
     Vector3 textAngle = {0,0,0};
     float fov = 90;
+    float sprite_radians = 0;
     bool fov_increasing = true;
+    unsigned long long frames = 0;
+    bool framerate_measurement = false;
+    std::chrono::system_clock::time_point start;
+    float elapsed = 0.0f;
 
     void display() {
+        if (framerate_measurement)
+            start = std::chrono::high_resolution_clock::now();
+
         JGL::Update(getSize());
         if (fov_increasing)
             fov += 0.25;
@@ -154,25 +163,26 @@ public:
             fov_increasing = true;
         J3D::ChangeFOV(fov);
 
+        sprite_radians += 0.05;
         textAngle.y += 2.0f;
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         glMatrixMode(GL_MODELVIEW);
         glLoadIdentity();
 
         camera->render();
-
         ///All 3D elements of the scene and JGL elements *must* be rendered before the 2d stuff.
 
         J3D::Begin();
             J3D::DrawLine(Colors::Red, {-0.33,-0.125,1}, {-1,-0.125,1});
             J3D::DrawLine(Colors::Red, {-0.33,-0.125,1}, {-0.33,0.25,1});
-            J3D::DrawString(Colors::Red, "JGL Sample Text", {-0.33, -0.1, 1.0f},textAngle,  1.f, 32, FreeSans);
+            J3D::DrawString(Colors::Red, "JGL Sample Text", {-0.33, -0.1, 1.0f}, 1.f, 32, FreeSans, textAngle, true);
         J3D::End();
 
         J2D::Begin();
             J2D::FillQuad(Color4(Colors::Red), {500, 52}, {500, 152}, {600, 152}, {600, 52});
             J2D::FillRect(Colors::Blue, {0,52}, {100,100});
-            J2D::DrawSprite(*image, {200, 252}, {0.5, 0.5}, {2, 1});
+            J2D::DrawSprite(*image, {252, 252}, sprite_radians, {0.5, 0.5});
+            J2D::DrawPartialSprite(*image, {200, 252}, image->GetDimensions() * 0.25, image->GetDimensions() * 0.75, sprite_radians, {0.5, 0.5});
             J2D::FillRect(Colors::Pinks::HotPink, {68, 120}, {32, 32});
             J2D::FillGradientRect(Colors::Red, Colors::Blue, Gradient::DiagonalBottomLeft, {100,52}, {100,100});
             J2D::FillRoundedRect(Colors::Red, {200, 52}, {100, 100}, 8, 8);
@@ -191,7 +201,8 @@ public:
             J2D::DrawString(Colors::Green, "Jupteroid Font", 0.f, 0, 1.f, 16, Jupiteroid);
             J2D::DrawString(Colors::White, "Position: " + std::to_string(camera->position.x) + " " + std::to_string(camera->position.y) + " " + std::to_string(camera->position.z), 0, 16, 1,16, Jupiteroid);
             J2D::DrawString(Colors::White, "ViewAngle: " + std::to_string(camera->angle.x) + " " + std::to_string(camera->angle.y) + " " + std::to_string(camera->angle.z), 0, 33, 1,16, Jupiteroid);
-
+            J2D::OutlinePolygon(Colors::White, {{200, 400}, {220, 420}, {220, 430}, {230, 410}, {200, 400}});
+            //J2D::FillPolygon(Colors::White, {{200, 400}, {220, 420}, {220, 430}, {230, 410}, {200, 400}});
             J2D::DrawCubicBezierCurve(Colors::Blues::CornflowerBlue,
                                       a.position,
                                       b.position,
@@ -204,6 +215,22 @@ public:
             c.Draw();
             d.Draw();
         J2D::End();
+
+        if (framerate_measurement) {
+            frames++;
+            std::chrono::system_clock::time_point stop = std::chrono::high_resolution_clock::now();
+            std::chrono::duration<float> frame_time = stop - start;
+            elapsed += frame_time.count();
+            if (elapsed >= 1)
+                std::cout << "Framerate: " << frames << std::endl,
+                frames = 0,
+                elapsed = 0,
+                framerate_measurement = false,
+                setVsyncEnabled(true);
+        } else if (isKeyDown(Keys::One))
+            framerate_measurement = true,
+            frames = 0,
+            setVsyncEnabled(false);
     }
 
     void OnRefresh(float elapsed) override {

src/JGL.cpp

@@ -5,7 +5,7 @@
 #include <JGL/JGL.h>
 #include <glad/glad.h>
 #include <Color3.hpp>
-#include <jlog/jlog.hpp>
+#include <jlog/Logger.hpp>
 #include <J3ML/Algorithm/Bezier.hpp>
 
 GLfloat oldColor[4] = {0, 0, 0, 1};
@@ -27,15 +27,14 @@ namespace JGL {
 
     void Update(const Vector2& window_size) {
         wS = window_size;
-        glViewport(0, 0, wS.x, wS.y);
+        glViewport(0, 0, (int) wS.x, (int) wS.y);
     }
 
-
     void J2D::Begin() {
         glMatrixMode(GL_PROJECTION);
         glPushMatrix();
         glLoadIdentity();
-        glViewport(0, 0, wS.x, wS.y);
+        glViewport(0, 0, (int) wS.x, (int) wS.y);
         glOrtho(0, wS.x, wS.y, 0, -1, 1);
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
@@ -43,53 +42,61 @@ namespace JGL {
 
         //Get what the draw color was before we did anything.
         glGetFloatv(GL_CURRENT_COLOR, oldColor);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
 
         glGetIntegerv(GL_ACTIVE_TEXTURE,& activeTextureUnit);
         activeTextureUnit = activeTextureUnit - GL_TEXTURE0;
+
         if (activeTextureUnit != 0)
             glActiveTexture(GL_TEXTURE0);
 
-        wasDepthTestEnabled = false;
         if (glIsEnabled(GL_DEPTH_TEST))
             wasDepthTestEnabled = true,
             glDisable(GL_DEPTH_TEST);
+        else
+            wasDepthTestEnabled = false;
 
-        wasVertexArraysEnabled = true;
         if (!glIsEnabled(GL_VERTEX_ARRAY))
             wasVertexArraysEnabled = false,
             glEnableClientState(GL_VERTEX_ARRAY);
+        else
+            wasVertexArraysEnabled = true;
 
-        wasCullFaceEnabled = true;
         if (!glIsEnabled(GL_CULL_FACE))
             wasCullFaceEnabled = false,
             glEnable(GL_CULL_FACE),
             glCullFace(GL_BACK);
+        else
+            wasCullFaceEnabled = true;
 
-        wasBlendEnabled = true;
         if (!glIsEnabled(GL_BLEND))
             wasBlendEnabled = false,
             glEnable(GL_BLEND),
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        else
+            wasBlendEnabled = true;
 
-        wasTexture2DEnabled = true;
         if (!glIsEnabled(GL_TEXTURE_2D))
             wasTexture2DEnabled = false,
             glEnable(GL_TEXTURE_2D);
+        else
+            wasTexture2DEnabled = true;
 
-        wasTextureCoordArrayEnabled = true;
         if (!glIsEnabled(GL_TEXTURE_COORD_ARRAY))
             wasTextureCoordArrayEnabled = false,
             glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        else
+            wasTextureCoordArrayEnabled = true;
 
-        wasColorArrayEnabled = false;
         if (glIsEnabled(GL_COLOR_ARRAY))
             wasColorArrayEnabled = true,
             glDisableClientState(GL_COLOR_ARRAY);
+        else
+            wasColorArrayEnabled = false;
 
         if (!inJ3D)
             inJ2D = true;
-        else { ERROR("Attempt to Begin J2D inside of J3D context.") }
+        else { jlog::Error("Attempt to Begin J2D inside of J3D context."); }
     }
 
     void J2D::End() {
@@ -123,14 +130,14 @@ namespace JGL {
         glActiveTexture(GL_TEXTURE0 + activeTextureUnit);
 
         //Put the draw color back how it was before.
-        glColor4f(oldColor[0], oldColor[1], oldColor[2], oldColor[3]);
+        glColor4fv(oldColor);
 
         inJ2D = false;
     }
 
-    void J2D::DrawSprite(const Texture& texture, const Vector2& pos, const Vector2& origin, const Vector2& scale, const Color4& color, Inversion inversion) {
+    void J2D::DrawSprite(const Texture& texture, const Vector2& pos, float rad_rotation, const Vector2& origin, const Vector2& scale, const Color4& color, Inversion inversion) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
 
         const Vector2 size = texture.GetDimensions();
@@ -141,18 +148,26 @@ namespace JGL {
         // Factors in scaling and origin correctly.
         // i.e. to render at 2x size, from the center, at coords XY, use {2, 2} scale, and {0.5, 0.5} offset.
         const Vector2 offset = origin * size;
-
-        Vector2 pos2 = pos - offset*scale;
+        Vector2 pos2 = pos - offset * scale;
         Vector2 scaled_size = scale * size;
         Vector2 size2 = scaled_size;
+        float cos_theta = std::cos(rad_rotation);
+        float sin_theta = std::sin(rad_rotation);
 
-        const Vector2 vertices[] = {
-                pos2,                                 // Top-left vertex
-                {pos2.x, pos2.y + size2.y},            // Bottom-left
-                {pos2.x + size2.x, pos2.y + size2.y},   // Bottom-right
-                {pos2.x + size2.x, pos2.y}             // Top-right
+        std::array<Vector2, 4> vertices =
+        {
+            pos2,                                 // Top-left vertex
+            {pos2.x, pos2.y + size2.y},            // Bottom-left
+            {pos2.x + size2.x, pos2.y + size2.y},   // Bottom-right
+            {pos2.x + size2.x, pos2.y}             // Top-right
         };
 
+        //Rotate the vertices about the origin by float rad_rotation.
+        if (rad_rotation != 0)
+            for (auto& v : vertices)
+                v = { (v.x - pos2.x - offset.x * scale.x) * cos_theta - (v.y - pos2.y - offset.y * scale.y) * sin_theta + pos2.x + offset.x * scale.x, (v.x - pos2.x - offset.x * scale.x) * sin_theta + (v.y - pos2.y - offset.y * scale.y) * cos_theta + pos2.y + offset.y * scale.y};
+
+
         if (inversion&  Inversion::Vertical)
             textureCoordinates = {Vector2(0, 1), Vector2(0, 0), Vector2(1, 0), Vector2(1, 1)};
         if (inversion&  Inversion::Horizontal)
@@ -162,121 +177,157 @@ namespace JGL {
 
         glColor4ubv(color.ptr());
         glBindTexture(GL_TEXTURE_2D, texture.GetGLTextureHandle());
-        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
         glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), textureCoordinates.data());
         glDrawArrays(GL_QUADS, 0, 4);
         glBindTexture(GL_TEXTURE_2D, 0);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
     }
 
 
-    void J2D::DrawSprite(const Texture& texture, float positionX, float positionY, float originX, float originY, float scaleX, float scaleY, const Color4& color, Inversion inversion)
+    void J2D::DrawSprite(const Texture& texture, float positionX, float positionY, float rad_rotation, float originX, float originY, float scaleX, float scaleY, const Color4& color, Inversion inversion)
     {
         DrawSprite(texture,
-                   {positionX, positionX},
+                   {positionX, positionY},
+                   rad_rotation,
                    {originX, originY},
                    {scaleX, scaleY},
-                   color,
-                   inversion);
+                   color, inversion);
+    }
+
+    void J2D::DrawPartialSprite(const Texture& texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation, const Vector2& origin, const Vector2& scale, const Color4& color, Inversion inversion) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        const Vector2 textureSize = texture.GetDimensions();
+
+        // Calculate texture coordinates (relative to the whole texture)
+        std::array<GLfloat, 8> textureCoordinates = {
+                sub_texture_position.x / textureSize.x,
+                sub_texture_position.y / textureSize.y,
+                sub_texture_position.x / textureSize.x,
+                (sub_texture_position.y + sub_texture_size.y) / textureSize.y,
+                (sub_texture_position.x + sub_texture_size.x) / textureSize.x,
+                (sub_texture_position.y + sub_texture_size.y) / textureSize.y,
+                (sub_texture_position.x + sub_texture_size.x) / textureSize.x,
+                sub_texture_position.y / textureSize.y
+        };
+
+        if (inversion & Inversion::Vertical)
+            std::swap(textureCoordinates[1], textureCoordinates[3]),
+            std::swap(textureCoordinates[5], textureCoordinates[7]);
+
+        if (inversion & Inversion::Horizontal)
+            std::swap(textureCoordinates[0], textureCoordinates[6]),
+            std::swap(textureCoordinates[2], textureCoordinates[4]);
+
+        const Vector2 offset = origin * sub_texture_size;
+        Vector2 pos2 = position - offset * scale;
+        Vector2 scaled_size = scale * sub_texture_size;
+        Vector2 size2 = scaled_size;
+        float cos_theta = std::cos(rad_rotation);
+        float sin_theta = std::sin(rad_rotation);
+
+        std::array<Vector2, 4> vertices =
+        {
+            pos2,                                // Top-left
+            {pos2.x, pos2.y + size2.y},          // Bottom-left
+            {pos2.x + size2.x, pos2.y + size2.y},// Bottom-right
+            {pos2.x + size2.x, pos2.y}           // Top-right
+        };
+
+        //Rotate the vertices about the origin by float rad_rotation.
+        if (rad_rotation != 0)
+            for (auto& v : vertices)
+                v = { (v.x - pos2.x - offset.x * scale.x) * cos_theta - (v.y - pos2.y - offset.y * scale.y) * sin_theta + pos2.x + offset.x * scale.x, (v.x - pos2.x - offset.x * scale.x) * sin_theta + (v.y - pos2.y - offset.y * scale.y) * cos_theta + pos2.y + offset.y * scale.y};
+
+        glColor4ubv(color.ptr());
+        glBindTexture(GL_TEXTURE_2D, texture.GetGLTextureHandle());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
+        glTexCoordPointer(2, GL_FLOAT, 0, textureCoordinates.data());
+        glDrawArrays(GL_QUADS, 0, 4);
+        glBindTexture(GL_TEXTURE_2D, 0);
+        glColor4fv(baseColor);
+    }
+
+    void J2D::DrawPartialSprite(const JGL::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,float originY, float rad_rotation, float scaleX, float scaleY, const Color4& color,JGL::Inversion inversion) {
+
+        J2D::DrawPartialSprite(texture, {positionX, positionY}, {sub_texture_positionX, sub_texture_positionY},
+                               {(float) sub_texture_sizeX, (float) sub_texture_sizeY}, rad_rotation, {originX, originY}, {scaleX, scaleY}, color, inversion);
     }
 
     void J2D::FillQuad(const Color4& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
-        Vector2 vertices[] = {v1, v2, v3, v4};
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        Vector2 vertices[4] = {v1, v2, v3, v4};
+
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_QUADS, 0, 4);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::FillQuad(const Color3& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4) {
-        J2D::FillQuad(Color4(color), v1, v2, v3, v4);
+        glColor4fv(baseColor);
     }
 
     void J2D::OutlineQuad(const Color4& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float thickness) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {v1, v2, v3, v4};
         glLineWidth(thickness);
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_LINE_LOOP, 0, 4);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
     }
 
-    void J2D::OutlineQuad(const Color3& color, const Vector2& v1, const Vector2& v2, const Vector2& v3, const Vector2& v4, float thickness) {
-        J2D::OutlineQuad(Color4(color), v1, v2, v3, v4);
-    }
-
-
-
     void J2D::FillRect(const Color4& color, const Vector2& pos, const Vector2& size) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_QUADS, 0, 4);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::FillRect(const Color3& color, const Vector2& pos, const Vector2& size) {
-        J2D::FillRect({color.r, color.g, color.b, 255}, pos, size);
+        glColor4fv(baseColor);
     }
 
     void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Gradient& gradient, const Vector2& pos, const Vector2& size) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
-        std::vector<GLfloat> colors = {};
+        std::vector<GLfloat> colors{};
 
         if (gradient == Gradient::Horizontal)
-            colors = {color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f, color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f,
-                     color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f, color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f};
+            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),
+                      color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(), color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized()};
 
         else if (gradient == Gradient::Vertical)
-            colors = {color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f, color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f,
-                     color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f, color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f};
+            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(),
+                      color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(), color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized()};
 
         else if (gradient == Gradient::DiagonalBottomLeft)
-            colors = {(color1.r + color2.r) / 2.f / 255.f, (color1.g + color2.g) / 2.f / 255.f, (color1.b + color2.b) / 2.f / 255.f, (color1.a + color2.a) / 2.f / 255.f,
-                    color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f,(color1.r + color2.r) / 2.f / 255.f, (color1.g + color2.g) / 2.f / 255.f,
-                    (color1.b + color2.b) / 2.f / 255.f, (color1.a + color2.a) / 2.f / 255.f, color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f};
+            colors = {(color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f, (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f,
+                      color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(), (color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f,
+                      (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f, color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized()};
 
         else if (gradient == Gradient::DiagonalTopLeft)
-                    colors = {color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f,(color1.r + color2.r) / 2.f / 255.f, (color1.g + color2.g) / 2.f / 255.f,
-                              (color1.b + color2.b) / 2.f / 255.f, (color1.a + color2.a) / 2.f / 255.f,color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f,
-                              (color1.r + color2.r) / 2.f / 255.f, (color1.g + color2.g) / 2.f / 255.f, (color1.b + color2.b) / 2.f / 255.f,(color1.a + color2.a) / 2.f / 255.f};
+            colors = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),(color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f,
+                      (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f, (color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f, color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized(),
+                      (color1.RedChannelNormalized() + color2.RedChannelNormalized()) / 2.f, (color1.GreenChannelNormalized() + color2.GreenChannelNormalized()) / 2.f, (color1.BlueChannelNormalized() + color2.BlueChannelNormalized()) / 2.f,(color1.AlphaChannelNormalized() + color2.AlphaChannelNormalized()) / 2.f};
 
         glEnableClientState(GL_COLOR_ARRAY);
-            glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-            glColorPointer(4, GL_FLOAT, 0, colors.data());
-            glDrawArrays(GL_QUADS, 0, 4);
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glColorPointer(4, GL_FLOAT, 0, colors.data());
+        glDrawArrays(GL_QUADS, 0, 4);
         glDisableClientState(GL_COLOR_ARRAY);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::FillGradientRect(const Color3& color1, const Color3& color2, const Gradient& gradient, const Vector2& pos, const Vector2& size) {
-        J2D::FillGradientRect({color1.r, color1.g, color1.b, 255}, {color2.r, color2.g, color2.b, 255}, gradient, pos, size);
+        glColor4fv(baseColor);
     }
 
     void J2D::FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius, unsigned int subdivisions) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         J2D::FillRect(color, {pos.x + radius, pos.y}, {size.x - 2 * radius, size.y});
         J2D::FillRect(color, {pos.x, pos.y + radius}, {size.x, size.y - 2 * radius});
@@ -287,117 +338,90 @@ namespace JGL {
         J2D::FillCircle(color, {pos.x + size.x - radius, pos.y + size.y - radius}, radius, subdivisions);
     }
 
-    void J2D::FillRoundedRect(const Color3& color, const J3ML::LinearAlgebra::Vector2& pos, const J3ML::LinearAlgebra::Vector2& size, float radius, unsigned int subdivisions) {
-        J2D::FillRoundedRect({color.r, color.g, color.b, 255}, pos, size, radius, subdivisions);
-    }
-
     void J2D::OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {{pos.x, pos.y}, {pos.x, pos.y + size.y}, {pos.x + size.x, pos.y + size.y}, {pos.x + size.x, pos.y}};
 
         glLineWidth(thickness);
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_LINE_LOOP, 0, 4);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::OutlineRect(const Color3& color, const Vector2& pos, const Vector2& size, float thickness) {
-        J2D::OutlineRect({color.r, color.g, color.b, 255}, pos, size, thickness);
+        glColor4fv(baseColor);
     }
 
     void J2D::DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.");
-
+            jlog::Error("Drawing J2D element before J2D begin.");
         Vector2 vertices[] = {A, B};
 
         glLineWidth(thickness);
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_LINES, 0, 2);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::DrawLine(const Color3& color, const Vector2& A, const Vector2& B, float thickness) {
-        J2D::DrawLine({color.r, color.g, color.b, 255}, A, B, thickness);
+        glColor4fv(baseColor);
     }
 
     void J2D::DrawLine(const Color4& color, float x, float y, float w, float h, float thickness) {
         J2D::DrawLine(color, {x, y}, {w, h}, thickness);
     }
 
-    void J2D::DrawLine(const Color3& color, float x, float y, float w, float h, float thickness) {
-        J2D::DrawLine({color.r, color.g, color.b, 255}, x, y, w, h, thickness);
-    }
-
     void J2D::DrawGradientLine(const Color4& color1, const Color4& color2, const Vector2& A, const Vector2& B, float thickness) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.");
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {A, B};
-        GLfloat colors[8] = {color1.r / 255.f, color1.g / 255.f, color1.b / 255.f, color1.a / 255.f,
-                             color2.r / 255.f, color2.g / 255.f, color2.b / 255.f, color2.a / 255.f};
+        GLfloat colors[8] = {color1.RedChannelNormalized(), color1.GreenChannelNormalized(), color1.BlueChannelNormalized(), color1.AlphaChannelNormalized(),
+                             color2.RedChannelNormalized(), color2.GreenChannelNormalized(), color2.BlueChannelNormalized(), color2.AlphaChannelNormalized() };
 
         glEnableClientState(GL_COLOR_ARRAY);
-            glLineWidth(thickness);
-            glColorPointer(4,GL_FLOAT,sizeof(GL_FLOAT) * 4, colors);
-            glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
-            glDrawArrays(GL_LINES, 0, 2);
+        glLineWidth(thickness);
+        glColorPointer(4,GL_FLOAT,sizeof(Color4), colors);
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_LINES, 0, 2);
         glDisableClientState(GL_COLOR_ARRAY);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
     }
 
-    void J2D::DrawGradientLine(const Color3& color1, const Color3& color2, const Vector2& A, const Vector2& B, float thickness) {
-        J2D::DrawGradientLine({color1.r, color1.g, color1.b, 255}, {color2.r, color2.g, color2.b, 255}, A, B, thickness);
-    }
     void DrawGradientLine(const Color4& color1, const Color4& color2, float x, float y, float w, float h, float thickness) {
         J2D::DrawGradientLine(color1, color2, {x, y}, {w, h}, thickness);
     }
 
-    void DrawGradientLine(const Color3& color1, const Color3& color2, float x, float y, float w, float h, float thickness) {
-        J2D::DrawGradientLine({color1.r, color1.g, color1.b, 255}, {color2.r, color2.g, color2.b, 255}, {x, y}, {w, h}, thickness);
+    void J2D::OutlinePolygon(const Color4 &color, const std::vector<Vector2>& points, float thickness) {
+        if (!inJ2D)
+            jlog::Error("Drawing J2D element before J2D begin.");
+
+        if (points.front() != points.back())
+            throw std::runtime_error("J2D::OutlinePolygon: The first point and the last point must connect.");
+
+        glLineWidth(thickness);
+        glColor4ubv(color.ptr());
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), points.data());
+        glDrawArrays(GL_LINE_LOOP, 0, (int) points.size());
+        glColor4fv(baseColor);
     }
 
     void J2D::DrawPoint(const Color4& color, const Vector2& coordinates, float radius) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.");
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {coordinates};
 
         glPointSize(radius);
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_POINTS, 0, 1);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::DrawPoint(const Color3& color, const Vector2& coordinates, float radius) {
-        J2D::DrawPoint({color.r, color.g, color.b, 255}, coordinates);
+        glColor4fv(baseColor);
     }
 
     void J2D::DrawPoint(const Color4& color, float x, float y, float radius) {
-        DrawPoint(color, {x, y});
-    }
-
-    void J2D::DrawPoint(const Color3& color, float x, float y, float radius) {
-        DrawPoint({color.r, color.g, color.b, 255}, {x, y});
+        DrawPoint(color, {x, y}, radius);
     }
 
     void J2D::OutlineCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions, float thickness) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         float step = (2.f * Math::Pi) / (float) subdivisions;
         std::vector<Vector2> vertices{};
@@ -410,110 +434,82 @@ namespace JGL {
         }
 
         glLineWidth(thickness);
-        glColor4f(color.RedChannelNormalized(),
-                  color.GreenChannelNormalized(),
-                  color.BlueChannelNormalized(),
-                  color.AlphaChannelNormalized());
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
-        glDrawArrays(GL_LINE_LOOP, 0, vertices.size());
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::OutlineCircle(const Color3& color, const Vector2& center, float radius, unsigned int subdivisions, float thickness) {
-        J2D::OutlineCircle({color.r, color.g, color.b, 255}, center, radius, subdivisions, thickness);
+        glDrawArrays(GL_LINE_LOOP, 0, (int) vertices.size());
+        glColor4fv(baseColor);
     }
 
     void J2D::FillCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         GLfloat angle, x, y;
         float step =  (2.f * Math::Pi) / (float) subdivisions;
         std::vector<Vector2> vertices{};
 
         for (angle = 0.0f; angle < (2.f * Math::Pi); angle += step)
-                x = radius * sin(angle) + center.x,
-                y = radius * cos(angle) + center.y,
-                vertices.push_back({x, y});
+                x = radius * std::sin(angle) + center.x,
+                y = radius * std::cos(angle) + center.y,
+                vertices.emplace_back(x, y);
 
         glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
-        glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.size());
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::FillCircle(const Color3& color, const Vector2& center, float radius, unsigned int subdivisions) {
-        J2D::FillCircle({color.r, color.g, color.b, 255}, center, radius, subdivisions);
+        glDrawArrays(GL_TRIANGLE_FAN, 0, (int) vertices.size());
+        glColor4fv(baseColor);
     }
 
     void J2D::OutlineTriangle(const Color4& color, const Triangle2D& tri, float thickness) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {{tri.A.x, tri.A.y}, {tri.B.x, tri.B.y}, {tri.C.x, tri.C.y}};
 
         glLineWidth(thickness);
-        glColor4f(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_LINE_LOOP, 0, 3);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J2D::OutlineTriangle(const Color3& color, const Triangle2D& tri, float thickness) {
-        J2D::OutlineTriangle({color.r, color.g, color.b, 255}, tri, thickness);
+        glColor4fv(baseColor);
     }
 
     void J2D::FillTriangle(const Color4& color, const Triangle2D& tri) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {{tri.A.x, tri.A.y}, {tri.B.x, tri.B.y}, {tri.C.x, tri.C.y}};
 
-        glColor4f(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+        glColor4ubv(color.ptr());
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_TRIANGLES, 0, 3);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
     }
 
     void J2D::FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Triangle2D& tri) {
         if (!inJ2D)
-            ERROR("Attempt to Render J2D element before J2D begin.")
+            jlog::Error("Drawing J2D element before J2D begin.");
 
         Vector2 vertices[] = {{tri.A.x, tri.A.y}, {tri.B.x, tri.B.y}, {tri.C.x, tri.C.y}};
-        GLfloat colors[] = {a_color.r / 255.f, a_color.g / 255.f, a_color.b / 255.f, a_color.a / 255.f,b_color.r / 255.f,
-                            b_color.g / 255.f, b_color.b / 255.f, b_color.a / 255.f,c_color.r / 255.f, c_color.g / 255.f, c_color.b / 255.f,
-                            c_color.a / 255.f };
+        GLfloat colors[] = {a_color.RedChannelNormalized(), a_color.GreenChannelNormalized(), a_color.BlueChannelNormalized(), a_color.AlphaChannelNormalized(),
+                            b_color.RedChannelNormalized(),b_color.GreenChannelNormalized(), b_color.BlueChannelNormalized(), b_color.AlphaChannelNormalized(),
+                            c_color.RedChannelNormalized(), c_color.GreenChannelNormalized(), c_color.BlueChannelNormalized(),c_color.AlphaChannelNormalized()};
 
         glEnableClientState(GL_COLOR_ARRAY);
         glColorPointer(4, GL_FLOAT, sizeof(Color4), colors);
         glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
         glDrawArrays(GL_TRIANGLES, 0, 3);
         glDisableClientState(GL_COLOR_ARRAY);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
     }
 
-    void J2D::FillGradientTriangle(const Color3& a_color, const Color3& b_color, const Color3& c_color, const Triangle2D& tri) {
-        J2D::FillGradientTriangle(Color4(a_color), Color4(b_color), Color4(c_color), tri);
-    }
-
-
-    void J2D::FillTriangle(const Color3& color, const Triangle2D& tri) {
-        J2D::FillTriangle({color.r, color.g, color.b, 255}, tri);
-    }
-
-
-
-    void J2D::DrawCubicBezierCurve(const Color4 &color, const J3ML::LinearAlgebra::Vector2 &controlA,
-                                   const J3ML::LinearAlgebra::Vector2 &pointA,
-                                   const J3ML::LinearAlgebra::Vector2 &pointB,
-                                   const J3ML::LinearAlgebra::Vector2 &controlB, int subdivisions, float thickness) {
+    void J2D::DrawCubicBezierCurve(const Color4 &color, const Vector2& controlA, const Vector2& pointA, const Vector2& pointB, const Vector2& controlB,
+                                   int subdivisions, float thickness) {
 
 
         Vector2 last = controlA;
-        Vector2 first = controlB;
+        const Vector2& first = controlB;
         for (int i = 0; i < subdivisions; ++i)
         {
-            float alpha = (float)i / (float)subdivisions;
+            float alpha = (float) i / (float) subdivisions;
             Vector2 step = J3ML::Algorithm::Bezier(alpha, controlA, pointA, pointB, controlB);
             DrawLine(color, last, step, thickness);
             last = step;
@@ -521,19 +517,12 @@ namespace JGL {
 
         // Have to manually draw the last segment of the curve.
         DrawLine(color, last, first, thickness);
-
-        // Display control points
-        DrawPoint(Colors::Red, controlA, 2.f);
-        DrawPoint(Colors::Red, controlB, 2.f);
-        DrawPoint(Colors::Reds::Salmon, pointA, 2.f);
-        DrawPoint(Colors::Reds::Salmon, pointB, 2.f);
-
     }
 
     //The 3D projection.
     std::vector<GLfloat> perspective(float fov, float aspect, float nearPlane, float farPlane) {
         std::vector<float> result(16);
-        float f = 1.0f / tan(fov * 0.5f * Math::Pi / 180.0f);
+        float f = 1.0f / std::tan(fov * 0.5f * Math::Pi / 180.0f);
         result[0] = f / aspect;
         result[5] = f;
         result[10] = (farPlane + nearPlane) / (nearPlane - farPlane);
@@ -573,7 +562,7 @@ namespace JGL {
 
         //Get what the draw color was before we did anything.
         glGetFloatv(GL_CURRENT_COLOR, oldColor);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+        glColor4fv(baseColor);
 
         wasDepthTestEnabled = false;
         if (glIsEnabled(GL_DEPTH_TEST))
@@ -590,7 +579,6 @@ namespace JGL {
             wasTexture2DEnabled = false,
             glEnable(GL_TEXTURE_2D);
 
-        // TODO: implement bool drawBackface as DrawString parameter.
         wasCullFaceEnabled = false;
         if (glIsEnabled(GL_CULL_FACE))
             wasCullFaceEnabled = true,
@@ -606,7 +594,8 @@ namespace JGL {
 
         if (!inJ2D)
             inJ3D = true;
-        else { ERROR("Attempt to Begin J3D inside of J2D context.")}
+        else
+            jlog::Error("Can't begin J3D context inside J2D context.");
     }
 
     void J3D::End() {
@@ -626,25 +615,20 @@ namespace JGL {
             glEnable(GL_CULL_FACE);
 
         //Put the draw color back how it was before.
-        glColor4f(oldColor[0], oldColor[1], oldColor[2], oldColor[3]);
-
+        glColor4fv(oldColor);
         inJ3D = false;
     }
 
     void J3D::DrawLine(const Color4& color, const Vector3& A, const Vector3& B, float thickness) {
         if (!inJ3D)
-            ERROR("Attempt to Render J3D element before J3D begin.")
+            jlog::Error("Attempt to Render J3D element before J3D begin.");
 
         Vector3 vertices[] = {A, B};
 
         glLineWidth(thickness);
-        glColor4f(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+        glColor4ubv(color.ptr());
         glVertexPointer(3, GL_FLOAT, sizeof(Vector3), vertices);
         glDrawArrays(GL_LINES, 0, 2);
-        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
-    }
-
-    void J3D::DrawLine(const Color3& color, const Vector3& A, const Vector3& B, float thickness) {
-        J3D::DrawLine({color.r, color.g, color.b, 255}, A, B, thickness);
+        glColor4fv(baseColor);
     }
 }

src/TextRendering.cpp

@@ -2,20 +2,20 @@
 
 
 #if __linux__
-#include <freetype2/ft2build.h>
-#include FT_FREETYPE_H
-#include FT_OUTLINE_H
-
+    #include <freetype2/ft2build.h>
+    #include FT_FREETYPE_H
+    #include FT_OUTLINE_H
 #endif
+
 #if _WIN32
-#include <ft2build.h>
-#include FT_FREETYPE_H
-#include FT_OUTLINE_H
+    #include <ft2build.h>
+    #include FT_FREETYPE_H
+    #include FT_OUTLINE_H
 #endif
 
-#include <JGL/Font.h>
-#include <JGL/FontCache.h>
-#include <jlog/jlog.hpp>
+#include <JGL/types/Font.h>
+#include <JGL/types/FontCache.h>
+#include <JGL/Logger.h>
 
 namespace JGL {
 
@@ -31,13 +31,6 @@ namespace JGL {
 
         CachedFont* cachedFont = fontCache.getFont(size, font.index);
 
-        //Set up the regular font.
-        //for (const auto &f : Font::GetLoadedFonts())
-        //    if (f.index == font.index)
-        //        font = f;
-
-
-
         if (font.face == nullptr)
             return;
 
@@ -45,7 +38,7 @@ namespace JGL {
 
         //If the font doesn't exist in the cache yet.
         if (!cachedFont) {
-            DEBUG("Caching font data...");
+            jlog::Debug("Caching font data...");
             GLuint texture_id;
             glGenTextures(1, &texture_id);
             glBindTexture(GL_TEXTURE_2D, texture_id);
@@ -74,7 +67,7 @@ namespace JGL {
 
                 FT_GlyphSlot g = font.face->glyph;
                 width += g->bitmap.width;
-                max_height = std::max(max_height, (GLsizei)g->bitmap.rows);
+                max_height = std::max(max_height, (GLsizei) g->bitmap.rows);
                 charcode = FT_Get_Next_Char(font.face, charcode, &gindex);
             }
 
@@ -115,7 +108,7 @@ namespace JGL {
             }
         }
 
-        glColor4f(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+        glColor4ubv(color.ptr());
 
         //Texture parameters are restored when the texture_handle is bound
         glBindTexture(GL_TEXTURE_2D, *cachedFont->getTexture());
@@ -125,8 +118,9 @@ namespace JGL {
 
         for (int i = 0; i < text.length(); i++) {
             float x2, y2, w, h;
-            CachedGlyph *glyph = cachedFont->getGlyph(text.c_str()[i]);
-            if (glyph == nullptr) continue;
+            CachedGlyph* glyph = cachedFont->getGlyph(text.c_str()[i]);
+            if (glyph == nullptr)
+                continue;
 
             x2 = x + glyph->x2offset * scale;
             y2 = y - glyph->y2offset * scale; // Adjust y-coordinate
@@ -150,18 +144,12 @@ namespace JGL {
 
         glVertexPointer(2, GL_FLOAT, sizeof(GLfloat) * 2, vertices.data());
         glTexCoordPointer(2, GL_FLOAT, sizeof(GLfloat) * 2, texcoords.data());
-        glDrawArrays(GL_TRIANGLES, 0, vertices.size() * 6);
+        glDrawArrays(GL_TRIANGLES, 0, (int) vertices.size() * 6);
         glBindTexture(GL_TEXTURE_2D, 0);
         glColor4f(1, 1, 1, 1);
     }
 
-    void J2D::DrawString(const Color3& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font) {
-        J2D::DrawString(Color4::FromColor3(color, 255), text, x, y, scale, size, font);
-    }
-
-
-
-    void J3D::DrawString(const Color4& color, const std::string& text, const Vector3& pos, const Vector3& angle, float scale, u32 size, const Font& font) {
+    void J3D::DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font, const EulerAngle& angle, bool draw_back_face) {
         //TODO figure out what the scale should actually be mathematically.
         scale = scale * 0.002f;
         scale = -scale;
@@ -173,25 +161,18 @@ namespace JGL {
         glUseProgram(0); // Fixed-function pipeline.
         glColor4ubv(color.ptr());
 
-        //Font font;
-        //for (auto& f : Font::GetLoadedFonts())
-            //if (f.index == font.index)
-               //font = f;
-        if (font.face == NULL) {
-            std::cout << "null font" << std::endl;
-            return;
-        }
+        if (font.face == nullptr)
+            throw std::runtime_error("FreeType font face is null.");
 
         FT_Set_Pixel_Sizes(font.face, 0, size);
 
         glPushMatrix();
         glTranslatef(x, y, z);
-        glRotatef(angle.x, 1.0f, 0.0f, 0.0f);
-        glRotatef(angle.y, 0.0f, 1.0f, 0.0f);
-        glRotatef(angle.z, 0.0f, 0.0f, 1.0f);
-        x = 0;
-        y = 0;
-        z = 0;
+        glRotatef(angle.pitch, 1.0f, 0.0f, 0.0f);
+        glRotatef(angle.yaw, 0.0f, 1.0f, 0.0f);
+        glRotatef(angle.roll, 0.0f, 0.0f, 1.0f);
+
+        x = y = z = 0;
 
         for (int i = 0; i < text.length(); i++)
         {
@@ -215,6 +196,10 @@ namespace JGL {
             float w = g->bitmap.width * scale;
             float h = g->bitmap.rows * scale;
 
+            if (!draw_back_face)
+                glEnable(GL_CULL_FACE),
+                glCullFace(GL_BACK);
+
             glBegin(GL_TRIANGLES);
 
             glTexCoord2f(0, 0);
@@ -237,6 +222,9 @@ namespace JGL {
 
             glEnd();
 
+            if (!draw_back_face)
+                glDisable(GL_CULL_FACE);
+
             x += (g->advance.x >> 6) * scale;
             y += (g->advance.y >> 6) * scale;
         }

src/types/Font.cpp

@@ -16,8 +16,8 @@
     #include FT_OUTLINE_H
 #endif
 
-#include <JGL/Font.h>
-#include <JGL/FontCache.h>
+#include <JGL/types/Font.h>
+#include <JGL/types/FontCache.h>
 
 namespace JGL::Detail
 {

src/types/FontCache.cpp

@@ -1,4 +1,4 @@
-#include <JGL/FontCache.h>
+#include <JGL/types/FontCache.h>
 
 using namespace JGL;
 

src/types/Texture.cpp

@@ -1,4 +1,4 @@
-#include <JGL/Texture.h>
+#include <JGL/types/Texture.h>
 #include <iostream>
 
 using namespace ReTexture;