Move app init state mapping to renderer gl

docs/modernization/build-inventory.md

@@ -155,7 +155,9 @@ Known local toolchain state:
   by legacy `Shader` creation also live here. `Shader` no longer spells GL enum
   names directly. It also owns the PanoPainter shader uniform catalog and legacy hash
   mapping used by `Shader` active-uniform discovery and the uniform uniqueness
-  check.
+  check. App OpenGL initialization debug severity, debug output, GL info string,
+  default depth/program-point/line-smooth state, blend factor/equation, and UI
+  render-target RGBA8 format tokens are cataloged and tested here too.
 - `windows-msvc-vcpkg-headless` validates manifest install/configure/build/test
   for the current headless component matrix; see DEBT-0007 for remaining app
   and platform triplet migration.

docs/modernization/roadmap.md

@@ -419,7 +419,10 @@ count query, and matrix-uniform transpose token also live in `pp_renderer_gl`
 and are consumed by legacy `Shader` creation. Shader uniform hashing, catalog
 validation, active-uniform mapping, and the legacy uniform uniqueness check now
 delegate to `pp_renderer_gl` as well. `Shader` no longer spells GL enum names
-directly. The existing renderer classes are not yet fully
+directly. App OpenGL initialization debug severity, debug output, GL info
+string, default depth/program-point/line-smooth state, blend factor/equation,
+and UI render-target RGBA8 format tokens are now also cataloged and tested in
+`pp_renderer_gl`. The existing renderer classes are not yet fully
 behind the renderer interfaces.
 
 Implementation tasks:

src/app.cpp

@@ -5,6 +5,7 @@
 #include "node_dialog_open.h"
 #include "node_progress_bar.h"
 #include "mp4enc.h"
+#include "renderer_gl/opengl_capabilities.h"
 
 #ifdef __APPLE__
 #include <Foundation/Foundation.h>
@@ -38,6 +39,100 @@ App* App::I = nullptr; // singleton
 std::deque<AppTask> App::render_tasklist;
 std::mutex App::render_task_mutex;
 std::condition_variable App::render_cv;
+
+namespace {
+
+[[nodiscard]] GLenum debug_severity_notification() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::debug_severity_notification());
+}
+
+[[nodiscard]] GLenum debug_severity_low() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::debug_severity_low());
+}
+
+[[nodiscard]] GLenum debug_severity_medium() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::debug_severity_medium());
+}
+
+[[nodiscard]] GLenum debug_severity_high() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::debug_severity_high());
+}
+
+[[nodiscard]] GLenum debug_output_state() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::debug_output_state());
+}
+
+[[nodiscard]] GLenum debug_output_synchronous_state() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::debug_output_synchronous_state());
+}
+
+[[nodiscard]] GLenum version_string_name() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::version_string_name());
+}
+
+[[nodiscard]] GLenum vendor_string_name() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::vendor_string_name());
+}
+
+[[nodiscard]] GLenum renderer_string_name() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::renderer_string_name());
+}
+
+[[nodiscard]] GLenum shading_language_version_string_name() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::shading_language_version_string_name());
+}
+
+[[nodiscard]] GLenum depth_test_state() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::depth_test_state());
+}
+
+[[nodiscard]] GLenum program_point_size_state() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::program_point_size_state());
+}
+
+[[nodiscard]] GLenum line_smooth_state() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::line_smooth_state());
+}
+
+[[nodiscard]] GLenum source_alpha_blend_factor() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::source_alpha_blend_factor());
+}
+
+[[nodiscard]] GLenum one_minus_source_alpha_blend_factor() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::one_minus_source_alpha_blend_factor());
+}
+
+[[nodiscard]] GLenum add_blend_equation() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::add_blend_equation());
+}
+
+[[nodiscard]] GLenum max_blend_equation() noexcept
+{
+    return static_cast<GLenum>(pp::renderer::gl::max_blend_equation());
+}
+
+[[nodiscard]] GLint rgba8_internal_format() noexcept
+{
+    return static_cast<GLint>(pp::renderer::gl::rgba8_internal_format());
+}
+
+}
 std::thread App::render_thread;
 std::thread::id App::render_thread_id;
 bool App::render_running = false;
@@ -391,19 +486,21 @@ void handle_gl_callback(GLenum source, GLenum type, GLuint id,
     GLenum severity, GLsizei length, const GLchar* message, const void* userParam)
 {
     static std::map<GLenum, int> colors = {
-        { GL_DEBUG_SEVERITY_NOTIFICATION, 8 },
+        { debug_severity_notification(), 8 },
-        { GL_DEBUG_SEVERITY_LOW, 8 },
+        { debug_severity_low(), 8 },
-        { GL_DEBUG_SEVERITY_MEDIUM, FOREGROUND_GREEN | FOREGROUND_INTENSITY },
+        { debug_severity_medium(), FOREGROUND_GREEN | FOREGROUND_INTENSITY },
-        { GL_DEBUG_SEVERITY_HIGH, FOREGROUND_RED | FOREGROUND_INTENSITY },
+        { debug_severity_high(), FOREGROUND_RED | FOREGROUND_INTENSITY },
     };
-    if (severity == GL_DEBUG_SEVERITY_HIGH || severity == GL_DEBUG_SEVERITY_MEDIUM || severity == GL_DEBUG_SEVERITY_LOW)
+    if (severity == debug_severity_high()
+        || severity == debug_severity_medium()
+        || severity == debug_severity_low())
     {
         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors[severity]);
         LOG("OPENGL: %.*s", length, message);
         FlushConsoleInputBuffer(GetStdHandle(STD_OUTPUT_HANDLE));
         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), info.wAttributes);
 #ifdef _DEBUG
-        if (severity == GL_DEBUG_SEVERITY_HIGH)
+        if (severity == debug_severity_high())
             __debugbreak();
 #endif
     }
@@ -421,8 +518,8 @@ void App::init()
         render_task([]
         {
             glDebugMessageCallback(handle_gl_callback, nullptr);
-            glEnable(GL_DEBUG_OUTPUT);
+            glEnable(debug_output_state());
-            glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
+            glEnable(debug_output_synchronous_state());
         });
     }
 #endif
@@ -431,10 +528,10 @@ void App::init()
 
     render_task([]
     {
-        LOG("GL version: %s", glGetString(GL_VERSION));
+        LOG("GL version: %s", glGetString(version_string_name()));
-        LOG("GL vendor: %s", glGetString(GL_VENDOR));
+        LOG("GL vendor: %s", glGetString(vendor_string_name()));
-        LOG("GL renderer: %s", glGetString(GL_RENDERER));
+        LOG("GL renderer: %s", glGetString(renderer_string_name()));
-        LOG("GLSL version: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
+        LOG("GLSL version: %s", glGetString(shading_language_version_string_name()));
 
         //GLint n_exts;
         //glGetIntegerv(GL_NUM_EXTENSIONS, &n_exts);
@@ -447,13 +544,13 @@ void App::init()
         //    }
         //}
     
-        glDisable(GL_DEPTH_TEST);
+        glDisable(depth_test_state());
     #if defined(_WIN32) || defined(__OSX__)
-        glEnable(GL_PROGRAM_POINT_SIZE);
+        glEnable(program_point_size_state());
-        glEnable(GL_LINE_SMOOTH);
+        glEnable(line_smooth_state());
     #endif
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glBlendFunc(source_alpha_blend_factor(), one_minus_source_alpha_blend_factor());
-        glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX);
+        glBlendEquationSeparate(add_blend_equation(), max_blend_equation());
     });
 
     int run_counter = Settings::value<Serializer::Integer>("run_counter") + 1;
@@ -468,7 +565,7 @@ void App::init()
     initLayout();
     title_update();
 
-    uirtt.create(width, height, -1, GL_RGBA8, true);
+    uirtt.create(width, height, -1, rgba8_internal_format(), true);
 
     if (Settings::value_or<Serializer::Boolean>("auto-timelapse", true))
         rec_start();

src/renderer_gl/opengl_capabilities.cpp

@@ -20,6 +20,23 @@ constexpr std::uint32_t gl_vertex_shader = 0x8B31U;
 constexpr std::uint32_t gl_compile_status = 0x8B81U;
 constexpr std::uint32_t gl_link_status = 0x8B82U;
 constexpr std::uint32_t gl_active_uniforms = 0x8B86U;
+constexpr std::uint32_t gl_version = 0x1F02U;
+constexpr std::uint32_t gl_vendor = 0x1F00U;
+constexpr std::uint32_t gl_renderer = 0x1F01U;
+constexpr std::uint32_t gl_shading_language_version = 0x8B8CU;
+constexpr std::uint32_t gl_debug_output_synchronous = 0x8242U;
+constexpr std::uint32_t gl_debug_output = 0x92E0U;
+constexpr std::uint32_t gl_debug_severity_high = 0x9146U;
+constexpr std::uint32_t gl_debug_severity_medium = 0x9147U;
+constexpr std::uint32_t gl_debug_severity_low = 0x9148U;
+constexpr std::uint32_t gl_debug_severity_notification = 0x826BU;
+constexpr std::uint32_t gl_src_alpha = 0x0302U;
+constexpr std::uint32_t gl_one_minus_src_alpha = 0x0303U;
+constexpr std::uint32_t gl_line_smooth = 0x0B20U;
+constexpr std::uint32_t gl_depth_test = 0x0B71U;
+constexpr std::uint32_t gl_func_add = 0x8006U;
+constexpr std::uint32_t gl_max = 0x8008U;
+constexpr std::uint32_t gl_program_point_size = 0x8642U;
 constexpr std::uint32_t gl_array_buffer = 0x8892U;
 constexpr std::uint32_t gl_element_array_buffer = 0x8893U;
 constexpr std::uint32_t gl_static_draw = 0x88E4U;
@@ -393,6 +410,96 @@ std::uint32_t matrix_uniform_not_transposed() noexcept
     return gl_false;
 }
 
+std::uint32_t debug_severity_notification() noexcept
+{
+    return gl_debug_severity_notification;
+}
+
+std::uint32_t debug_severity_low() noexcept
+{
+    return gl_debug_severity_low;
+}
+
+std::uint32_t debug_severity_medium() noexcept
+{
+    return gl_debug_severity_medium;
+}
+
+std::uint32_t debug_severity_high() noexcept
+{
+    return gl_debug_severity_high;
+}
+
+std::uint32_t debug_output_state() noexcept
+{
+    return gl_debug_output;
+}
+
+std::uint32_t debug_output_synchronous_state() noexcept
+{
+    return gl_debug_output_synchronous;
+}
+
+std::uint32_t version_string_name() noexcept
+{
+    return gl_version;
+}
+
+std::uint32_t vendor_string_name() noexcept
+{
+    return gl_vendor;
+}
+
+std::uint32_t renderer_string_name() noexcept
+{
+    return gl_renderer;
+}
+
+std::uint32_t shading_language_version_string_name() noexcept
+{
+    return gl_shading_language_version;
+}
+
+std::uint32_t depth_test_state() noexcept
+{
+    return gl_depth_test;
+}
+
+std::uint32_t program_point_size_state() noexcept
+{
+    return gl_program_point_size;
+}
+
+std::uint32_t line_smooth_state() noexcept
+{
+    return gl_line_smooth;
+}
+
+std::uint32_t source_alpha_blend_factor() noexcept
+{
+    return gl_src_alpha;
+}
+
+std::uint32_t one_minus_source_alpha_blend_factor() noexcept
+{
+    return gl_one_minus_src_alpha;
+}
+
+std::uint32_t add_blend_equation() noexcept
+{
+    return gl_func_add;
+}
+
+std::uint32_t max_blend_equation() noexcept
+{
+    return gl_max;
+}
+
+std::uint32_t rgba8_internal_format() noexcept
+{
+    return gl_rgba8;
+}
+
 std::uint32_t texture_cube_map_target() noexcept
 {
     return gl_texture_cube_map;

src/renderer_gl/opengl_capabilities.h

@@ -86,6 +86,24 @@ struct OpenGlReadbackFormat {
 [[nodiscard]] std::uint32_t program_link_status_query() noexcept;
 [[nodiscard]] std::uint32_t active_uniform_count_query() noexcept;
 [[nodiscard]] std::uint32_t matrix_uniform_not_transposed() noexcept;
+[[nodiscard]] std::uint32_t debug_severity_notification() noexcept;
+[[nodiscard]] std::uint32_t debug_severity_low() noexcept;
+[[nodiscard]] std::uint32_t debug_severity_medium() noexcept;
+[[nodiscard]] std::uint32_t debug_severity_high() noexcept;
+[[nodiscard]] std::uint32_t debug_output_state() noexcept;
+[[nodiscard]] std::uint32_t debug_output_synchronous_state() noexcept;
+[[nodiscard]] std::uint32_t version_string_name() noexcept;
+[[nodiscard]] std::uint32_t vendor_string_name() noexcept;
+[[nodiscard]] std::uint32_t renderer_string_name() noexcept;
+[[nodiscard]] std::uint32_t shading_language_version_string_name() noexcept;
+[[nodiscard]] std::uint32_t depth_test_state() noexcept;
+[[nodiscard]] std::uint32_t program_point_size_state() noexcept;
+[[nodiscard]] std::uint32_t line_smooth_state() noexcept;
+[[nodiscard]] std::uint32_t source_alpha_blend_factor() noexcept;
+[[nodiscard]] std::uint32_t one_minus_source_alpha_blend_factor() noexcept;
+[[nodiscard]] std::uint32_t add_blend_equation() noexcept;
+[[nodiscard]] std::uint32_t max_blend_equation() noexcept;
+[[nodiscard]] std::uint32_t rgba8_internal_format() noexcept;
 [[nodiscard]] std::uint32_t texture_cube_map_target() noexcept;
 [[nodiscard]] std::uint32_t cube_map_allocation_face_texture_target(std::uint32_t face_index) noexcept;
 [[nodiscard]] std::span<const std::uint32_t> panopainter_cube_face_texture_targets() noexcept;

tests/renderer_gl/capabilities_tests.cpp

@@ -306,6 +306,30 @@ void exposes_shader_attribute_binding_catalog(pp::tests::Harness& h)
     PP_EXPECT(h, bindings[4].location == 3U);
 }
 
+void maps_app_initialization_parameters(pp::tests::Harness& h)
+{
+    PP_EXPECT(h, pp::renderer::gl::debug_severity_notification() == 0x826BU);
+    PP_EXPECT(h, pp::renderer::gl::debug_severity_low() == 0x9148U);
+    PP_EXPECT(h, pp::renderer::gl::debug_severity_medium() == 0x9147U);
+    PP_EXPECT(h, pp::renderer::gl::debug_severity_high() == 0x9146U);
+    PP_EXPECT(h, pp::renderer::gl::debug_output_state() == 0x92E0U);
+    PP_EXPECT(h, pp::renderer::gl::debug_output_synchronous_state() == 0x8242U);
+
+    PP_EXPECT(h, pp::renderer::gl::version_string_name() == 0x1F02U);
+    PP_EXPECT(h, pp::renderer::gl::vendor_string_name() == 0x1F00U);
+    PP_EXPECT(h, pp::renderer::gl::renderer_string_name() == 0x1F01U);
+    PP_EXPECT(h, pp::renderer::gl::shading_language_version_string_name() == 0x8B8CU);
+
+    PP_EXPECT(h, pp::renderer::gl::depth_test_state() == 0x0B71U);
+    PP_EXPECT(h, pp::renderer::gl::program_point_size_state() == 0x8642U);
+    PP_EXPECT(h, pp::renderer::gl::line_smooth_state() == 0x0B20U);
+    PP_EXPECT(h, pp::renderer::gl::source_alpha_blend_factor() == 0x0302U);
+    PP_EXPECT(h, pp::renderer::gl::one_minus_source_alpha_blend_factor() == 0x0303U);
+    PP_EXPECT(h, pp::renderer::gl::add_blend_equation() == 0x8006U);
+    PP_EXPECT(h, pp::renderer::gl::max_blend_equation() == 0x8008U);
+    PP_EXPECT(h, pp::renderer::gl::rgba8_internal_format() == 0x8058U);
+}
+
 void rejects_invalid_shader_attribute_binding_catalogs(pp::tests::Harness& h)
 {
     const std::array<pp::renderer::gl::OpenGlAttributeBinding, 0> empty {};
@@ -398,6 +422,7 @@ int main()
     harness.run("exposes_default_render_target_texture_parameters", exposes_default_render_target_texture_parameters);
     harness.run("maps_sampler_parameters", maps_sampler_parameters);
     harness.run("exposes_shader_attribute_binding_catalog", exposes_shader_attribute_binding_catalog);
+    harness.run("maps_app_initialization_parameters", maps_app_initialization_parameters);
     harness.run("rejects_invalid_shader_attribute_binding_catalogs", rejects_invalid_shader_attribute_binding_catalogs);
     harness.run("exposes_shader_uniform_catalog", exposes_shader_uniform_catalog);
     harness.run("rejects_invalid_shader_uniform_catalogs", rejects_invalid_shader_uniform_catalogs);