Merge remote-tracking branch 'origin/master'

src/JGL.cpp

@@ -42,7 +42,7 @@ namespace JGL {
         glGetFloatv(GL_CURRENT_COLOR, oldColor);
         glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
 
-        glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTextureUnit);
+        glGetIntegerv(GL_ACTIVE_TEXTURE,& activeTextureUnit);
         activeTextureUnit = activeTextureUnit - GL_TEXTURE0;
         if (activeTextureUnit != 0)
             glActiveTexture(GL_TEXTURE0);
@@ -126,16 +126,16 @@ namespace JGL {
     }
 
     //TODO rotation, I'm unsure if @josh wants degrees or radians.
-    void J2D::DrawSprite(GLuint texture, const Vector2& pos, const Vector2& size, u8 opacity, Inversion inversion) {
+    void J2D::DrawSprite(GLuint texture, const Vector2& pos, const Vector2& size, u8 opacity, Inversion::Inversion inversion) {
         if (!inJ2D)
             ERROR("Attempt to Render J2D element before J2D begin.")
 
         std::array<Vector2, 4> textureCoordinates = {Vector2(0, 0), Vector2(0, 1), Vector2(1, 1), Vector2(1, 0)};;
         const 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}};
 
-        if (inversion & Inversion::Vertical)
+        if (inversion&  Inversion::Vertical)
             textureCoordinates = {Vector2(0, 1), Vector2(0, 0), Vector2(1, 0), Vector2(1, 1)};
-        if (inversion & Inversion::Horizontal)
+        if (inversion&  Inversion::Horizontal)
             textureCoordinates = {Vector2(1, 0), Vector2(1, 1), Vector2(0, 1), Vector2(0, 0)};
         if ((inversion& Inversion::Horizontal) && (inversion& Inversion::Vertical))
             textureCoordinates = {Vector2(1, 1), Vector2(1, 0), Vector2(0, 0), Vector2(0, 1)};
@@ -149,7 +149,38 @@ namespace JGL {
         glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
     }
 
-    void J2D::DrawSprite(GLuint texture, float x, float y, float w, float h, u8 opacity, Inversion 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.")
+
+        Vector2 vertices[] = {v1, v2, v3, v4};
+        glColor4f(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+        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);
+    }
+
+    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.")
+
+        Vector2 vertices[] = {v1, v2, v3, v4};
+        glLineWidth(thickness);
+        glColor4f(color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f);
+        glVertexPointer(2, GL_FLOAT, sizeof(Vector2), vertices);
+        glDrawArrays(GL_LINE_LOOP, 0, 4);
+        glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
+    }
+
+    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::DrawSprite(GLuint texture, float x, float y, float w, float h, u8 opacity, Inversion::Inversion inversion) {
         J2D::DrawSprite(texture, {x, y}, {w, h}, opacity, inversion);
     }
 
@@ -168,7 +199,7 @@ namespace JGL {
         J2D::FillRect({color.r, color.g, color.b, 255}, pos, size);
     }
 
-    void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Gradient& gradient, const Vector2& pos, const Vector2& size) {
+    void J2D::FillGradientRect(const Color4& color1, const Color4& color2, const Gradient::Gradient& gradient, const Vector2& pos, const Vector2& size) {
         if (!inJ2D)
             ERROR("Attempt to Render J2D element before J2D begin.")
 
@@ -201,11 +232,11 @@ namespace JGL {
         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) {
+    void J2D::FillGradientRect(const Color3& color1, const Color3& color2, const Gradient::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);
     }
 
-    void J2D::FillRoundedRect(const Color4 &color, const Vector2 &pos, const Vector2 &size, float radius, unsigned int subdivisions) {
+    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.")
 
@@ -381,7 +412,7 @@ namespace JGL {
         J2D::OutlineTriangle({color.r, color.g, color.b, 255}, tri, thickness);
     }
 
-    void J2D::FillTriangle(const Color4& color, const Triangle2D &tri) {
+    void J2D::FillTriangle(const Color4& color, const Triangle2D& tri) {
         if (!inJ2D)
             ERROR("Attempt to Render J2D element before J2D begin.")
 
@@ -393,7 +424,29 @@ namespace JGL {
         glColor4f(baseColor[0], baseColor[1], baseColor[2], baseColor[3]);
     }
 
-    void J2D::FillTriangle(const Color3& color, const Triangle2D &tri) {
+    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.")
+
+        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 };
+
+        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]);
+    }
+
+    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);
     }
 

src/JGL/Font.cpp

@@ -8,6 +8,8 @@
 #include <freetype2/ft2build.h>
 #include FT_FREETYPE_H
 #include FT_OUTLINE_H
+#include <JGL/FontCache.h>
+
 #endif
 #if _WIN32
 #include <ft2build.h>
@@ -18,7 +20,6 @@
 
 namespace JGL::Detail
 {
-
     FT_Library ft;
 
     std::vector<Font> fonts;
@@ -95,7 +96,7 @@ namespace JGL
         return Font(path);
     }
 
-    Vector2 Font::MeasureString(const std::string &text, float ptSize) {
+    Vector2 Font::MeasureString(const std::string &text, unsigned int ptSize) {
 
         // TODO: Check if a font of that size is in the cache and if so use the info from that because this is sloooooooooooooow.
         // That'll make it go vroom vroom.
@@ -103,12 +104,32 @@ namespace JGL
         // This is likely returning slightly incorrect results for likely several reasons.
         // Half-ass solution for now ~ dawsh.
 
-        FT_BBox glyph_bbox;
+        Vector2 extents = Vector2(0,0);
+        bool font_of_size_in_cache = false;
+
+        for(const auto& f : fontCache.getFonts()) {
+            if (f->getFontSize() == ptSize) {
+                font_of_size_in_cache = true;
+                break;
+            }
+        }
+
+        if (font_of_size_in_cache) {
+            CachedFont* font;
+
+            for (auto* f: fontCache.getFonts())
+                if (f->getFontSize() == ptSize)
+                    font = f;
+
+            for (const char& c : text)
+                extents.x += font->getGlyph(c)->advanceX;
+
+            extents.y = ptSize;
+            return extents;
+        }
 
         FT_Set_Pixel_Sizes(this->face, ptSize, ptSize);
 
-        Vector2 extents = Vector2(0,0);
-
         for (const char& c : text) {
 
             FT_GlyphSlot slot = face->glyph;
@@ -137,8 +158,6 @@ namespace JGL
             }
         }
 
-
-
         return extents;
     }
 

src/JGL/TextRendering.cpp

@@ -18,8 +18,6 @@
 
 namespace JGL {
 
-    FontCache fontCache; // <-- Not implemented yet
-
     void PurgeFontCache() {
         fontCache.purgeCache();
     }