custom behavior per draw function

Add support for doing custom behavior per draw function for JGL.

You must define uniform int J2D_RENDERING_ROUTINE in any shader to be used by JGL even if you're not doing per draw function behavior.

assets/shader_programs/test_fragment.glsl

@@ -1,13 +1,43 @@
 #version 120
 
-// The color manually set with glColor4f, glColor4ubv etc.
-varying vec4 v_color;
+#define J2D_DrawPoint 1
+#define J2D_DrawPoints 2
+#define J2D_DrawLine 3
+#define J2D_DrawLines 4
+#define J2D_DrawDottedLine 5
+#define J2D_DrawDashedLine 6
+#define J2D_DrawGradientLine 7
+#define J2D_OutlineRect 8
+#define J2D_OutlineRoundedRect 9
+#define J2D_OutlineChamferRect 10
+#define J2D_FillRect 11
+#define J2D_FillGradientRect 12
+#define J2D_FillRoundedRect 13
+#define J2D_FillChamferRect 14
+#define J2D_DrawRenderTarget 15
+#define J2D_DrawPartialRenderTarget 16
+#define J2D_DrawSprite 17
+#define J2D_DrawAlphaMaskSprite 18
+#define J2D_DrawPartialSprite 19
+#define J2D_DrawMirrorSprite 20
+#define J2D_OutlineCircle 21
+#define J2D_FillCircle 22
+#define J2D_OutlineTriangle 23
+#define J2D_FillTriangle 24
+#define J2D_FillGradientTriangle 25
+#define J2D_DrawCubicBezierCurve 26
+#define J2D_OutlinePolygon 27
+#define J2D_DrawString 28
+#define J2D_DrawArc 29
+
+
+uniform int JGL_RENDERING_ROUTINE;
 
 // The number of texture units that have been set.
 uniform int TEXTURE_UNIT_SET_COUNT;
 
-// True if we're rendering text.
-uniform bool TEXT;
+// The color manually set with glColor4f, glColor4ubv etc.
+varying vec4 v_color;
 
 // Texture unit 0 - 7 (8 - 31 will come later).
 uniform sampler2D GL_TEXTURE0;
@@ -34,7 +64,7 @@ void DrawColorOnly() {
 }
 
 void SampleTextureUnits() {
-    if (TEXT)
+    if (JGL_RENDERING_ROUTINE == J2D_DrawString)
         gl_FragColor = vec4(v_color.rgb, v_color.a * texture2D(GL_TEXTURE0, GL_TEXTURE0_COORD).a);
 
     // Draw sprite, partial sprite, mirror sprite, render target, partial render target.
@@ -50,10 +80,75 @@ void SampleTextureUnits() {
 
 }
 
-void main() {
+void Default() {
     if (TEXTURE_UNIT_SET_COUNT == 0) {
         DrawColorOnly(); return;
     }
-
     SampleTextureUnits();
+}
+
+void main() {
+
+/* If you want behavior per JGL draw function, Or for specific ones. The order here matters because some JGL functions call others.
+    if (JGL_RENDERING_ROUTINE == J2D_DrawRenderTarget)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPartialRenderTarget)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawAlphaMaskSprite)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawMirrorSprite)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawSprite)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPartialSprite)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPartialSprite)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawString)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPoint)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPoints)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawCubicBezierCurve)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawLine)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawLines)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawDottedLine)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawDashedLine)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawGradientLine)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineRoundedRect)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillChamferRect)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillRoundedRect)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillGradientRect)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineRect)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillRect)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineCircle)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillCircle)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineTriangle)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillTriangle)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillGradientTriangle)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlinePolygon)
+        Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawArc)
+        Default();
+    else { Default(); }
+*/
+    Default();
 }

assets/shader_programs/test_vertex.glsl

@@ -1,5 +1,37 @@
 #version 120
 
+#define J2D_DrawPoint 1
+#define J2D_DrawPoints 2
+#define J2D_DrawLine 3
+#define J2D_DrawLines 4
+#define J2D_DrawDottedLine 5
+#define J2D_DrawDashedLine 6
+#define J2D_DrawGradientLine 7
+#define J2D_OutlineRect 8
+#define J2D_OutlineRoundedRect 9
+#define J2D_OutlineChamferRect 10
+#define J2D_FillRect 11
+#define J2D_FillGradientRect 12
+#define J2D_FillRoundedRect 13
+#define J2D_FillChamferRect 14
+#define J2D_DrawRenderTarget 15
+#define J2D_DrawPartialRenderTarget 16
+#define J2D_DrawSprite 17
+#define J2D_DrawAlphaMaskSprite 18
+#define J2D_DrawPartialSprite 19
+#define J2D_DrawMirrorSprite 20
+#define J2D_OutlineCircle 21
+#define J2D_FillCircle 22
+#define J2D_OutlineTriangle 23
+#define J2D_FillTriangle 24
+#define J2D_FillGradientTriangle 25
+#define J2D_DrawCubicBezierCurve 26
+#define J2D_OutlinePolygon 27
+#define J2D_DrawString 28
+#define J2D_DrawArc 29
+
+uniform int JGL_RENDERING_ROUTINE;
+
 // The color manually set with glColor4f, glColor4ubv etc etc.
 varying vec4 v_color;
 
@@ -13,6 +45,9 @@ varying vec2 GL_TEXTURE5_COORD;
 varying vec2 GL_TEXTURE6_COORD;
 varying vec2 GL_TEXTURE7_COORD;
 
+vec4 Default() {
+    return gl_ModelViewProjectionMatrix * gl_Vertex;
+}
 
 void main() {
     v_color = gl_Color;
@@ -25,5 +60,67 @@ void main() {
     GL_TEXTURE6_COORD = gl_MultiTexCoord6.xy;
     GL_TEXTURE7_COORD = gl_MultiTexCoord7.xy;
 
-    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+/* If you want behavior per JGL draw function, Or for specific ones. The order here matters because some JGL functions call others.
+    if (JGL_RENDERING_ROUTINE == J2D_DrawRenderTarget)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPartialRenderTarget)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawAlphaMaskSprite)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawMirrorSprite)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawSprite)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPartialSprite)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPartialSprite)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawString)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPoint)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawPoints)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawCubicBezierCurve)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawLine)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawLines)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawDottedLine)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawDashedLine)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawGradientLine)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineRoundedRect)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillChamferRect)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillRoundedRect)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillGradientRect)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineRect)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillRect)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineCircle)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillCircle)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlineTriangle)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillTriangle)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_FillGradientTriangle)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_OutlinePolygon)
+        gl_Position = Default();
+    else if (JGL_RENDERING_ROUTINE == J2D_DrawArc)
+        gl_Position = Default();
+    else { gl_Position = Default(); }
+    */
+
+    gl_Position = Default();
 }

src/renderer/OpenGL/J2D.cpp

@@ -90,7 +90,15 @@ void J2D::DrawPoint(const Color4& color, const Vector2& coordinates, float radiu
     glPointSize(radius);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), coordinates.ptr());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawPoint);
+
     glDrawArrays(GL_POINTS, 0, 1);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -106,7 +114,15 @@ void J2D::DrawLine(const Color4& color, const Vector2& A, const Vector2& B, floa
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawLine);
+
     glDrawArrays(GL_LINES, 0, 2);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -121,7 +137,15 @@ void J2D::DrawLines(const Color4& color, const Vector2* points, const size_t& po
     glLineWidth(thickness);
     glColor3ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), points);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawLines);
+
     glDrawArrays(GL_LINE_STRIP, 0, point_count);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -138,7 +162,13 @@ void J2D::DrawDottedLine(const Color4& color, const Vector2& A, const Vector2& B
     for (unsigned int i = 0; i < point_count; ++i)
         points[i] = A + direction * (i * spacing);
 
-    return J2D::DrawPoints(color, points.data(), points.size(), thickness);
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawDottedLine);
+
+    J2D::DrawPoints(color, points.data(), points.size(), thickness);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
 }
 
 void J2D::DrawDottedLine(const Color4& color, float x1, float y1, float x2, float y2, float spacing, float thickness) {
@@ -155,6 +185,10 @@ void J2D::DrawDashedLine(const Color4& color, const Vector2& A, const Vector2& B
         Logger::Error("Drawing a dashed line that would have no dashes?");
 
     Vector2 A_current, B_current;
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawDashedLine);
+
     for (unsigned int i = 0; i < dash_count; i++) {
         A_current = A + direction * (i * length_of_dash_and_gap);
         B_current = A_current + (direction * dash_length);
@@ -168,6 +202,9 @@ void J2D::DrawDashedLine(const Color4& color, const Vector2& A, const Vector2& B
         B_current = A_current + direction * std::min(dash_length, distance_left);
         J2D::DrawLine(color, A_current, B_current, thickness);
     }
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
 }
 
 void J2D::DrawDashedLine(const Color4& color, float x1, float y1, float x2, float y2, float spacing, float dash_length, float thickness) {
@@ -186,7 +223,15 @@ void J2D::DrawGradientLine(const Color4& color1, const Color4& color2, const Vec
     glLineWidth(thickness);
     glColorPointer(4,GL_FLOAT,sizeof(Color4), colors);
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawGradientLine);
+
     glDrawArrays(GL_LINES, 0, 2);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glDisableClientState(GL_COLOR_ARRAY);
     glColor4fv(default_state.draw_color);
 }
@@ -203,7 +248,15 @@ void J2D::OutlineRect(const Color4& color, const Vector2& pos, const Vector2& si
 
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineRect);
+
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glDrawArrays(GL_LINE_LOOP, 0, 4);
     glColor4fv(default_state.draw_color);
 }
@@ -222,6 +275,9 @@ void J2D::BatchFillRect(const Color4* colors, const Vector2* positions, const Ve
     glBindBuffer(GL_ARRAY_BUFFER, ShapeCache::square_origin_topleft_vertex_data->GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), nullptr);
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillRect);
+
     for (size_t i = 0; i < rect_count; i++) {
         glPushMatrix();
             glColor4ubv(colors[i].ptr());
@@ -230,10 +286,15 @@ void J2D::BatchFillRect(const Color4* colors, const Vector2* positions, const Ve
             glDrawArrays(GL_QUADS, 0, 4);
         glPopMatrix();
     }
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glColor4fv(default_state.draw_color);
 }
 
+// TODO just let them set the color of each corner.
 void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size) {
     if (!state_stack.Size())
         Logger::Error("Drawing J2D element before J2D begin.");
@@ -262,7 +323,15 @@ void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Dir
     glEnableClientState(GL_COLOR_ARRAY);
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
     glColorPointer(4, GL_FLOAT, 0, colors.data());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillGradientRect);
+
     glDrawArrays(GL_QUADS, 0, 4);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glDisableClientState(GL_COLOR_ARRAY);
     glColor4fv(default_state.draw_color);
 }
@@ -278,8 +347,14 @@ void J2D::FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2
         {pos.x + radius, pos.y + size.y - radius}, {pos.x + size.x - radius, pos.y + size.y - radius}
     };
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillRoundedRect);
+
     J2D::BatchFillRect(colors.data(), rect_positions.data(), rect_sizes.data(), 2);
     J2D::BatchFillCircle(colors.data(), circle_positions.data(), circle_radii.data(), subdivisions, 4);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
 }
 
 void J2D::DrawSprite(const Texture* texture, float positionX, float positionY, float rad_rotation,
@@ -351,8 +426,15 @@ void J2D::DrawSprite(const RenderTarget& rt, const Vector2& position, float rad_
         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
     auto r_position = Vector2(Math::Floor(position.x), Math::Floor(position.y));
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawRenderTarget);
+
     J2D::DrawPartialSprite(*rt.GetTexture(), r_position, {0, 0}, Vector2(rt.GetDimensions()), rad_rotation, origin, scale, color, d);
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     if (rt.OwnsTexture())
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
@@ -432,8 +514,14 @@ void J2D::DrawSprite(const Texture& texture, const Texture& alpha_mask, const Ve
         current_state.current_shader->SetInt("GL_TEXTURE1", 1);
 
     // Draw.
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawAlphaMaskSprite);
+
     glDrawArrays(GL_QUADS, 0, 4);
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     if (current_state.current_shader)
         current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 0),
         current_state.current_shader->SetInt("GL_TEXTURE1", 0);
@@ -494,8 +582,14 @@ void J2D::DrawPartialRenderTarget(const RenderTarget& rt, const Vector2& positio
     auto r_position = Vector2(Math::Floor(position.x), Math::Floor(position.y));
     auto r_sub_texture_position = Vector2(Math::Floor(sub_texture_position.x), Math::Floor(sub_texture_position.y));
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawPartialRenderTarget);
+
     J2D::DrawPartialSprite(*rt.GetTexture(), r_position, r_sub_texture_position, sub_texture_size, rad_rotation, origin, scale, color, d);
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     if (rt.OwnsTexture())
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
@@ -519,9 +613,6 @@ void J2D::DrawSprite(const Texture& texture, const Vector2& pos, float rad_rotat
     else
         textureCoordinates = {Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 0)};
 
-    // TODO: Kind of a mess, refactor to be more sensible later.
-    // 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;
     Vector2 scaled_size = scale * size;
@@ -561,16 +652,19 @@ void J2D::DrawSprite(const Texture& texture, const Vector2& pos, float rad_rotat
     glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), textureCoordinates.data());
 
     if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawSprite),
         current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 1);
 
     glDrawArrays(GL_QUADS, 0, 4);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0),
+        current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 0);
+
     glBindTexture(GL_TEXTURE_2D, 0);
     glColor4fv(default_state.draw_color);
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     glDisable(GL_TEXTURE_2D);
-
-    if (current_state.current_shader)
-        current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 0);
 }
 
 
@@ -657,11 +751,13 @@ void J2D::DrawPartialSprite(const Texture& texture, const Vector2& position, con
     glTexCoordPointer(2, GL_FLOAT, 0, textureCoordinates.data());
 
     if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawPartialSprite),
         current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 1);
 
     glDrawArrays(GL_QUADS, 0, 4);
 
     if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0),
         current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 0);
 
     glBindTexture(GL_TEXTURE_2D, 0);
@@ -747,11 +843,13 @@ void J2D::DrawMirrorSprite(const Texture& texture, const Vector2& position, Dire
     glTexCoordPointer(2, GL_FLOAT, sizeof(Vector2), textureCoordinates.data());
 
     if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawMirrorSprite),
         current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 1);
 
     glDrawArrays(GL_QUADS, 0, 4);
 
     if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0),
         current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 0);
 
     //Reset the wrapping mode.
@@ -794,7 +892,15 @@ void J2D::OutlineCircle(const Color4& color, const Vector2& center, float radius
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineCircle);
+
     glDrawArrays(GL_LINE_LOOP, 0, (int) vertices.size());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -828,6 +934,10 @@ void J2D::BatchFillCircle(const Color4* colors, const Vector2* positions, float*
     }
 
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillCircle);
+
     for (size_t j = 0; j < circle_count; j++) {
         glPushMatrix();
             glColor4ubv(colors[j].ptr());
@@ -836,6 +946,10 @@ void J2D::BatchFillCircle(const Color4* colors, const Vector2* positions, float*
             glDrawArrays(GL_TRIANGLE_FAN, 0, (int) vertices.size());
         glPopMatrix();
     }
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -848,7 +962,15 @@ void J2D::OutlineTriangle(const Color4& color, const Triangle2D& tri, float thic
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineTriangle);
+
     glDrawArrays(GL_LINE_LOOP, 0, 3);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -860,7 +982,15 @@ void J2D::FillTriangle(const Color4& color, const Triangle2D& tri) {
 
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillTriangle);
+
     glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -876,7 +1006,15 @@ void J2D::FillGradientTriangle(const Color4& a_color, const Color4& b_color, con
     glEnableClientState(GL_COLOR_ARRAY);
     glColorPointer(4, GL_FLOAT, sizeof(Color4), colors);
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillGradientTriangle);
+
     glDrawArrays(GL_TRIANGLES, 0, 3);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glDisableClientState(GL_COLOR_ARRAY);
     glColor4fv(default_state.draw_color);
 }
@@ -898,7 +1036,14 @@ void J2D::DrawCubicBezierCurve(const Color4& color, const Vector2& controlA, con
     }
     vertices[2 * subdivisions] = last;
     vertices[2 * subdivisions + 1] = first;
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawCubicBezierCurve);
+
     DrawLines(color, vertices.data(), vertices.size(), thickness);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
 }
 
 void J2D::OutlinePolygon(const Color4& color, const Vector2* points, int points_size, float thickness) {
@@ -911,7 +1056,15 @@ void J2D::OutlinePolygon(const Color4& color, const Vector2* points, int points_
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), points);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlinePolygon);
+
     glDrawArrays(GL_LINE_LOOP, 0, points_size);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -949,7 +1102,15 @@ void J2D::DrawArc(const Color4& color, const Vector2& center, float radius, floa
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawArc);
+
     glDrawArrays(GL_LINE_STRIP, 0, (int) vertices.size());
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -1003,6 +1164,9 @@ void J2D::OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vect
 
     unsigned int subdivisions = 9;
 
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineRoundedRect);
+
     J2D::DrawArc(color, anchor_tl, radius, Math::Pi, 3.01f*Math::Pi/2.f, subdivisions, thickness);
     J2D::DrawLine(color, anchor_topleft_top, anchor_topright_top, thickness);
     J2D::DrawArc(color, anchor_tr, radius, 3.f*Math::Pi/2.f, 2.02*Math::Pi, subdivisions, thickness);
@@ -1011,13 +1175,22 @@ void J2D::OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vect
     J2D::DrawLine(color, anchor_bottomright_bottom, anchor_bottomleft_bottom, thickness);
     J2D::DrawArc(color, anchor_bl, radius, Math::Pi/2, Math::Pi*1.01f, subdivisions, thickness);
     J2D::DrawLine(color, anchor_bottomleft_left, anchor_topleft_left, thickness);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
     //J2D::End();
 
 
 }
 
 void J2D::FillChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius) {
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_FillChamferRect);
+
     FillRoundedRect(color, pos, size, radius, 4);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
 }
 
 void J2D::OutlineChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius, float thickness) {
@@ -1034,7 +1207,15 @@ void J2D::OutlineChamferRect(const Color4& color, const Vector2& pos, const Vect
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineChamferRect);
+
     glDrawArrays(GL_LINE_LOOP, 0, 8);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -1049,7 +1230,15 @@ void J2D::DrawPoints(const Color4* colors, const Vector2* points, int point_coun
 
     glBindBuffer(GL_ARRAY_BUFFER, ShapeCache::draw_points_positions->GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), nullptr);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawPoints);
+
     glDrawArrays(GL_POINTS, 0, point_count);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glDisableClientState(GL_COLOR_ARRAY);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glColor4fv(default_state.draw_color);
@@ -1061,7 +1250,15 @@ void J2D::DrawPoints(const Color4& color, const Vector2* points, int point_count
     glColor4ubv(color.ptr());
     glBindBuffer(GL_ARRAY_BUFFER, ShapeCache::draw_points_positions->GetHandle());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), nullptr);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawPoints);
+
     glDrawArrays(GL_POINTS, 0, point_count);
+
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glColor4fv(default_state.draw_color);
 }
@@ -1098,7 +1295,19 @@ void J2D::OutlineEllipse(const Color4& color, const Vector2& position, float rad
     glLineWidth(thickness);
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
+
+    /*
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineElipse);
+        */
+
     glDrawArrays(GL_LINE_LOOP, 0, (int) vertices.size());
+
+    /*
+    if (current_state.current_shader)
+        current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+     */
+
     glColor4fv(default_state.draw_color);
 }
 
@@ -1126,7 +1335,18 @@ void J2D::FillEllipse(const Color4& color, const Vector2& position, float radius
 
     glColor4ubv(color.ptr());
     glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices.data());
+
+    /*
+if (current_state.current_shader)
+    current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_OutlineElipse);
+    */
+
     glDrawArrays(GL_TRIANGLE_FAN, 0, (int) vertices.size());
+
+    /*
+if (current_state.current_shader)
+    current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+    */
     glColor4fv(default_state.draw_color);
 }
 

src/renderer/OpenGL/TextRendering.cpp

@@ -159,13 +159,13 @@ namespace JGL {
 
         if (current_state.current_shader)
             current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 1),
-            current_state.current_shader->SetBool("TEXT", true);
+            current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawString);
 
         glDrawArrays(GL_TRIANGLES, 0, (int) vertices.size() * 6);
 
         if (current_state.current_shader)
             current_state.current_shader->SetInt("TEXTURE_UNIT_SET_COUNT", 0),
-            current_state.current_shader->SetBool("TEXT", false);
+                    current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
 
         glBindTexture(GL_TEXTURE_2D, 0);
         glColor4fv(default_state.draw_color);
@@ -248,13 +248,17 @@ namespace JGL {
             glEnable(GL_CULL_FACE);
             glCullFace(GL_BACK);
 
+        /*
         if (current_state.current_shader)
-            current_state.current_shader->SetBool("TEXT", true);
+            current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", RENDERING_ROUTINE_ID::J2D_DrawString);
+       */
 
         glDrawArrays(GL_TRIANGLES, 0, (int) vertices.size() * 6);
 
+        /*
         if (current_state.current_shader)
-            current_state.current_shader->SetBool("TEXT", false);
+            current_state.current_shader->SetInt("JGL_RENDERING_ROUTINE", 0);
+        */
 
         if (!draw_back_face)
             glDisable(GL_CULL_FACE);

src/renderer/OpenGL/internals/internals.h

@@ -12,8 +12,41 @@
 namespace JGL {
     class State;
     class StateStack;
+    enum RENDERING_ROUTINE_ID : int32_t;
 }
 
+enum JGL::RENDERING_ROUTINE_ID : int32_t {
+    J2D_DrawPoint = 1,
+    J2D_DrawPoints = 2,
+    J2D_DrawLine = 3,
+    J2D_DrawLines = 4,
+    J2D_DrawDottedLine = 5,
+    J2D_DrawDashedLine = 6,
+    J2D_DrawGradientLine = 7,
+    J2D_OutlineRect = 8,
+    J2D_OutlineRoundedRect = 9,
+    J2D_OutlineChamferRect = 10,
+    J2D_FillRect = 11,
+    J2D_FillGradientRect = 12,
+    J2D_FillRoundedRect = 13,
+    J2D_FillChamferRect = 14,
+    J2D_DrawRenderTarget = 15,
+    J2D_DrawPartialRenderTarget = 16,
+    J2D_DrawSprite = 17,
+    J2D_DrawAlphaMaskSprite = 18,
+    J2D_DrawPartialSprite = 19,
+    J2D_DrawMirrorSprite = 20,
+    J2D_OutlineCircle = 21,
+    J2D_FillCircle = 22,
+    J2D_OutlineTriangle = 23,
+    J2D_FillTriangle = 24,
+    J2D_FillGradientTriangle = 25,
+    J2D_DrawCubicBezierCurve = 26,
+    J2D_OutlinePolygon = 27,
+    J2D_DrawString = 28,
+    J2D_DrawArc = 29,
+};
+
 class JGL::State {
 public: