Route paint UI clear state through GL backend

src/node_canvas.cpp

@@ -1,6 +1,7 @@
 #include "pch.h"
 
 #include <algorithm>
+#include <array>
 #include <cstdint>
 #include <memory>
 #include <vector>
@@ -67,6 +68,31 @@ void set_opengl_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std
     glViewport(static_cast<GLint>(x), static_cast<GLint>(y), static_cast<GLsizei>(width), static_cast<GLsizei>(height));
 }
 
+void set_opengl_clear_color(float r, float g, float b, float a) noexcept
+{
+    glClearColor(r, g, b, a);
+}
+
+void clear_opengl_buffer(std::uint32_t mask) noexcept
+{
+    glClear(static_cast<GLbitfield>(mask));
+}
+
+void get_opengl_integer(std::uint32_t name, std::int32_t* values) noexcept
+{
+    GLint raw_values[4] {};
+    glGetIntegerv(static_cast<GLenum>(name), raw_values);
+    values[0] = static_cast<std::int32_t>(raw_values[0]);
+    values[1] = static_cast<std::int32_t>(raw_values[1]);
+    values[2] = static_cast<std::int32_t>(raw_values[2]);
+    values[3] = static_cast<std::int32_t>(raw_values[3]);
+}
+
+void get_opengl_float(std::uint32_t name, float* values) noexcept
+{
+    glGetFloatv(static_cast<GLenum>(name), values);
+}
+
 void apply_node_canvas_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
 {
     const auto status = pp::renderer::gl::apply_opengl_viewport(
@@ -83,6 +109,56 @@ void apply_node_canvas_viewport(std::int32_t x, std::int32_t y, std::int32_t wid
         LOG("NodeCanvas viewport dispatch failed because: %s", status.message);
 }
 
+pp::renderer::gl::OpenGlViewportRect query_node_canvas_viewport()
+{
+    const auto result = pp::renderer::gl::query_opengl_viewport(
+        pp::renderer::gl::OpenGlViewportQueryDispatch {
+            .get_integer = get_opengl_integer,
+        });
+    if (!result.ok()) {
+        LOG("NodeCanvas viewport query dispatch failed because: %s", result.status().message);
+    }
+    return result.value();
+}
+
+std::array<float, 4> query_node_canvas_clear_color()
+{
+    const auto result = pp::renderer::gl::query_opengl_clear_color(
+        pp::renderer::gl::OpenGlClearColorQueryDispatch {
+            .get_float = get_opengl_float,
+        });
+    if (!result.ok()) {
+        LOG("NodeCanvas clear-color query dispatch failed because: %s", result.status().message);
+    }
+    return result.value();
+}
+
+void apply_node_canvas_clear_color(std::array<float, 4> color)
+{
+    const auto status = pp::renderer::gl::apply_opengl_clear_color(
+        color,
+        pp::renderer::gl::OpenGlClearColorDispatch {
+            .clear_color = set_opengl_clear_color,
+        });
+    if (!status.ok())
+        LOG("NodeCanvas clear-color dispatch failed because: %s", status.message);
+}
+
+void clear_node_canvas_color_buffer(std::array<float, 4> color)
+{
+    const auto status = pp::renderer::gl::clear_opengl_render_target(
+        pp::renderer::gl::OpenGlDefaultClear {
+            .color = color,
+            .mask = pp::renderer::gl::framebuffer_color_buffer_mask(),
+        },
+        pp::renderer::gl::OpenGlClearDispatch {
+            .clear_color = set_opengl_clear_color,
+            .clear = clear_opengl_buffer,
+        });
+    if (!status.ok())
+        LOG("NodeCanvas color-buffer clear dispatch failed because: %s", status.message);
+}
+
 void apply_node_canvas_capability(std::uint32_t state, bool enabled)
 {
     const auto status = pp::renderer::gl::apply_opengl_capability(
@@ -281,17 +357,15 @@ void NodeCanvas::draw()
     if (box.z == 0 || box.w == 0)
         return;
 
-    GLint vp[4];
-    GLfloat cc[4];
-    glGetIntegerv(pp::renderer::gl::viewport_query(), vp);
-    glGetFloatv(pp::renderer::gl::color_clear_value_query(), cc);
+    const auto vp = query_node_canvas_viewport();
+    const auto cc = query_node_canvas_clear_color();
     auto blend = glIsEnabled(pp::renderer::gl::blend_state());
     auto depth = glIsEnabled(pp::renderer::gl::depth_test_state());
     auto scissor = glIsEnabled(pp::renderer::gl::scissor_test_state());
 
     apply_node_canvas_capability(pp::renderer::gl::scissor_test_state(), false);
 
-    glm::ivec4 c = (glm::ivec4)glm::vec4(box.x, (int)(vp[3] - box.y - box.w), box.z, box.w);
+    glm::ivec4 c = (glm::ivec4)glm::vec4(box.x, (int)(vp.height - box.y - box.w), box.z, box.w);
 
     //m_canvas->m_cam_rot = m_pan * 0.003f;
 
@@ -328,14 +402,12 @@ void NodeCanvas::draw()
     if (m_density != 1.f)
     {
         m_rtt.bindFramebuffer();
-        glClearColor(1, 1, 0, 0);
-        glClear(pp::renderer::gl::framebuffer_color_buffer_mask());
+        clear_node_canvas_color_buffer({ 1.f, 1.f, 0.f, 0.f });
         apply_node_canvas_viewport(0, 0, m_rtt.getWidth(), m_rtt.getHeight());
     }
     else
     {
-        glClearColor(1, 1, 1, 0);
-        glClear(pp::renderer::gl::framebuffer_color_buffer_mask());
+        clear_node_canvas_color_buffer({ 1.f, 1.f, 1.f, 0.f });
         apply_node_canvas_viewport(c.x + App::I->off_x, c.y + App::I->off_y, c.z, c.w);
     }
 
@@ -718,8 +790,7 @@ void NodeCanvas::draw()
     {
         m_rtt.unbindFramebuffer();
 
-        glClearColor(1, 1, 1, 0);
-        glClear(pp::renderer::gl::framebuffer_color_buffer_mask());
+        clear_node_canvas_color_buffer({ 1.f, 1.f, 1.f, 0.f });
         apply_node_canvas_viewport(c.x + App::I->off_x, c.y + App::I->off_y, c.z, c.w);
 
         // draw the canvas
@@ -736,8 +807,8 @@ void NodeCanvas::draw()
     scissor ? apply_node_canvas_capability(pp::renderer::gl::scissor_test_state(), true) : apply_node_canvas_capability(pp::renderer::gl::scissor_test_state(), false);
     blend ? apply_node_canvas_capability(pp::renderer::gl::blend_state(), true) : apply_node_canvas_capability(pp::renderer::gl::blend_state(), false);
     depth ? apply_node_canvas_capability(pp::renderer::gl::depth_test_state(), true) : apply_node_canvas_capability(pp::renderer::gl::depth_test_state(), false);
-    apply_node_canvas_viewport(vp[0], vp[1], vp[2], vp[3]);
-    glClearColor(cc[0], cc[1], cc[2], cc[3]);
+    apply_node_canvas_viewport(vp.x, vp.y, vp.width, vp.height);
+    apply_node_canvas_clear_color(cc);
 }
 
 void NodeCanvas::handle_resize(glm::vec2 old_size, glm::vec2 new_size, float zoom)

src/node_stroke_preview.cpp

@@ -10,6 +10,7 @@
 #include "renderer_gl/opengl_capabilities.h"
 #include "util.h"
 #include <algorithm>
+#include <array>
 #include <cstdint>
 
 namespace {
@@ -92,6 +93,26 @@ void set_opengl_scissor(std::int32_t x, std::int32_t y, std::int32_t width, std:
     glScissor(static_cast<GLint>(x), static_cast<GLint>(y), static_cast<GLsizei>(width), static_cast<GLsizei>(height));
 }
 
+void set_opengl_clear_color(float r, float g, float b, float a) noexcept
+{
+    glClearColor(r, g, b, a);
+}
+
+void get_opengl_integer(std::uint32_t name, std::int32_t* values) noexcept
+{
+    GLint raw_values[4] {};
+    glGetIntegerv(static_cast<GLenum>(name), raw_values);
+    values[0] = static_cast<std::int32_t>(raw_values[0]);
+    values[1] = static_cast<std::int32_t>(raw_values[1]);
+    values[2] = static_cast<std::int32_t>(raw_values[2]);
+    values[3] = static_cast<std::int32_t>(raw_values[3]);
+}
+
+void get_opengl_float(std::uint32_t name, float* values) noexcept
+{
+    glGetFloatv(static_cast<GLenum>(name), values);
+}
+
 void apply_stroke_preview_viewport(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
 {
     const auto status = pp::renderer::gl::apply_opengl_viewport(
@@ -108,6 +129,41 @@ void apply_stroke_preview_viewport(std::int32_t x, std::int32_t y, std::int32_t
         LOG("NodeStrokePreview viewport dispatch failed because: %s", status.message);
 }
 
+pp::renderer::gl::OpenGlViewportRect query_stroke_preview_viewport()
+{
+    const auto result = pp::renderer::gl::query_opengl_viewport(
+        pp::renderer::gl::OpenGlViewportQueryDispatch {
+            .get_integer = get_opengl_integer,
+        });
+    if (!result.ok()) {
+        LOG("NodeStrokePreview viewport query dispatch failed because: %s", result.status().message);
+    }
+    return result.value();
+}
+
+std::array<float, 4> query_stroke_preview_clear_color()
+{
+    const auto result = pp::renderer::gl::query_opengl_clear_color(
+        pp::renderer::gl::OpenGlClearColorQueryDispatch {
+            .get_float = get_opengl_float,
+        });
+    if (!result.ok()) {
+        LOG("NodeStrokePreview clear-color query dispatch failed because: %s", result.status().message);
+    }
+    return result.value();
+}
+
+void apply_stroke_preview_clear_color(std::array<float, 4> color)
+{
+    const auto status = pp::renderer::gl::apply_opengl_clear_color(
+        color,
+        pp::renderer::gl::OpenGlClearColorDispatch {
+            .clear_color = set_opengl_clear_color,
+        });
+    if (!status.ok())
+        LOG("NodeStrokePreview clear-color dispatch failed because: %s", status.message);
+}
+
 void apply_stroke_preview_scissor(std::int32_t x, std::int32_t y, std::int32_t width, std::int32_t height)
 {
     const auto status = pp::renderer::gl::apply_opengl_scissor_rect(
@@ -398,10 +454,8 @@ void NodeStrokePreview::draw_stroke_immediate()
     if (m_size.x == 0 || m_size.y == 0)
         return;
 
-    GLint vp[4];
-    GLfloat cc[4];
-    glGetIntegerv(pp::renderer::gl::viewport_query(), vp);
-    glGetFloatv(pp::renderer::gl::color_clear_value_query(), cc);
+    const auto vp = query_stroke_preview_viewport();
+    const auto cc = query_stroke_preview_clear_color();
     
     float zoom = root()->m_zoom;
 
@@ -668,8 +722,8 @@ void NodeStrokePreview::draw_stroke_immediate()
 
     m_rtt.unbindFramebuffer();
 
-    apply_stroke_preview_viewport(vp[0], vp[1], vp[2], vp[3]);
-    glClearColor(cc[0], cc[1], cc[2], cc[3]);
+    apply_stroke_preview_viewport(vp.x, vp.y, vp.width, vp.height);
+    apply_stroke_preview_clear_color(cc);
 }
 
 Image NodeStrokePreview::render_to_image()

src/renderer_gl/opengl_capabilities.cpp

@@ -481,6 +481,18 @@ pp::foundation::Status clear_opengl_render_target(
     return pp::foundation::Status::success();
 }
 
+pp::foundation::Status apply_opengl_clear_color(
+    std::array<float, 4> color,
+    OpenGlClearColorDispatch dispatch) noexcept
+{
+    if (dispatch.clear_color == nullptr) {
+        return pp::foundation::Status::invalid_argument("OpenGL clear-color dispatch callback must not be null");
+    }
+
+    dispatch.clear_color(color[0], color[1], color[2], color[3]);
+    return pp::foundation::Status::success();
+}
+
 pp::foundation::Status clear_opengl_color_buffer_with_write_mask(
     OpenGlColorMaskedClear clear,
     OpenGlColorMaskedClearDispatch dispatch) noexcept
@@ -539,6 +551,37 @@ pp::foundation::Status apply_opengl_viewport(
     return pp::foundation::Status::success();
 }
 
+pp::foundation::Result<OpenGlViewportRect> query_opengl_viewport(
+    OpenGlViewportQueryDispatch dispatch) noexcept
+{
+    if (dispatch.get_integer == nullptr) {
+        return pp::foundation::Result<OpenGlViewportRect>::failure(
+            pp::foundation::Status::invalid_argument("OpenGL viewport query dispatch callback must not be null"));
+    }
+
+    std::array<std::int32_t, 4> viewport {};
+    dispatch.get_integer(viewport_query(), viewport.data());
+    return pp::foundation::Result<OpenGlViewportRect>::success(OpenGlViewportRect {
+        .x = viewport[0],
+        .y = viewport[1],
+        .width = viewport[2],
+        .height = viewport[3],
+    });
+}
+
+pp::foundation::Result<std::array<float, 4>> query_opengl_clear_color(
+    OpenGlClearColorQueryDispatch dispatch) noexcept
+{
+    if (dispatch.get_float == nullptr) {
+        return pp::foundation::Result<std::array<float, 4>>::failure(
+            pp::foundation::Status::invalid_argument("OpenGL clear-color query dispatch callback must not be null"));
+    }
+
+    std::array<float, 4> color {};
+    dispatch.get_float(color_clear_value_query(), color.data());
+    return pp::foundation::Result<std::array<float, 4>>::success(color);
+}
+
 pp::foundation::Status apply_opengl_scissor_rect(
     OpenGlScissorRect scissor,
     OpenGlScissorDispatch dispatch) noexcept

src/renderer_gl/opengl_capabilities.h

@@ -564,10 +564,22 @@ struct OpenGlClearDispatch {
     OpenGlClearFn clear = nullptr;
 };
 
+struct OpenGlClearColorDispatch {
+    OpenGlClearColorFn clear_color = nullptr;
+};
+
 struct OpenGlActiveTextureDispatch {
     OpenGlActiveTextureFn active_texture = nullptr;
 };
 
+struct OpenGlViewportQueryDispatch {
+    OpenGlGetIntegerFn get_integer = nullptr;
+};
+
+struct OpenGlClearColorQueryDispatch {
+    OpenGlGetFloatFn get_float = nullptr;
+};
+
 struct OpenGlColorMaskedClearDispatch {
     OpenGlGetBooleanFn get_boolean = nullptr;
     OpenGlColorMaskFn color_mask = nullptr;
@@ -884,6 +896,9 @@ struct OpenGlMeshDeleteDispatch {
 [[nodiscard]] pp::foundation::Status clear_opengl_render_target(
     OpenGlDefaultClear clear,
     OpenGlClearDispatch dispatch) noexcept;
+[[nodiscard]] pp::foundation::Status apply_opengl_clear_color(
+    std::array<float, 4> color,
+    OpenGlClearColorDispatch dispatch) noexcept;
 [[nodiscard]] pp::foundation::Status clear_opengl_color_buffer_with_write_mask(
     OpenGlColorMaskedClear clear,
     OpenGlColorMaskedClearDispatch dispatch) noexcept;
@@ -896,6 +911,10 @@ struct OpenGlMeshDeleteDispatch {
 [[nodiscard]] pp::foundation::Status apply_opengl_viewport(
     OpenGlViewportRect viewport,
     OpenGlViewportDispatch dispatch) noexcept;
+[[nodiscard]] pp::foundation::Result<OpenGlViewportRect> query_opengl_viewport(
+    OpenGlViewportQueryDispatch dispatch) noexcept;
+[[nodiscard]] pp::foundation::Result<std::array<float, 4>> query_opengl_clear_color(
+    OpenGlClearColorQueryDispatch dispatch) noexcept;
 [[nodiscard]] pp::foundation::Status apply_opengl_scissor_rect(
     OpenGlScissorRect scissor,
     OpenGlScissorDispatch dispatch) noexcept;