Update CMakeLists.txt

Reviewed-on: #12

CMakeLists.txt

@@ -1,67 +1,67 @@
-cmake_minimum_required(VERSION 3.25)
-project(JGL
-    VERSION 1.0
-    LANGUAGES CXX
-)
-
-if (PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)
-    message(FATAL_ERROR "In-source builds are not allowed")
-endif()
-
-set(CMAKE_CXX_STANDARD 20)
-if (WIN32)
-    set(CMAKE_CXX_FLAGS "-municode")
-endif(WIN32)
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
-
-# Enable Package Managers
-include(cmake/CPM.cmake)
-
-CPMAddPackage(
-        NAME J3ML
-        URL https://git.redacted.cc/josh/j3ml/archive/Prerelease-18.zip
-)
-
-CPMAddPackage(
-        NAME ReWindow
-        URL https://git.redacted.cc/Redacted/ReWindow/archive/vA0.2.14.zip
-)
-
-CPMAddPackage(
-        NAME GLAD
-        URL https://git.redacted.cc/Redacted/glad/archive/v2.1.zip
-)
-
-file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp")
-file(GLOB_RECURSE SOURCES "src/*.c"     "src/*.cpp"    )
-file(GLOB_RECURSE ASSETS  "content/*")
-
-add_library(JGL SHARED ${SOURCES}
-        include/JGL/JGL.h
-        src/JGL/JGL.cpp
-        include/LearnOpenGL/Shader.h
-        include/LearnOpenGL/Texture2D.h
-        include/JGL/Color3.h
-        include/JGL/Colors.h
-        include/JGL/Color4.h
-        )
-set_target_properties(JGL PROPERTIES LINKER_LANGUAGE CXX)
-
-find_package(OpenGL REQUIRED)
-find_package(GLUT REQUIRED)
-find_package(Freetype REQUIRED)
-
-add_executable(JGL_Demo main.cpp)
-set_target_properties(JGL_Demo PROPERTIES LINK_FLAGS "-Wl,-rpath,./lib")
-include_directories(${PROJECT_SOURCE_DIR}/include)
-include_directories(${OPENGL_INCLUDE_DIRS})
-include_directories(${GLUT_INCLUDE_DIRS})
-include_directories(${J3ML_SOURCE_DIR}/include)
-include_directories(${ReWindow_SOURCE_DIR}/include)
-include_directories(${glad_SOURCE_DIR}/include)
-
-target_link_libraries(JGL PRIVATE ${FREETYPE_LIBRARIES})
-target_include_directories(JGL PRIVATE ${FREETYPE_INCLUDE_DIRS})
-target_link_libraries(JGL_Demo PUBLIC JGL ${OPENGL_LIBRARIES} ${GLUT_LIBRARIES} J3ML ReWindowLibrary GLEW glad)
+cmake_minimum_required(VERSION 3.25)
+project(JGL
+    VERSION 1.0
+    LANGUAGES CXX
+)
+
+if (PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)
+    message(FATAL_ERROR "In-source builds are not allowed")
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+if (WIN32)
+    set(CMAKE_CXX_FLAGS "-municode")
+endif(WIN32)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+
+# Enable Package Managers
+include(cmake/CPM.cmake)
+
+CPMAddPackage(
+        NAME J3ML
+        URL https://git.redacted.cc/josh/j3ml/archive/Prerelease-18.zip
+)
+
+CPMAddPackage(
+        NAME ReWindow
+        URL https://git.redacted.cc/Redacted/ReWindow/archive/vA0.2.19.zip
+)
+
+CPMAddPackage(
+        NAME GLAD
+        URL https://git.redacted.cc/Redacted/glad/archive/v2.1.zip
+)
+
+file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp")
+file(GLOB_RECURSE SOURCES "src/*.c"     "src/*.cpp"    )
+file(GLOB_RECURSE ASSETS  "content/*")
+
+add_library(JGL SHARED ${SOURCES}
+        include/JGL/JGL.h
+        src/JGL/JGL.cpp
+        include/LearnOpenGL/Shader.h
+        include/LearnOpenGL/Texture2D.h
+        include/JGL/Color3.h
+        include/JGL/Colors.h
+        include/JGL/Color4.h
+        )
+set_target_properties(JGL PROPERTIES LINKER_LANGUAGE CXX)
+
+find_package(OpenGL REQUIRED)
+find_package(GLUT REQUIRED)
+find_package(Freetype REQUIRED)
+
+add_executable(JGL_Demo main.cpp)
+set_target_properties(JGL_Demo PROPERTIES LINK_FLAGS "-Wl,-rpath,./lib")
+include_directories(${PROJECT_SOURCE_DIR}/include)
+include_directories(${OPENGL_INCLUDE_DIRS})
+include_directories(${GLUT_INCLUDE_DIRS})
+include_directories(${J3ML_SOURCE_DIR}/include)
+include_directories(${ReWindow_SOURCE_DIR}/include)
+include_directories(${glad_SOURCE_DIR}/include)
+
+target_link_libraries(JGL PRIVATE ${FREETYPE_LIBRARIES})
+target_include_directories(JGL PRIVATE ${FREETYPE_INCLUDE_DIRS})
+target_link_libraries(JGL_Demo PUBLIC JGL ${OPENGL_LIBRARIES} ${GLUT_LIBRARIES} J3ML ReWindowLibrary GLEW glad)

include/JGL/JGL.h

@@ -10,6 +10,10 @@
 #include <iostream>
 #include <JGL/Color3.h>
 #include <J3ML/Geometry/Sphere.h>
+#include <J3ML/Geometry/OBB.h>
+#include <J3ML/Geometry/Capsule.h>
+#include <J3ML/Geometry/Plane.h>
+#include <J3ML/Geometry/TriangleMesh.h>
 
 // OpenGL Wrapper for rendering 2D graphics primitives in both a 2D and 3D context
 namespace JGL {
@@ -22,6 +26,10 @@ namespace JGL {
     using J3ML::LinearAlgebra::Quaternion;
 
     using J3ML::Geometry::Sphere;
+    using J3ML::Geometry::OBB;
+    using J3ML::Geometry::Capsule;
+    using J3ML::Geometry::TriangleMesh;
+    using J3ML::Geometry::Plane;
 
     struct HSV {
         float hue;
@@ -47,23 +55,23 @@ namespace JGL {
 
     // TODO: implement correct coloring
     using J3ML::u32;
-    void RenderText(std::string text, float x, float y, float scale, u32 size = 16);
 
     namespace J2D {
-        void DrawPixel2D(const Color3& color, const Vector2 &coordinates);
-        void DrawPixel2D(const Color3& color, float x, float y);
-        void DrawLine2D(const Color3& color, const Vector2 &A, const Vector2 &B, float thickness = 1);
-        void DrawLine2D(const Color3& color, float x, float y, float w, float h, float thickness = 1);
+        void DrawPixel2D(const Color3 &color, const Vector2 &coordinates);
+        void DrawPixel2D(const Color3 &color, float x, float y);
+        void DrawLine2D(const Color3 &color, const Vector2 &A, const Vector2 &B, float thickness = 1);
+        void DrawLine2D(const Color3 &color, float x, float y, float w, float h, float thickness = 1);
         void DrawCubicBezierCurve2D();
-        void OutlineCircle2D(const Color3& color, const Vector2& center, float radius, int subdivisions, float thickness = 1);
-        void FillCircle2D(const Color3& color, const Vector2& center, float radius, int subdivisions);
-        void OutlineTriangle2D();
-        void FillTriangle2D(const Color3& color, const Triangle2D& tri);
+        void OutlineCircle2D(const Color3 &color, const Vector2 &center, float radius, int subdivisions,
+                             float thickness = 1);
+        void FillCircle2D(const Color3 &color, const Vector2 &center, float radius, int subdivisions);
+        void OutlineTriangle2D(const Color3 &color, const Triangle2D &tri);
+        void FillTriangle2D(const Color3 &color, const Triangle2D &tri);
         void FillTexturedTriangle2D();
         void FillTexturedPolygon2D();
         void DrawSprite2D();
         void DrawPartialSprite2D();
-        void DrawString2D();
+        void DrawString2D(const Color3& color, std::string text, float x, float y, float scale, u32 size = 16);
         void FillRect2D(const Color3 &color, const Vector2 &pos, const Vector2 &size);
         void OutlineRect2D       ( const Color3& color, const Vector2& pos, const Vector2& size, float thickness = 1);
         void FillRoundedRect2D   (const Color3& color, const Vector2& pos, const Vector2& size, float radius);
@@ -74,11 +82,14 @@ namespace JGL {
     }
     namespace J3D {
         void DrawLine3D(const Color3& color, const Vector3 &A, const Vector3 &B, float thickness = 1);
-        void FillSphere3D();
-        void WireframeSphere3D(const Sphere& sphere)
-        {
-
-        }
+        void FillSphere3D(const Color3& color, const Sphere& sphere);
+        void WireframeSphere3D(const Color3& color, const Sphere& sphere, float thickness = 1);
+        void FillOBB3D(const Color3& color, const OBB& obb);
+        void WireframeOBB3D(const Color3& color, const OBB& obb, float thickness = 1);
+        void FillCapsule3D(const Color3& color, const Capsule& capsule);
+        void WireframeCapsule3D(const Color3& color, const Capsule& cap, float thickness = 1);
+        void FillTriangleMesh3D(const Color3& color, const TriangleMesh& mesh);
+        void WireframeTriangleMesh3D(const Color3& color, const TriangleMesh& mesh, float thickness = 1);
         void DrawString3D(const Color3& color, const std::string& text, const Vector3& pos, float scale, u32 size = 12);
 
         void DrawMatrixGizmo     (const Matrix3x3&, const Vector3&);

include/LearnOpenGL/Mesh.h

@@ -0,0 +1,149 @@
+/// @file Mesh.h
+/// @description
+/// @author LearnOpenGL - Updated Josh O'Leary
+/// @lastedit 2024-02-22
+
+// Original Source:
+// https://learnopengl.com/code_viewer_gh.php?code=includes/learnopengl/mesh.h
+
+#pragma once
+
+#include <glad/glad.h>
+#include <GL/glew.h>
+#include <GL/glext.h>
+#include <J3ML/LinearAlgebra/Vector3.h>
+#include <J3ML/LinearAlgebra/Vector2.h>
+#include <string>
+#include "Shader.h"
+
+using J3ML::LinearAlgebra::Vector2;
+using J3ML::LinearAlgebra::Vector3;
+using J3ML::u32;
+
+constexpr int MAX_BONE_INFLUENCE = 4;
+
+namespace LearnOpenGL
+{
+
+    struct Vertex
+    {
+        Vector3 Position;
+        Vector3 Normal;
+        Vector2 TexCoords;
+        Vector3 Tangent;
+        Vector3 BiTangent;
+        int BoneIDs[MAX_BONE_INFLUENCE];
+        float BoneWeights[MAX_BONE_INFLUENCE];
+    };
+
+    // Different from Texture2D in purpose
+    struct Texture {
+        unsigned int id;
+        std::string type;
+        std::string path;
+    };
+
+    class Mesh {
+    public:
+        std::vector<Vertex> vertices;
+        std::vector<uint> indices;
+        std::vector<Texture> textures;
+        uint VAO;
+
+        Mesh(std::vector<Vertex> verts, std::vector<uint> indices, std::vector<Texture> textures)
+        {
+            this->vertices = verts;
+            this->indices = indices;
+            this->textures = textures;
+
+            setupMesh();
+        }
+
+        void Draw(Shader &shader)
+        {
+            uint diffuse  = 1;
+            uint specular = 1;
+            uint normal   = 1;
+            uint height   = 1;
+            for (uint i = 0; i < textures.size(); i++)
+            {
+                // activate proper texture unit before binding
+                glActiveTexture(GL_TEXTURE0 + i);
+                // retrieve texture number (the N in diffuse_textureN)
+                std::string number;
+                std::string name = textures[i].type;
+                if (name == "texture_diffuse")
+                    number = std::to_string(diffuse++);
+                else if (name == "texture_specular")
+                    number = std::to_string(specular++);
+                else if (name == "texture_normal")
+                    number = std::to_string(normal++);
+                else if (name == "texture_height")
+                    number = std::to_string(height++);
+
+                // now set the sampler to the correct texture unit
+                glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i);
+                // and finally bind the texture
+                glBindTexture(GL_TEXTURE_2D, textures[i].id);
+            }
+
+            // draw mesh
+            glBindVertexArray(VAO);
+            glDrawElements(GL_TRIANGLES, static_cast<uint>(indices.size()), GL_UNSIGNED_INT, 0);
+            glBindVertexArray(0);
+
+            // always good practice to set everything back to defaults once configured.
+
+            glActiveTexture(GL_TEXTURE0);
+        }
+    private:
+        // render data
+        unsigned int VBO, EBO;
+
+        // initializes all the buffer objects/arrays
+        void setupMesh()
+        {
+            glGenVertexArrays(1, &VAO);
+            glGenBuffers(1, &VBO);
+            glGenBuffers(1, &EBO);
+
+            glBindVertexArray(VAO);
+            // load data into vertex buffers
+            glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+            // A great thing about structs is that their memory layout is sequential for all member items
+            // The effect is that we can simply pass a pointer to the struct and it translates perfectly to a glm::vec3/vec2 array
+            // which again translates to 3/2 floats which translates to a byte array
+            // Except we use J3ML instead of glm, but the concept applies nonetheless
+            glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
+
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+            glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(uint), &indices[0], GL_STATIC_DRAW);
+
+            // set the vertex attribute pointers
+            // vertex positions
+            glEnableVertexAttribArray(0);
+            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
+            // vertex normals
+            glEnableVertexAttribArray(1);
+            glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
+            // vertex texture coords
+            glEnableVertexAttribArray(2);
+            glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));
+            // vertex tangent
+            glEnableVertexAttribArray(3);
+            glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Tangent));
+            // vertex bitangent
+            glEnableVertexAttribArray(4);
+            glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, BiTangent));
+                // ids
+                glEnableVertexAttribArray(5);
+                glVertexAttribIPointer(5, 4, GL_INT, sizeof(Vertex), (void*)offsetof(Vertex, BoneIDs));
+
+                // weights
+                glEnableVertexAttribArray(6);
+                glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, BoneWeights));
+            glBindVertexArray(0);
+        }
+    };
+}

main.cpp

@@ -53,7 +53,9 @@ class JGLDemoWindow : public ReWindow::RWindow
 public:
     LearnOpenGL::Shader shader;
 
-    JGLDemoWindow() : ReWindow::RWindow()
+    JGLDemoWindow() : ReWindow::RWindow() {}
+    JGLDemoWindow(const std::string& title, int width, int height) :
+            ReWindow::RWindow(title, width, height)
     {
 
     }
@@ -64,12 +66,12 @@ public:
 
         glMatrixMode(GL_PROJECTION);
         glLoadIdentity();
-        glOrtho(0, 1024, 768, 0, -1, 1);
+        glOrtho(0, getSize().x, getSize().y, 0, -1, 1);
         glMatrixMode(GL_MODELVIEW);
 
         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
-        //glEnable(GL_CULL_FACE);
+        glEnable(GL_CULL_FACE);
         glEnable(GL_BLEND);
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         glEnable(GL_TEXTURE_2D);
@@ -82,6 +84,11 @@ public:
     {
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glOrtho(0, getSize().x, getSize().y, 0, -1, 1);
+        glMatrixMode(GL_MODELVIEW);
+
         JGL::J2D::FillRect2D(JGL::Colors::Blue, {32, 32}, {100.5, 100.5});
         JGL::J2D::FillRect2D(JGL::Colors::Blue, {32, 32}, {100.5, 100.5});
 
@@ -95,7 +102,7 @@ public:
 
 
         JGL::J3D::DrawString3D(JGL::Colors::White, "JGL Sample Text", {1, -120, 0.5f}, 2.f);
-        JGL::RenderText("William J. Tomasine II ", 0.f, -120.f, 1.f);
+        JGL::J2D::DrawString2D(JGL::Colors::Green, "William J. Tomasine II ", 0.f, -120.f, 1.f);
 
         JGL::J2D::DrawLine2D(JGL::Colors::Greens::DarkGreen, {10, 10}, {200, 300});
         JGL::J3D::DrawLine3D(JGL::Colors::Red, {0,0,0}, {1,0,0});
@@ -117,9 +124,9 @@ public:
 
 int main(int argc, char** argv)
 {
-    auto* window = new JGLDemoWindow();
-
-    window->init(RenderingAPI::OPENGL, "Window", 1280, 720, false);
+    auto* window = new JGLDemoWindow("JGL Demo Window", 1280, 720);
+    window->setRenderer(RenderingAPI::OPENGL);
+    window->Open();
     window->initGL();
     window->setResizable(true);
     while (window->isAlive())

src/JGL/JGL.cpp

@@ -4,12 +4,10 @@
 
 #include <glad/glad.h>
 #include <JGL/JGL.h>
-#include <GL/glut.h>
 #include <J3ML/LinearAlgebra/Transform2D.h>
-#include <rewindow/types/window.h>
 #include <freetype2/ft2build.h>
 #include FT_FREETYPE_H
-#include "JGL/Color3.h"
+#include <JGL/Color3.h>
 #include <iostream>
 
 
@@ -18,7 +16,6 @@ GLuint texture;
 
 namespace JGL
 {
-
     FT_Face face;
     FT_Library ft;
 
@@ -41,65 +38,6 @@ namespace JGL
         return true;
     }
 
-    void RenderText(std::string text, float x, float y, float scale, u32 text_size) {
-        glUseProgram(0); // Fixed-function pipeline.
-        glColor3f(1.0f, 1.0f, 1.0f);
-
-        FT_Set_Pixel_Sizes(face, 0, text_size);
-
-        const char* c;
-        for (c = text.c_str(); *c; c++)
-        {
-            if (FT_Load_Char(face, *c, FT_LOAD_RENDER))
-                continue;
-
-            FT_GlyphSlot g = face->glyph;
-
-            glActiveTexture(GL_TEXTURE0);
-            glGenTextures(1, &texture);
-            glBindTexture(GL_TEXTURE_2D, texture);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, g->bitmap.width, g->bitmap.rows, 0, GL_ALPHA, GL_UNSIGNED_BYTE, g->bitmap.buffer);
-
-            float x2 = x + g->bitmap_left * scale;
-            float y2 = -y - g->bitmap_top * scale; // Adjust y-coordinate
-            float w = g->bitmap.width * scale;
-            float h = g->bitmap.rows * scale;
-
-            glBegin(GL_TRIANGLES);
-
-                glTexCoord2f(0, 0);
-                glVertex2f(x2, y2);
-
-                glTexCoord2f(0, 1);
-                glVertex2f(x2, y2 + h);
-
-                glTexCoord2f(1, 1);
-                glVertex2f(x2 + w, y2 + h);
-
-                glTexCoord2f(0, 0);
-                glVertex2f(x2, y2);
-
-                glTexCoord2f(1, 1);
-                glVertex2f(x2 + w, y2 + h);
-
-                glTexCoord2f(1, 0);
-                glVertex2f(x2 + w, y2);
-
-            glEnd();
-
-            x += (g->advance.x >> 6) * scale;
-            y += (g->advance.y >> 6) * scale;
-
-        }
-        glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture
-    }
-
     namespace J2D
     {
         void FillRect2D(const Color3 &color, const Vector2 &pos, const Vector2 &size) {
@@ -189,6 +127,16 @@ namespace JGL
             glEnd();
         }
 
+        void OutlineTriangle2D(const Color3& color, const Triangle2D& tri)
+        {
+            glBegin(GL_LINE_LOOP);
+            glColor3f(color.r/255.f, color.g/255.f, color.b/255.f);
+            glVertex2f(tri.A.x, tri.A.y);
+            glVertex2f(tri.B.x, tri.B.y);
+            glVertex2f(tri.C.x, tri.C.y);
+            glEnd();
+        }
+
         void FillTriangle2D(const Color3& color, const Triangle2D& tri)
         {
             glBegin(GL_LINE_LOOP);
@@ -198,6 +146,65 @@ namespace JGL
             glVertex2f(tri.C.x, tri.C.y);
             glEnd();
         }
+
+        void DrawString2D(const Color3& color, std::string text, float x, float y, float scale, u32 size) {
+            glUseProgram(0); // Fixed-function pipeline.
+            glColor3f(color.r/255.f, color.g/255.f, color.b/255.f);
+
+            FT_Set_Pixel_Sizes(face, 0, size);
+
+            const char* c;
+            for (c = text.c_str(); *c; c++)
+            {
+                if (FT_Load_Char(face, *c, FT_LOAD_RENDER))
+                    continue;
+
+                FT_GlyphSlot g = face->glyph;
+
+                glActiveTexture(GL_TEXTURE0);
+                glGenTextures(1, &texture);
+                glBindTexture(GL_TEXTURE_2D, texture);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, g->bitmap.width, g->bitmap.rows, 0, GL_ALPHA, GL_UNSIGNED_BYTE, g->bitmap.buffer);
+
+                float x2 = x + g->bitmap_left * scale;
+                float y2 = -y - g->bitmap_top * scale; // Adjust y-coordinate
+                float w = g->bitmap.width * scale;
+                float h = g->bitmap.rows * scale;
+
+                glBegin(GL_TRIANGLES);
+
+                glTexCoord2f(0, 0);
+                glVertex2f(x2, y2);
+
+                glTexCoord2f(0, 1);
+                glVertex2f(x2, y2 + h);
+
+                glTexCoord2f(1, 1);
+                glVertex2f(x2 + w, y2 + h);
+
+                glTexCoord2f(0, 0);
+                glVertex2f(x2, y2);
+
+                glTexCoord2f(1, 1);
+                glVertex2f(x2 + w, y2 + h);
+
+                glTexCoord2f(1, 0);
+                glVertex2f(x2 + w, y2);
+
+                glEnd();
+
+                x += (g->advance.x >> 6) * scale;
+                y += (g->advance.y >> 6) * scale;
+
+            }
+            glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture
+        }
     }