Merge remote-tracking branch 'origin/master'

2024-08-02 10:49:05 -04:00
parent ff4d014739 9dda4bebc5
commit af42d8fd25
13 changed files with 156 additions and 68 deletions
--- a/.gitea/workflows/buildtest.yml
+++ b/.gitea/workflows/buildtest.yml
@@ -17,8 +17,6 @@ jobs:
      - run: echo "The ${{ gitea.repository }} repository has been cloned to the runner."
      - run: echo "The workflow is now ready to run your tests on the runner."
      - run: echo "Install toolchain and run ReCI build test"
-      - run: apt-get update && apt-get install -y git && git clone $RECI_GIT $RECI
-      - run: bash $RECI/scripts/setup_build_tools.sh
-      - run: bash reci/scripts/install_build_dependencies.sh
-      - run: bash $RECI/scripts/run_buildtest.sh ${{ gitea.repository }}
+      - run: apt-get update && apt-get install -y lua5.3 git && git clone $RECI_GIT $RECI
+      - run: lua $RECI/reci.lua -f $RECI/scripts/buildtools.reci -f reci/scripts/builddeps.reci -f $RECI/scripts/buildtest.reci
      - run: echo "This job's status is ${{ job.status }}."
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,7 +41,7 @@ CPMAddPackage(

 CPMAddPackage(
        NAME ReTexture
-        URL https://git.redacted.cc/Redacted/ReTexture/archive/Prerelease-2.zip
+        URL https://git.redacted.cc/Redacted/ReTexture/archive/Release-1.zip
 )

 if (WIN32)
--- a/include/JGL/Font.h
+++ b/include/JGL/Font.h
@@ -32,7 +32,7 @@ namespace JGL
        /// @param text The string to measure.
        /// @param ptSize The font size at which to measure.
        /// @return The size-in-pixels that would contain the entire text.
-        Vector2 MeasureString(const std::string& text, float ptSize);
+        Vector2 MeasureString(const std::string& text, unsigned int ptSize);
    public:
        int index = 0;
        FT_Face face;
--- a/include/JGL/FontCache.h
+++ b/include/JGL/FontCache.h
@@ -61,3 +61,7 @@ public:
    void eraseFont(CachedFont* font);
    void purgeCache();
 };
+
+namespace JGL {
+    inline FontCache fontCache;
+}
--- a/include/JGL/Gradient.h
+++ b/include/JGL/Gradient.h
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <J3ML/J3ML.h>
-
-namespace JGL {
-    enum class Gradient : u8 {
-        Vertical = 0,
-        Horizontal = 1,
-        DiagonalTopLeft = 2,
-        DiagonalBottomLeft = 3
-    };
-}
--- a/include/JGL/Inversion.h
+++ b/include/JGL/Inversion.h
@@ -1,14 +0,0 @@
-#pragma once
-
-namespace JGL {
-    enum Inversion {
-        None = 0,
-        Vertical = 1,
-        Horizontal = 2,
-    };
-
-    inline Inversion operator|(Inversion a, Inversion b) {
-        return static_cast<Inversion>(static_cast<int>(a) | static_cast<int>(b));
-    }
-
-}
--- a/include/JGL/JGL.h
+++ b/include/JGL/JGL.h
@@ -15,8 +15,7 @@
 #include <string>
 #include <iostream>
 #include <JGL/Color4.h>
-#include <JGL/Gradient.h>
-#include <JGL/Inversion.h>
+#include <JGL/enums.h>
 #include <JGL/FontCache.h>
 #include <JGL/Font.h>
 #include <J3ML/LinearAlgebra.h>
@@ -103,16 +102,26 @@ namespace JGL {
        void OutlineRect(const Color3& color, const Vector2& pos, const Vector2& size, float thickness = 1);

        ///Draws a sprite to the screen.
-        void DrawSprite(GLuint texture, const Vector2& pos, const Vector2& size, u8 opacity = 255, Inversion inversion = Inversion::None);
-        void DrawSprite(GLuint texture, float x, float y, float w, float h, u8 opacity = 255, Inversion inversion = Inversion::None);
+        void DrawSprite(GLuint texture, const Vector2& pos, const Vector2& size, u8 opacity = 255, Inversion::Inversion inversion = Inversion::None);
+        void DrawSprite(GLuint texture, float x, float y, float w, float h, u8 opacity = 255, Inversion::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.
+        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.
+        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);
+        void FillGradientRect(const Color4& color1, const Color4& color2, const Gradient::Gradient& gradient, const Vector2& pos, const Vector2& size);
+        void FillGradientRect(const Color3& color1, const Color3& color2, const Gradient::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);
@@ -132,8 +141,12 @@ namespace JGL {
        // TODO: Implement an overload that simply takes 3 Vector3's

        /// Draws a filled triangle on the screen.
-        void FillTriangle(const Color4& color, const Triangle2D &tri);
+        void FillTriangle(const Color4& color, const Triangle2D& tri);
        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


--- a/include/JGL/enums.h
+++ b/include/JGL/enums.h
@@ -0,0 +1,26 @@
+#pragma once
+
+namespace JGL::Inversion {
+    enum Inversion {
+        None = 0,
+        Vertical = 1,
+        Horizontal = 2,
+    };
+
+    inline Inversion operator|(Inversion a, Inversion b) {
+        return static_cast<Inversion>(static_cast<int>(a) | static_cast<int>(b));
+    }
+}
+
+namespace JGL::Gradient {
+    enum Gradient {
+        Vertical = 0,
+        Horizontal = 1,
+        DiagonalTopLeft = 2,
+        DiagonalBottomLeft = 3
+    };
+
+    inline Gradient operator|(Gradient a, Gradient b) {
+        return static_cast<Gradient>(static_cast<int>(a) | static_cast<int>(b));
+    }
+}
--- a/main.cpp
+++ b/main.cpp
@@ -5,12 +5,13 @@
 #include <J3ML/LinearAlgebra/Vector2.h>
 #include <JGL/Font.h>
 #include <jlog/jlog.hpp>
-#include <ReTexture/rTexture.h>
+#include <ReTexture/Texture.h>

 using J3ML::LinearAlgebra::Vector2;
 using namespace JGL;
+using namespace ReTexture;

-RTexture* image;
+Texture* image;
 GLuint imageID;
 //The Re3D style base projection.
 std::vector<GLfloat> perspective(float fov, float aspect, float nearPlane, float farPlane) {
@@ -90,7 +91,7 @@ public:
        glDepthFunc(GL_LESS);
        glDepthMask(GL_TRUE);

-        image = new RTexture("assets/sprites/Re3D.png");
+        image = new Texture("assets/sprites/Re3D.png");
        glGenTextures(1, &imageID);
        glBindTexture(GL_TEXTURE_2D, imageID);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -98,10 +99,10 @@ public:
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

-        if (image->format == RTextureFormat::RGBA)
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->width, image->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixelData.data());
-        if (image->format == RTextureFormat::RGB)
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image->width, image->height, 0, GL_RGB, GL_UNSIGNED_BYTE, image->pixelData.data());
+        if (image->getTextureFormat() == TextureFormat::RGBA)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image->getWidth(), image->getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, image->pixelData.data());
+        if (image->getTextureFormat() == TextureFormat::RGB)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image->getWidth(), image->getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE, image->pixelData.data());

        glBindTexture(GL_TEXTURE_2D, 0);
    }
@@ -124,8 +125,9 @@ public:
        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(imageID, {0, 52}, {(float) image->width, (float) image->height}, 128);
+            J2D::DrawSprite(imageID, {0, 52}, {(float) image->getWidth(), (float) image->getHeight()}, 128);
            J2D::FillRect(Color4::FromColor3(Colors::Pinks::HotPink), {68, 120}, {32, 32});
            J2D::FillGradientRect(Colors::Red, Colors::Blue, Gradient::DiagonalBottomLeft, {100,52}, {100,100});
            J2D::FillRoundedRect(JGL::Colors::Red, {200, 52}, {100, 100}, 8, 8);
@@ -134,10 +136,10 @@ public:
            J2D::FillCircle(JGL::Colors::White, {52, 204}, 50, 24);
            J2D::OutlineCircle(JGL::Colors::White, {153, 204}, 50, 24);

-            J2D::FillTriangle(Colors::Red, {{0, 275}, {0, 375}, {100, 375}});
+            //J2D::FillTriangle(Colors::Red, {{0, 275}, {0, 375}, {100, 375}});
+            J2D::FillGradientTriangle(Color4(Colors::Red), Color4(Colors::Green), Color4(Colors::Blue), {{0, 275}, {0, 375}, {100, 375}});
            J2D::OutlineTriangle(Colors::Blue, {{100, 275}, {0, 275}, {100, 375}});
            J2D::DrawGradientLine(JGL::Colors::Red, JGL::Colors::Blue, {105, 375}, {200, 275}, 2);
-
            auto result = Jupiteroid.MeasureString("Jupiteroid Font", 16);

            J2D::FillRect(JGL::Colors::Gray, {0, 0}, result);
--- a/reci/scripts/builddeps.reci
+++ b/reci/scripts/builddeps.reci
@@ -0,0 +1 @@
+Main:new("Install build dependencies", "apt-get install -yq libgl1-mesa-dev libfreetype-dev")
--- a/src/JGL.cpp
+++ b/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);
    }

--- a/src/JGL/Font.cpp
+++ b/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;
    }

--- a/src/JGL/TextRendering.cpp
+++ b/src/JGL/TextRendering.cpp
@@ -18,8 +18,6 @@

 namespace JGL {

-    FontCache fontCache; // <-- Not implemented yet
-
    void PurgeFontCache() {
        fontCache.purgeCache();
    }
				`@@ -0,0 +1 @@`
				`Main:new("Install build dependencies", "apt-get install -yq libgl1-mesa-dev libfreetype-dev")`