Started creating GL helper lib pagl.h

src/libpapaya/pagl.h

@@ -0,0 +1,157 @@
+
+/*
+    Single-header OpenGL helper functions
+*/
+
+#ifndef PAGL_H
+#define PAGL_H
+
+void pagl_init(void);
+void pagl_destroy(void);
+void pagl_push_state(void);
+
+void pagl_pop_state(void);
+void pagl_enable(i32 count, ...);
+void pagl_disable(i32 count, ...);
+
+#endif // PAGL_H
+
+
+// =============================================================================
+
+
+#ifdef PAGL_IMPLEMENTATION
+
+#include <stdlib.h>
+#include <string.h>
+
+struct pagl_state {
+    u32 caps_edited;
+    u32 caps_state;
+};
+
+static pagl_state* state_stack;
+static i32 stack_idx;
+static i32 stack_size;
+
+void pagl_init()
+{
+    if (state_stack) { return; }
+    // The stack is implemented as a static array. Can be converted to a dynamic
+    // array later if required.
+    stack_idx = -1;
+    stack_size = 16;
+    state_stack = (pagl_state*) calloc(1, sizeof(pagl_state) * stack_size);
+}
+
+void pagl_destroy()
+{
+    free(state_stack);
+}
+
+void pagl_push_state()
+{
+    stack_idx++;
+    assert(stack_idx < stack_size);
+}
+
+/*
+    Converts an OpenGL capability enum (e.g. GL_SCISSOR_TEST) into its
+    corresponding mask to be stored in the internal state stack in this file.
+*/
+static u32 cap_to_mask(u32 gl_cap)
+{
+    switch (gl_cap) {
+        case GL_BLEND:        return 1 << 0;
+        case GL_SCISSOR_TEST: return 1 << 1;
+        case GL_DEPTH_TEST:   return 1 << 2;
+        case GL_CULL_FACE:    return 1 << 3;
+        default:              return 0;
+    }
+}
+
+static void revert_cap(u32 gl_cap)
+{
+    u32 m = cap_to_mask(gl_cap);
+    pagl_state* s = &state_stack[stack_idx];
+    if (s->caps_edited & m) {
+        u8 was_on = s->caps_state & m;
+        if (was_on) {
+            GLCHK( glEnable(gl_cap) );
+        } else {
+            GLCHK( glDisable(gl_cap) );
+        }
+    }
+}
+
+void pagl_pop_state()
+{
+    assert(stack_idx >= 0);
+    revert_cap(GL_BLEND);
+    revert_cap(GL_SCISSOR_TEST);
+    revert_cap(GL_DEPTH_TEST);
+    revert_cap(GL_CULL_FACE);
+
+    pagl_state* s = &state_stack[stack_idx];
+    memset(s, 0, sizeof(pagl_state)); // Zero out the stack frame
+    stack_idx--;
+}
+
+void pagl_enable(i32 count, ...)
+{
+    va_list args;
+    va_start(args, count);
+
+    for (i32 i = 0; i < count; i++) {
+        u32 gl_cap = va_arg(args, u32);
+
+        u8 on;
+        GLCHK( glGetBooleanv(gl_cap, &on) );
+        if (on) {
+            return;
+        }
+
+        pagl_state* s = &state_stack[stack_idx];
+        u32 m = cap_to_mask(gl_cap);
+
+        // Caps should not be modified twice in a single stack frame.
+        assert((s->caps_edited & m) == 0);
+        s->caps_edited |= m;
+        // No need to set bit in caps_state because it will already be zero.
+
+        GLCHK( glEnable(gl_cap) );
+    }
+
+    va_end(args);
+}
+
+void pagl_disable(i32 count, ...)
+{
+
+    va_list args;
+    va_start(args, count);
+
+    for (i32 i = 0; i < count; i++) {
+        u32 gl_cap = va_arg(args, u32);
+
+        u8 on;
+        GLCHK( glGetBooleanv(gl_cap, &on) );
+        if (!on) {
+            return;
+        }
+
+        pagl_state* s = &state_stack[stack_idx];
+        u32 m = cap_to_mask(gl_cap);
+
+        // Caps should not be modified twice in a single stack frame.
+        assert((s->caps_edited & m) == 0);
+        s->caps_edited |= m;
+        s->caps_state |= m;
+
+        GLCHK( glDisable(gl_cap) );
+    }
+
+    va_end(args);
+}
+
+#endif // PAGL_IMPLEMENTATION

src/ui/common_ui.cpp

@@ -10,6 +10,7 @@
 #include "libs/mathlib.h"
 #include "libs/linmath.h"
 #include "libpapaya.h"
+#include "pagl.h"
 #include <inttypes.h>
 
 
@@ -154,6 +155,7 @@ void core::init(PapayaMemory* mem)
 {
     // Init values and load textures
     {
+        pagl_init();
         mem->misc.preview_height = mem->misc.preview_width = 512;
 
         mem->current_tool = PapayaTool_Brush;
@@ -399,11 +401,11 @@ void core::init(PapayaMemory* mem)
 
 void core::destroy(PapayaMemory* mem)
 {
-    //TODO: Free stuff
+    pagl_destroy();
 }
 
 void core::resize(PapayaMemory* mem, i32 width, i32 height)
-{/*
+{
     mem->window.width = width;
     mem->window.height = height;
     ImGui::GetIO().DisplaySize = ImVec2((f32)width, (f32)height);
@@ -430,7 +432,7 @@ void core::resize(PapayaMemory* mem, i32 width, i32 height)
        (available_height - (f32)mem->cur_doc->height * mem->cur_doc->canvas_zoom)
        / 2.0f;
     mem->cur_doc->canvas_pos = Vec2i(x, y);
-*/}
+}
 
 void core::update(PapayaMemory* mem)
 {
@@ -1372,6 +1374,7 @@ void core::render_imgui(ImDrawData* draw_data, void* mem_ptr)
 {
     PapayaMemory* mem = (PapayaMemory*)mem_ptr;
 
+    pagl_push_state();
     // Backup GL state
     GLint last_program, last_texture, last_array_buffer, last_element_array_buffer;
     GLCHK( glGetIntegerv(GL_CURRENT_PROGRAM, &last_program) );
@@ -1380,12 +1383,11 @@ void core::render_imgui(ImDrawData* draw_data, void* mem_ptr)
     GLCHK( glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer) );
 
     // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
-    GLCHK( glEnable       (GL_BLEND) );
+    pagl_enable(2, GL_BLEND, GL_SCISSOR_TEST);
+    pagl_disable(2, GL_CULL_FACE, GL_DEPTH_TEST);
+
     GLCHK( glBlendEquation(GL_FUNC_ADD) );
     GLCHK( glBlendFunc    (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) );
-    GLCHK( glDisable      (GL_CULL_FACE) );
-    GLCHK( glDisable      (GL_DEPTH_TEST) );
-    GLCHK( glEnable       (GL_SCISSOR_TEST) );
     GLCHK( glActiveTexture(GL_TEXTURE0) );
 
     // Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
@@ -1431,7 +1433,7 @@ void core::render_imgui(ImDrawData* draw_data, void* mem_ptr)
     GLCHK( glBindTexture    (GL_TEXTURE_2D, last_texture) );
     GLCHK( glBindBuffer     (GL_ARRAY_BUFFER, last_array_buffer) );
     GLCHK( glBindBuffer     (GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer) );
-    GLCHK( glDisable        (GL_SCISSOR_TEST) );
+    pagl_pop_state();
 }
 
 void core::update_canvas(PapayaMemory* mem)

src/ui/libs/gl_util.h

@@ -5,6 +5,7 @@
 #include "gl_lite.h"
 #include "types.h"
 
+// TODO: Turn this off in release mode
 #define GLCHK(stmt) stmt; gl::check_error(#stmt, __FILE__, __LINE__)
 
 enum UniformType_ {

src/ui/libs/single_header_libs.cpp

@@ -28,6 +28,9 @@
 #define GL_LITE_IMPLEMENTATION
 #include "gl_lite.h"
 
+#define PAGL_IMPLEMENTATION
+#include "pagl.h"
+
 
 #define MATHLIB_IMPLEMENTATION
 #include "mathlib.h"