omar/panopainter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move app init state mapping to renderer gl

Browse Source
This commit is contained in:
omigamedev
2026-06-02 06:54:43 +02:00
parent 9e0a88726c
commit 19f815e3d2
6 changed files with 272 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
docs/modernization/build-inventory.md
View File

@@ -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.

5
docs/modernization/roadmap.md
View File

@@ -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:

133
src/app.cpp
View File

@@ -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 },
{ 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<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();

107
src/renderer_gl/opengl_capabilities.cpp
View File

@@ -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;

18
src/renderer_gl/opengl_capabilities.h
View File

@@ -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;

25
tests/renderer_gl/capabilities_tests.cpp
View File

@@ -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);