first commit

.gitignore

@@ -0,0 +1,4 @@
+*.a
+obj/
+bin/
+build/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/glfw"]
+	path = vendor/glfw
+	url = https://github.com/TheCherno/glfw

Makefile

@@ -0,0 +1,18 @@
+premake:
+	./premake5 gmake2
+
+gearlib-debug: premake
+	make -C build config=debug
+
+run: gearlib-debug
+	cd examples && ../bin/Debug/test/test
+
+gearlib-release: premake
+	make -C build config=release
+
+install: gearlib-release
+	cp include/* /usr/local/include -r
+	cp bin/Release/gearlib/libgearlib.a bin/Release/glfw/libglfw.a /usr/local/lib
+
+clean:
+	make -C build clean

examples/assets/quad.frag

@@ -0,0 +1,13 @@
+#version 460 core
+
+layout(location = 0) out vec4 color;
+
+struct VertexOutput {
+    vec4 Color;
+};
+
+layout(location = 0) in VertexOutput Input;
+
+void main() {
+    color = Input.Color;
+}

examples/assets/quad.vert

@@ -0,0 +1,21 @@
+#version 460 core
+
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec4 a_Color;
+
+struct VertexOutput {
+    vec4 Color;
+};
+
+layout(location = 0) out VertexOutput Output;
+
+layout(std140, binding = 0) uniform Camera {
+    mat4 view;
+    mat4 projection;
+};
+
+void main() {
+    Output.Color = a_Color;
+    
+    gl_Position = projection * view * vec4(a_Position, 1.0);
+}

examples/assets/texture.frag

@@ -0,0 +1,17 @@
+#version 460 core
+
+layout(location = 0) out vec4 color;
+
+struct VertexOutput {
+    vec4 Tint;
+    vec2 TexCoord;
+};
+
+layout(location = 0) in VertexOutput Input;
+layout(location = 2) in flat float TexID;
+
+layout(binding = 0) uniform sampler2D textures[32];
+
+void main() {
+    color = texture(textures[int(TexID)], Input.TexCoord) * Input.Tint;
+}

examples/assets/texture.vert

@@ -0,0 +1,27 @@
+#version 460 core
+
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec4 a_Tint;
+layout(location = 2) in vec2 a_TexCoord;
+layout(location = 3) in float a_TexID;
+
+struct VertexOutput {
+    vec4 Tint;
+    vec2 TexCoord;
+};
+
+layout(location = 0) out VertexOutput Output;
+layout(location = 2) out flat float TexID;
+
+layout(std140, binding = 0) uniform Camera {
+    mat4 view;
+    mat4 projection;
+};
+
+void main() {
+    Output.Tint = a_Tint;
+    Output.TexCoord = a_TexCoord;
+    TexID = a_TexID;
+    
+    gl_Position = projection * view * vec4(a_Position, 1.0);
+}

examples/quad.cpp

@@ -0,0 +1,39 @@
+#include <gearlib.h>
+
+int main() {
+    Window window = create_window(800, 600, "textures");
+    glfwSwapInterval(0); // fps unlock
+    setup_quads();
+
+    Camera* camera = create_camera(vec2(0.0f, 0.0f));
+    UniformBuffer* camera_buffer = create_uniform_buffer(sizeof(CameraMatrices));
+
+    double time = glfwGetTime();
+
+    while (!glfwWindowShouldClose(window)) {
+        process_input(window);
+        update_camera(camera, window);
+        set_uniform_data(camera_buffer, camera->m);
+
+        glClearColor(vec4_spread(BLUE));
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        draw_quad(vec2(10, 10), vec2(500, 500), RED);
+
+        flush();
+
+	double end_time = glfwGetTime();
+	double frame_time = end_time - time;
+	time = end_time;
+
+	double fps = 1.0 / frame_time;
+	printf("frame_time: %lf fps: %lf\n", frame_time, fps);
+    
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}

examples/test.cpp

@@ -0,0 +1,44 @@
+#include <gearlib.h>
+
+int main() {
+    Window window = create_window(800, 600, "test");
+    glfwSwapInterval(0); // fps unlock
+    enable_debugging();
+    setup_textures();
+
+    Camera* camera = create_camera(vec2(0.0f, 0.0f));
+    UniformBuffer* camera_buffer = create_uniform_buffer(sizeof(CameraMatrices));
+
+    Texture cat = load_texture("assets/cat.png");
+
+    double time = glfwGetTime();
+
+    while (!glfwWindowShouldClose(window)) {
+        process_input(window);
+        update_camera(camera, window);
+        set_uniform_data(camera_buffer, camera->m);
+
+        glClearColor(vec4_spread(BLACK));
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        for(int i = 0; i < 32; i++) {
+            draw_texture(cat, vec2(rand() % 600, rand() % 600), vec2(500.0f, 500.0f), WHITE);
+        }
+
+        flush();
+
+	double end_time = glfwGetTime();
+	double frame_time = end_time - time;
+	time = end_time;
+
+	double fps = 1.0 / frame_time;
+	printf("frame_time: %lf fps: %lf\n", frame_time, fps);
+    
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}

examples/textures.cpp

@@ -0,0 +1,41 @@
+#include <gearlib.h>
+
+int main() {
+    Window window = create_window(800, 600, "textures");
+    glfwSwapInterval(0); // fps unlock
+    setup_textures();
+
+    Camera* camera = create_camera(vec2(0.0f, 0.0f));
+    UniformBuffer* camera_buffer = create_uniform_buffer(sizeof(CameraMatrices));
+
+    Texture cat = load_texture("assets/cat.png");
+
+    double time = glfwGetTime();
+
+    while (!glfwWindowShouldClose(window)) {
+        process_input(window);
+        update_camera(camera, window);
+        set_uniform_data(camera_buffer, camera->m);
+
+        glClearColor(vec4_spread(BLUE));
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        draw_texture(cat, vec2(250.0f, 250.0f), vec2(500.0f, 500.0f), WHITE);
+
+        flush();
+
+	double end_time = glfwGetTime();
+	double frame_time = end_time - time;
+	time = end_time;
+
+	double fps = 1.0 / frame_time;
+	printf("frame_time: %lf fps: %lf\n", frame_time, fps);
+    
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}

include/gearlib.h

@@ -0,0 +1,21 @@
+#ifndef __GEARLIB_H__
+#define __GEARLIB_H__
+
+#define MAX_VERTICES 2500
+
+#include <gearlib/slibs.h>
+#include <gearlib/colors.h>
+#include <gearlib/raymath.h>
+#include <gearlib/init.h>
+#include <gearlib/shaders.h>
+#include <gearlib/events.h>
+#include <gearlib/debugging.h>
+#include <gearlib/vertex.h>
+#include <gearlib/renderer.h>
+#include <gearlib/camera.h>
+#include <gearlib/batch.h>
+#include <gearlib/quad.h>
+#include <gearlib/textures.h>
+#include <gearlib/uniform_buffer.h>
+
+#endif

include/gearlib/KHR/khrplatform.h

@@ -0,0 +1,311 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be included
+** in all copies or substantial portions of the Materials.
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+/*
+ * To support platform where unsigned long cannot be used interchangeably with
+ * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
+ * Ideally, we could just use (u)intptr_t everywhere, but this could result in
+ * ABI breakage if khronos_uintptr_t is changed from unsigned long to
+ * unsigned long long or similar (this results in different C++ name mangling).
+ * To avoid changes for existing platforms, we restrict usage of intptr_t to
+ * platforms where the size of a pointer is larger than the size of long.
+ */
+#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
+#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
+#define KHRONOS_USE_INTPTR_T
+#endif
+#endif
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef KHRONOS_USE_INTPTR_T
+typedef intptr_t               khronos_intptr_t;
+typedef uintptr_t              khronos_uintptr_t;
+#elif defined(_WIN64)
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+#endif
+
+#if defined(_WIN64)
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */

include/gearlib/batch.h

@@ -0,0 +1,39 @@
+#ifndef __BATCH_H__
+#define __BATCH_H__
+
+#include <gearlib.h>
+#include <vector>
+
+typedef struct BatchStats {
+    uint32_t draw_calls;
+    uint32_t total_verts;
+} BatchStats;
+
+typedef struct RenderBatch {
+    uint32_t vbo, vao;
+
+    uint32_t shader;
+
+    void* vertices;
+    void* vertex_ptr;
+    size_t vertex_size;
+    uint32_t vertex_count;
+    uint32_t max_vertices;
+    std::vector<VertexAttrib> layout;
+
+    BatchStats stats;
+
+    void* data;
+    void (*flush_callback)(struct RenderBatch*);
+} RenderBatch;
+
+extern std::vector<RenderBatch*> batches;
+
+RenderBatch* create_batch(size_t vert_size, uint32_t max_verts);
+void flush();
+void flush_batch(RenderBatch* batch);
+void batch_add_attrib(RenderBatch* batch, VertexAttrib attr);
+void batch_bind_attribs(RenderBatch* batch);
+bool batch_needs_flush(RenderBatch* batch, uint32_t vertex_add);
+
+#endif

include/gearlib/camera.h

@@ -0,0 +1,23 @@
+#ifndef __CAMERA_H__
+#define __CAMERA_H__
+
+enum CAMERA_PROJECTION {
+    CAMERA_ORTHOGRAPHIC = 0,
+    CAMERA_PERSPECTIVE
+};
+
+typedef struct CameraMatrices {
+    mat4 view;
+    mat4 projection;
+} CameraMatrices;
+
+typedef struct Camera {
+    vec3 position;
+    int projection;
+    struct CameraMatrices* m;
+} Camera;
+
+Camera* create_camera(vec2 pos);
+void update_camera(Camera* camera, Window window);
+
+#endif

include/gearlib/colors.h

@@ -0,0 +1,12 @@
+#ifndef __COLORS_H__
+#define __COLORS_H__
+
+#define WHITE vec4(1.0f, 1.0f, 1.0f, 1.0f)
+#define BLACK vec4(0.0f, 0.0f, 0.0f, 1.0f)
+#define RED vec4(1.0f, 0.0f, 0.0f, 1.0f)
+#define GREEN vec4(0.0f, 1.0f, 0.0f, 1.0f)
+#define BLUE vec4(0.0f, 0.0f, 1.0f, 1.0f)
+
+#define BLANK vec4(0.0f, 0.0f, 0.0f, 0.0f)
+
+#endif

include/gearlib/debugging.h

@@ -0,0 +1,6 @@
+#ifndef __DEBUGGING_H__
+#define __DEBUGGING_H__
+
+void enable_debugging();
+
+#endif

include/gearlib/events.h

@@ -0,0 +1,9 @@
+#ifndef __EVENTS_H__
+#define __EVENTS_H__
+
+#include <gearlib.h>
+
+void framebuffer_size_callback(Window window, int width, int height);
+void process_input(Window window); 
+
+#endif

include/gearlib/init.h

@@ -0,0 +1,11 @@
+#ifndef __INIT_H__
+#define __INIT_H__
+
+#include <gearlib/opengl.h>
+
+typedef GLFWwindow* Window;
+
+void init_gl(int major, int minor);
+Window create_window(int width, int height, const char* title); 
+
+#endif

include/gearlib/opengl.h

@@ -0,0 +1,7 @@
+#ifndef __OPENGL_H__
+#define __OPENGL_H__
+
+#include <gearlib/glad/gl.h>
+#include <gearlib/GLFW/glfw3.h>
+
+#endif

include/gearlib/quad.h

@@ -0,0 +1,21 @@
+#ifndef __QUAD_H__
+#define __QUAD_H__
+
+#include <gearlib.h>
+
+void setup_quads();
+void draw_quad(vec2 pos, vec2 size, vec4 color);
+void draw_quad_trans(mat4 transform, vec4 color);
+void batch_draw_quad(RenderBatch* batch, mat4 transform, vec4 color);
+RenderBatch* create_quad_batch();
+
+extern RenderBatch* quad_batch;
+
+typedef struct {
+    vec3 Position;
+    vec4 Color;
+} QuadVertex;
+
+extern vec3 quad_vertex_positions[6];
+
+#endif

include/gearlib/renderer.h

@@ -0,0 +1,8 @@
+#ifndef __RENDERER_H__
+#define __RENDERER_H__
+
+#include <stdint.h>
+
+void renderer_draw(uint32_t vao, int count);
+
+#endif

include/gearlib/shaders.h

@@ -0,0 +1,10 @@
+#ifndef __SHADERS_H__
+#define __SHADERS_H__
+
+#include <stdint.h>
+
+uint32_t compile_shader(const char* path, int32_t type);
+uint32_t compile_shader_text(const char* name, const char* text, int32_t type);
+uint32_t load_shader_program(uint32_t shader, ...);
+
+#endif

include/gearlib/textures.h

@@ -0,0 +1,30 @@
+#ifndef __TEXTURES_H__
+#define __TEXTURES_H__
+
+#include <gearlib.h>
+#include <stdint.h>
+
+typedef uint32_t Texture;
+
+void setup_textures();
+Texture load_texture(const char* path);
+void draw_texture(Texture id, vec2 pos, vec2 size, vec4 tint);
+void draw_texture_trans(Texture id, mat4 transform, vec4 tint);
+void batch_draw_texture(RenderBatch* batch, Texture id, mat4 transform, vec4 tint);
+RenderBatch* create_texture_quad_batch();
+
+extern RenderBatch* texture_quad_batch;
+extern int max_textures;
+
+typedef struct {
+    vec3 Position;
+    vec4 Tint;
+    vec2 TexCoord;
+    float TexID;
+} TextureQuadVertex;
+
+typedef struct {
+    float texture_index;
+} TextureQuadBatchData;
+
+#endif

include/gearlib/uniform_buffer.h

@@ -0,0 +1,12 @@
+#ifndef __UNIFORM_BUFFER_H__
+#define __UNIFORM_BUFFER_H__
+
+typedef struct UniformBuffer {
+    size_t size;
+    uint32_t ubo;
+} UniformBuffer;
+
+UniformBuffer* create_uniform_buffer(size_t size);
+void set_uniform_data(UniformBuffer* buffer, void* data);
+
+#endif

include/gearlib/vertex.h

@@ -0,0 +1,12 @@
+#ifndef __VERTEX_H__
+#define __VERTEX_H__
+
+#include <stddef.h>
+
+typedef struct VertexAttrib {
+    int type;
+    size_t size;
+    int count;
+} VertexAttrib;
+
+#endif

premake5.lua

@@ -0,0 +1,45 @@
+local includes = { "include", "include/gearlib" }
+
+workspace "gearlib"
+    configurations { "Debug", "Release" }
+    location "build"
+
+    outputdir = "%{cfg.buildcfg}-%{cfg.system}"
+
+    include "vendor/glfw"
+
+project "gearlib"
+    kind "StaticLib"
+    language "C++"
+    targetdir "bin/%{cfg.buildcfg}/gearlib"
+
+    files { "include/**.h", "src/**.cpp", "src/**.c" }
+    includedirs(includes)
+    links { "GLFW", "m" }
+
+    filter "configurations:Debug"
+        defines { "DEBUG" }
+        symbols "On"
+
+    filter "configurations:Release"
+        defines { "NDEBUG" }
+        optimize "On"
+
+project "test"
+    kind "ConsoleApp"
+    language "C++"
+    targetdir "bin/%{cfg.buildcfg}/test"
+
+    files { "examples/test.cpp" }
+    includedirs(includes)
+    links { "GLFW", "gearlib", "m" }
+
+    debugdir "examples"
+
+    filter "configurations:Debug"
+        defines { "DEBUG" }
+        symbols "On"
+
+    filter "configurations:Release"
+        defines { "NDEBUG" }
+        optimize "On"

src/batch.cpp

@@ -0,0 +1,72 @@
+#include <gearlib.h>
+#include <vector>
+
+std::vector<RenderBatch*> batches;
+
+RenderBatch* create_batch(size_t vert_size, uint32_t max_verts) {
+    RenderBatch* batch = new RenderBatch();
+    batches.push_back(batch);
+    
+    glCreateBuffers(1, &batch->vbo);
+    glCreateVertexArrays(1, &batch->vao);
+
+    batch->vertex_size = vert_size;
+    batch->max_vertices = max_verts;
+    batch->vertices = calloc(vert_size, max_verts);
+    batch->vertex_ptr = batch->vertices;
+    glNamedBufferStorage(batch->vbo, vert_size * max_verts, NULL, GL_DYNAMIC_STORAGE_BIT); 
+    
+    return batch;
+}
+
+void flush() {
+    for(int i = 0; i < batches.size(); i++) {
+        RenderBatch* batch = batches[i];
+
+        batch->stats.total_verts = 0;
+        batch->stats.draw_calls = 0;
+
+        flush_batch(batch); 
+    }
+}
+
+void flush_batch(RenderBatch* batch) {
+    batch->stats.total_verts += batch->vertex_count;
+        
+    glUseProgram(batch->shader);
+
+    if(batch->flush_callback != NULL)
+        batch->flush_callback(batch);
+        
+    glNamedBufferSubData(batch->vbo, 0, batch->vertex_size * batch->vertex_count, batch->vertices);
+    renderer_draw(batch->vao, batch->vertex_count);
+    batch->vertex_count = 0;
+    batch->vertex_ptr = batch->vertices;
+
+    glUseProgram(0);
+
+    batch->stats.draw_calls++;
+}
+
+void batch_add_attrib(RenderBatch* batch, VertexAttrib attr) {
+    batch->layout.push_back(attr);
+}
+
+void batch_bind_attribs(RenderBatch* batch) {
+    size_t stride = 0;
+    for(int i = 0; i < batch->layout.size(); i++) {
+        VertexAttrib attr = batch->layout[i];
+
+        glEnableVertexArrayAttrib(batch->vao, i);
+        glVertexArrayAttribFormat(batch->vao, i, attr.count, attr.type, GL_FALSE, stride);
+        glVertexArrayAttribBinding(batch->vao, i, 0);
+
+        stride += attr.size * attr.count;
+    }
+
+    glVertexArrayVertexBuffer(batch->vao, 0, batch->vbo, 0, stride); 
+}
+
+bool batch_needs_flush(RenderBatch* batch, uint32_t vertex_add) {
+    return batch->vertex_size * (batch->vertex_count + vertex_add) >= batch->vertex_size * batch->max_vertices;
+}

src/camera.cpp

@@ -0,0 +1,28 @@
+#include <gearlib.h>
+#include <stdlib.h>
+
+Camera* create_camera(vec2 pos) {
+    Camera* camera = new Camera();
+    camera->position = vec3(pos.x, pos.y, -3.0f);
+    camera->m = new CameraMatrices();
+
+    return camera;
+}
+
+void update_camera(Camera* camera, Window window) {
+    int width, height;
+    glfwGetWindowSize(window, &width, &height);
+
+    assert(camera != NULL);
+
+    camera->m->view = mat4Transpose(mat4Translate(vec3_spread(camera->position)));
+    
+    switch(camera->projection) {
+    case CAMERA_ORTHOGRAPHIC:
+        camera->m->projection = mat4Transpose(mat4Ortho(0.0f, width, height, 0.0f, 0.0f, 1000.0f));
+        break;
+    case CAMERA_PERSPECTIVE:
+        camera->m->projection = mat4Transpose(mat4Perspective(45.0f * DEG2RAD, ((double)width / (double)height), 0.1f, 100.0f));
+        break;
+    }
+}

src/debugging.cpp

@@ -0,0 +1,50 @@
+#include <debugging.h>
+#include <opengl.h>
+#include <iostream>
+
+void message_callback(int32_t source, int32_t type, uint32_t id, int32_t severity, size_t length, char const* message, void const* user_param)
+{
+    auto const src_str = [source]() {
+        switch (source)
+        {
+        case GL_DEBUG_SOURCE_API: return "API";
+        case GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "WINDOW SYSTEM";
+        case GL_DEBUG_SOURCE_SHADER_COMPILER: return "SHADER COMPILER";
+        case GL_DEBUG_SOURCE_THIRD_PARTY: return "THIRD PARTY";
+        case GL_DEBUG_SOURCE_APPLICATION: return "APPLICATION";
+        case GL_DEBUG_SOURCE_OTHER: return "OTHER";
+        default: return "Unknown";
+        }
+    }();
+
+    auto const type_str = [type]() {
+        switch (type)
+        {
+        case GL_DEBUG_TYPE_ERROR: return "ERROR";
+        case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "DEPRECATED_BEHAVIOR";
+        case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "UNDEFINED_BEHAVIOR";
+        case GL_DEBUG_TYPE_PORTABILITY: return "PORTABILITY";
+        case GL_DEBUG_TYPE_PERFORMANCE: return "PERFORMANCE";
+        case GL_DEBUG_TYPE_MARKER: return "MARKER";
+        case GL_DEBUG_TYPE_OTHER: return "OTHER";
+        default: return "Unknown";
+        }
+    }();
+
+    auto const severity_str = [severity]() {
+        switch (severity) {
+        case GL_DEBUG_SEVERITY_NOTIFICATION: return "NOTIFICATION";
+        case GL_DEBUG_SEVERITY_LOW: return "LOW";
+        case GL_DEBUG_SEVERITY_MEDIUM: return "MEDIUM";
+        case GL_DEBUG_SEVERITY_HIGH: return "HIGH";
+        default: return "Unknown";
+        }
+    }();
+    std::cout << src_str << ", " << type_str << ", " << severity_str << ", " << id << ": " << message << '\n';
+}
+
+void enable_debugging() {
+    glEnable(GL_DEBUG_OUTPUT);
+    glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE);
+    glDebugMessageCallback((GLDEBUGPROC)message_callback, NULL);
+}

src/events.cpp

@@ -0,0 +1,11 @@
+#include <gearlib.h>
+
+void framebuffer_size_callback(Window window, int width, int height) {
+    glViewport(0, 0, width, height);
+}
+
+void process_input(Window window) {
+    if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+}
+

src/implementations.c

@@ -0,0 +1,7 @@
+#define STBI_NO_SIMD
+#define STBI_FAILURE_USERMSG
+#define STB_IMAGE_IMPLEMENTATION
+#include <stb_image.h>
+
+#define RAYMATH_IMPLEMENTATION
+#include <raymath.h>

src/init.cpp

@@ -0,0 +1,50 @@
+#include <gearlib.h>
+#include <opengl.h>
+
+bool gl_initialized = false;
+
+void init_gl(int major, int minor) {
+    if(!glfwInit()) {
+        printf("[GLFW] Failed to initialize\n");
+        exit(-1);
+    } else {
+        printf("[GLFW] Initialized successfully\n");
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, minor);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+    printf("[OPENGL] Using OpenGL %d.%d\n", major, minor);
+
+    gl_initialized = true;
+}
+
+Window create_window(int width, int height, const char* title) {
+    if(!gl_initialized) init_gl(4, 6);
+
+    Window window = glfwCreateWindow(width, height, title, NULL, NULL);
+    if(!window) {
+        printf("[GLFW] Failed to create window\n");
+        glfwTerminate();
+        exit(-1);
+    } else {
+        printf("[GLFW] Window created successfully\n");
+    }
+    glfwMakeContextCurrent(window);
+    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); 
+
+    if (!gladLoadGL((GLADloadfunc)glfwGetProcAddress)) {
+        printf("[GLAD] Failed to initialize\n");
+        exit(-1);
+    } else {
+        printf("[GLAD] Initialized successfully\n");
+    }
+
+    glViewport(0, 0, width, height);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  
+
+    return window;
+}

src/quad.cpp

@@ -0,0 +1,68 @@
+#include <gearlib.h>
+#include <assert.h>
+
+vec3 quad_vertex_positions[6] = {
+    { -0.5f, 0.5f, 0.0f },
+    { -0.5f, -0.5f, 0.0f },
+    { 0.5f, -0.5f, 0.0f },
+    
+    { -0.5f, 0.5f, 0.0f },
+    { 0.5f, -0.5f, 0.0f },
+    { 0.5f, 0.5f, 0.0f },
+};
+
+RenderBatch* quad_batch = NULL;
+
+void setup_quads() {
+    quad_batch = create_quad_batch();
+}
+
+void draw_quad(vec2 pos, vec2 size, vec4 color) { 
+    mat4 transform = mat4Multiply(
+            mat4Scale(size.x, size.y, 1.0f), 
+            mat4Translate(pos.x, pos.y, 0.0f));
+
+    draw_quad_trans(transform, color);
+}
+
+void draw_quad_trans(mat4 transform, vec4 color) {
+    assert(quad_batch != NULL && "quad_batch is null, was setup_quads() called?");
+
+    batch_draw_quad(quad_batch, transform, color);
+}
+
+void batch_draw_quad(RenderBatch* batch, mat4 transform, vec4 color) {
+    uint32_t vertex_add = 6; 
+
+    if(batch_needs_flush(batch, vertex_add))
+        flush_batch(batch);
+    
+    for(int i = 0; i < vertex_add; i++) {
+        QuadVertex* vertex = (QuadVertex*)batch->vertex_ptr;
+
+        vertex->Position = vec3Transform(quad_vertex_positions[i], transform);
+        vertex->Color = color;
+
+        batch->vertex_ptr = (QuadVertex*)batch->vertex_ptr + 1;
+        batch->vertex_count++;
+    }
+}
+
+RenderBatch* create_quad_batch() {
+    RenderBatch* quad_batch = create_batch(sizeof(QuadVertex), MAX_VERTICES);
+    quad_batch->shader = load_shader_program(
+            compile_shader("assets/quad.vert", GL_VERTEX_SHADER),
+            compile_shader("assets/quad.frag", GL_FRAGMENT_SHADER), 0);
+  
+    batch_add_attrib(quad_batch, (VertexAttrib){ 
+        .type = GL_FLOAT, .size = sizeof(float), .count = 3 
+    }); // pos 
+    
+    batch_add_attrib(quad_batch, (VertexAttrib){ 
+        .type = GL_FLOAT, .size = sizeof(float), .count = 4 
+    }); // color
+
+    batch_bind_attribs(quad_batch);
+    
+    return quad_batch;
+}

src/renderer.cpp

@@ -0,0 +1,8 @@
+#include <gearlib.h>
+#include <opengl.h>
+
+void renderer_draw(uint32_t vao, int count) {
+    glBindVertexArray(vao);
+    glDrawArrays(GL_TRIANGLES, 0, count);
+    glBindVertexArray(0);
+}

src/shaders.cpp

@@ -0,0 +1,76 @@
+#include <shaders.h>
+#include <opengl.h>
+#include <vector>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <fstream>
+
+uint32_t compile_shader(const char* path, int32_t type) {
+    std::ifstream file(path);
+    std::string source((std::istreambuf_iterator<char>(file)),
+                 std::istreambuf_iterator<char>());
+    const char* source_cstr = source.c_str();
+
+    uint32_t id = compile_shader_text(path, source_cstr, type);
+
+    return id;
+}
+
+uint32_t compile_shader_text(const char* name, const char* text, int32_t type) {
+    uint32_t id = glCreateShader(type);
+    glShaderSource(id, 1, &text, NULL);
+    glCompileShader(id);
+
+    int success;
+    char info_log[512];
+    glGetShaderiv(id, GL_COMPILE_STATUS, &success);
+    if(!success) {
+        glGetShaderInfoLog(id, 512, NULL, info_log);
+        printf("[Shader %d, %s] Failed to compile: %s\n", id, name, info_log);
+        exit(-1);
+    } else {
+        printf("[Shader %d, %s] Compiled successfully\n", id, name);
+    }
+
+    return id;
+}
+
+
+uint32_t load_shader_program(uint32_t shader, ...) {
+    std::vector<uint32_t> shaders;
+
+    va_list args;
+    va_start(args, shader);
+    while(shader != 0) {
+        shaders.push_back(shader);
+        shader = va_arg(args, uint32_t);
+    }
+    va_end(args);
+
+    uint32_t program = glCreateProgram();
+    for(const auto& shader : shaders) {
+        glAttachShader(program, shader);
+        printf("[Shader %d] Attached to program %d\n", shader, program);
+    }
+    glLinkProgram(program);
+
+    int success;
+    char info_log[512];
+    glGetProgramiv(program, GL_LINK_STATUS, &success);
+    if(!success) {
+        glGetProgramInfoLog(program, 512, NULL, info_log);
+        printf("[Program %d] Failed to link: %s\n", program, info_log);
+        exit(-1);
+    } else {
+        printf("[Program %d] Linked successfully\n", program);
+    }
+
+    for(const auto& shader : shaders) {
+        glDeleteShader(shader);
+        printf("[Shader %d] Deleted successfully\n", shader);
+    } 
+
+    return program;
+}

src/textures.cpp

@@ -0,0 +1,128 @@
+#include <textures.h>
+#include <stb_image.h>
+#include <opengl.h>
+#include <assert.h>
+
+RenderBatch* texture_quad_batch = NULL;
+int max_textures;
+
+void setup_textures() {
+    texture_quad_batch = create_texture_quad_batch();
+
+    glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_textures);
+    if(max_textures > 32) max_textures = 32;
+}
+
+uint32_t load_texture(const char* path) {
+    uint32_t id;
+    glCreateTextures(GL_TEXTURE_2D, 1, &id); 
+
+    uint8_t default_texture[] = { 
+	    0, 0, 0, 255, 	255, 0, 255, 255,
+	    255, 0, 255, 255,	0, 0, 0, 255 };
+
+    int width = 2, height = 2, channels;
+    uint8_t* pixels = stbi_load(path, &width, &height, &channels, 4);
+    if(pixels) {
+	glTextureParameteri(id, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    	glTextureParameteri(id, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    	glTextureParameteri(id, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    	glTextureParameteri(id, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        glTextureStorage2D(id, 1, GL_RGBA8, width, height);
+        glTextureSubImage2D(id, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+        printf("[Texture %d, %s] Loaded successfully (%dx%d, %d channels)\n", id, path, width, height, channels);
+    } else {
+	glTextureParameteri(id, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    	glTextureParameteri(id, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    	glTextureParameteri(id, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    	glTextureParameteri(id, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	glTextureStorage2D(id, 1, GL_RGBA8, width, height);
+	glTextureSubImage2D(id, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, default_texture);
+        printf("[Texture %d, %s] Failed to load image data: %s\n", id, path, stbi_failure_reason());
+    }
+
+    return id;
+}
+
+vec2 texture_quad_texcoords[] = {
+    { 0.0f, 1.0f },
+    { 0.0f, 0.0f },
+    { 1.0f, 0.0f },
+        
+    { 0.0f, 1.0f },
+    { 1.0f, 0.0f },
+    { 1.0f, 1.0f }
+};
+
+void draw_texture(Texture id, vec2 pos, vec2 size, vec4 tint) { 
+    mat4 transform = mat4Multiply(
+            mat4Scale(size.x, size.y, 1.0f),
+            mat4Translate(pos.x, pos.y, 0.0f));
+
+    draw_texture_trans(id, transform, tint);
+}
+
+void draw_texture_trans(Texture id, mat4 transform, vec4 tint) {
+    assert(texture_quad_batch != NULL && "texture_quad_batch is null, was setup_textures() called?");
+    batch_draw_texture(texture_quad_batch, id, transform, tint);
+}
+
+void batch_draw_texture(RenderBatch* batch, Texture texture, mat4 transform, vec4 color) {
+    TextureQuadBatchData* batch_data = (TextureQuadBatchData*)batch->data;
+    uint32_t vertex_add = 6; 
+
+    if(batch_needs_flush(batch, vertex_add) || batch_data->texture_index >= max_textures) 
+        flush_batch(batch); 
+ 
+    uint32_t tex_id = batch_data->texture_index++;
+    glBindTextureUnit(tex_id, texture);
+
+    for(int i = 0; i < vertex_add; i++) {
+        TextureQuadVertex* vertex = (TextureQuadVertex*)batch->vertex_ptr;
+
+        vertex->Position = vec3Transform(quad_vertex_positions[i], transform);
+        vertex->Tint = color;
+        vertex->TexCoord = texture_quad_texcoords[i];
+        vertex->TexID = tex_id;
+
+        batch->vertex_ptr = (TextureQuadVertex*)batch->vertex_ptr + 1;
+        batch->vertex_count++;
+    }
+}
+
+void texture_flush_callback(RenderBatch* batch) {
+    TextureQuadBatchData* data = (TextureQuadBatchData*)batch->data;
+    data->texture_index = 0;
+}
+
+RenderBatch* create_texture_quad_batch() {
+    RenderBatch* texture_quad_batch = create_batch(sizeof(TextureQuadVertex), MAX_VERTICES);
+    texture_quad_batch->shader = load_shader_program(
+            compile_shader("assets/texture.vert", GL_VERTEX_SHADER),
+            compile_shader("assets/texture.frag", GL_FRAGMENT_SHADER), 0);
+
+    texture_quad_batch->data = new TextureQuadBatchData();
+    texture_quad_batch->flush_callback = &texture_flush_callback;
+
+    batch_add_attrib(texture_quad_batch, (VertexAttrib){ 
+            .type = GL_FLOAT, .size = sizeof(float), .count = 3 
+    }); // pos
+    
+    batch_add_attrib(texture_quad_batch, (VertexAttrib){ 
+            .type = GL_FLOAT, .size = sizeof(float), .count = 4 
+    }); // color
+
+    batch_add_attrib(texture_quad_batch, (VertexAttrib){ 
+            .type = GL_FLOAT, .size = sizeof(float), .count = 2 
+    }); // texcoord
+
+    batch_add_attrib(texture_quad_batch, (VertexAttrib){ 
+            .type = GL_FLOAT, .size = sizeof(float), .count = 1 
+    }); // texid
+
+    batch_bind_attribs(texture_quad_batch);
+
+    return texture_quad_batch;
+}

src/uniform_buffer.cpp

@@ -0,0 +1,16 @@
+#include <gearlib.h>
+
+UniformBuffer* create_uniform_buffer(size_t size) {
+    UniformBuffer* buffer = (UniformBuffer*)calloc(sizeof(UniformBuffer), 1);
+    buffer->size = size;
+
+    glCreateBuffers(1, &buffer->ubo);
+    glNamedBufferStorage(buffer->ubo, buffer->size, NULL, GL_DYNAMIC_STORAGE_BIT);
+    glBindBufferBase(GL_UNIFORM_BUFFER, 0, buffer->ubo);
+
+    return buffer;
+}
+
+void set_uniform_data(UniformBuffer* buffer, void* data) {
+    glNamedBufferSubData(buffer->ubo, 0, buffer->size, data);
+}

vendor/glfw

@@ -0,0 +1 @@
+Subproject commit 026a148d7dd78d597de380c4e77ca0869f0ceaab