From 19f815e3d2a0181a62ca12246079e45712db2c03 Mon Sep 17 00:00:00 2001 From: omigamedev Date: Tue, 2 Jun 2026 06:54:43 +0200 Subject: [PATCH] Move app init state mapping to renderer gl --- docs/modernization/build-inventory.md | 4 +- docs/modernization/roadmap.md | 5 +- src/app.cpp | 133 ++++++++++++++++++++--- src/renderer_gl/opengl_capabilities.cpp | 107 ++++++++++++++++++ src/renderer_gl/opengl_capabilities.h | 18 +++ tests/renderer_gl/capabilities_tests.cpp | 25 +++++ 6 files changed, 272 insertions(+), 20 deletions(-) diff --git a/docs/modernization/build-inventory.md b/docs/modernization/build-inventory.md index 30f00be..47f4f4b 100644 --- a/docs/modernization/build-inventory.md +++ b/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. diff --git a/docs/modernization/roadmap.md b/docs/modernization/roadmap.md index a9d941a..a93e433 100644 --- a/docs/modernization/roadmap.md +++ b/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: diff --git a/src/app.cpp b/src/app.cpp index a54db64..7fff488 100644 --- a/src/app.cpp +++ b/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 @@ -38,6 +39,100 @@ App* App::I = nullptr; // singleton std::deque 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(pp::renderer::gl::debug_severity_notification()); +} + +[[nodiscard]] GLenum debug_severity_low() noexcept +{ + return static_cast(pp::renderer::gl::debug_severity_low()); +} + +[[nodiscard]] GLenum debug_severity_medium() noexcept +{ + return static_cast(pp::renderer::gl::debug_severity_medium()); +} + +[[nodiscard]] GLenum debug_severity_high() noexcept +{ + return static_cast(pp::renderer::gl::debug_severity_high()); +} + +[[nodiscard]] GLenum debug_output_state() noexcept +{ + return static_cast(pp::renderer::gl::debug_output_state()); +} + +[[nodiscard]] GLenum debug_output_synchronous_state() noexcept +{ + return static_cast(pp::renderer::gl::debug_output_synchronous_state()); +} + +[[nodiscard]] GLenum version_string_name() noexcept +{ + return static_cast(pp::renderer::gl::version_string_name()); +} + +[[nodiscard]] GLenum vendor_string_name() noexcept +{ + return static_cast(pp::renderer::gl::vendor_string_name()); +} + +[[nodiscard]] GLenum renderer_string_name() noexcept +{ + return static_cast(pp::renderer::gl::renderer_string_name()); +} + +[[nodiscard]] GLenum shading_language_version_string_name() noexcept +{ + return static_cast(pp::renderer::gl::shading_language_version_string_name()); +} + +[[nodiscard]] GLenum depth_test_state() noexcept +{ + return static_cast(pp::renderer::gl::depth_test_state()); +} + +[[nodiscard]] GLenum program_point_size_state() noexcept +{ + return static_cast(pp::renderer::gl::program_point_size_state()); +} + +[[nodiscard]] GLenum line_smooth_state() noexcept +{ + return static_cast(pp::renderer::gl::line_smooth_state()); +} + +[[nodiscard]] GLenum source_alpha_blend_factor() noexcept +{ + return static_cast(pp::renderer::gl::source_alpha_blend_factor()); +} + +[[nodiscard]] GLenum one_minus_source_alpha_blend_factor() noexcept +{ + return static_cast(pp::renderer::gl::one_minus_source_alpha_blend_factor()); +} + +[[nodiscard]] GLenum add_blend_equation() noexcept +{ + return static_cast(pp::renderer::gl::add_blend_equation()); +} + +[[nodiscard]] GLenum max_blend_equation() noexcept +{ + return static_cast(pp::renderer::gl::max_blend_equation()); +} + +[[nodiscard]] GLint rgba8_internal_format() noexcept +{ + return static_cast(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 colors = { - { GL_DEBUG_SEVERITY_NOTIFICATION, 8 }, - { GL_DEBUG_SEVERITY_LOW, 8 }, - { GL_DEBUG_SEVERITY_MEDIUM, FOREGROUND_GREEN | FOREGROUND_INTENSITY }, - { GL_DEBUG_SEVERITY_HIGH, FOREGROUND_RED | FOREGROUND_INTENSITY }, + { debug_severity_notification(), 8 }, + { debug_severity_low(), 8 }, + { debug_severity_medium(), FOREGROUND_GREEN | 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(GL_DEBUG_OUTPUT_SYNCHRONOUS); + glEnable(debug_output_state()); + glEnable(debug_output_synchronous_state()); }); } #endif @@ -431,10 +528,10 @@ void App::init() render_task([] { - LOG("GL version: %s", glGetString(GL_VERSION)); - LOG("GL vendor: %s", glGetString(GL_VENDOR)); - LOG("GL renderer: %s", glGetString(GL_RENDERER)); - LOG("GLSL version: %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); + LOG("GL version: %s", glGetString(version_string_name())); + LOG("GL vendor: %s", glGetString(vendor_string_name())); + LOG("GL renderer: %s", glGetString(renderer_string_name())); + 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(GL_LINE_SMOOTH); + glEnable(program_point_size_state()); + glEnable(line_smooth_state()); #endif - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - glBlendEquationSeparate(GL_FUNC_ADD, GL_MAX); + glBlendFunc(source_alpha_blend_factor(), one_minus_source_alpha_blend_factor()); + glBlendEquationSeparate(add_blend_equation(), max_blend_equation()); }); int run_counter = Settings::value("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("auto-timelapse", true)) rec_start(); diff --git a/src/renderer_gl/opengl_capabilities.cpp b/src/renderer_gl/opengl_capabilities.cpp index d7b80e5..aa0b0ca 100644 --- a/src/renderer_gl/opengl_capabilities.cpp +++ b/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; diff --git a/src/renderer_gl/opengl_capabilities.h b/src/renderer_gl/opengl_capabilities.h index c8ccb95..041e1d8 100644 --- a/src/renderer_gl/opengl_capabilities.h +++ b/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 panopainter_cube_face_texture_targets() noexcept; diff --git a/tests/renderer_gl/capabilities_tests.cpp b/tests/renderer_gl/capabilities_tests.cpp index 8b1f631..69eb596 100644 --- a/tests/renderer_gl/capabilities_tests.cpp +++ b/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 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);