Update CMakeLists.txt

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;
@@ -50,32 +58,19 @@ namespace JGL {
 
     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 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(const Color3 &color, const Triangle2D &tri);
-
         void FillTriangle2D(const Color3 &color, const Triangle2D &tri);
-
         void FillTexturedTriangle2D();
-
         void FillTexturedPolygon2D();
-
         void DrawSprite2D();
-
         void DrawPartialSprite2D();
-
         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);
@@ -87,8 +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)
     {
 
     }
@@ -69,7 +71,7 @@ public:
 
         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);
@@ -122,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,9 +4,7 @@
 
 #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>