From c5c31f0a56d42864e988da2ac304c1d03d85a7c2 Mon Sep 17 00:00:00 2001 From: omigamedev Date: Tue, 2 Jun 2026 18:25:25 +0200 Subject: [PATCH] Map renderer depth compares to OpenGL --- docs/modernization/build-inventory.md | 3 +- docs/modernization/roadmap.md | 4 ++- src/renderer_gl/opengl_capabilities.cpp | 32 ++++++++++++++++++ src/renderer_gl/opengl_capabilities.h | 2 ++ tests/renderer_gl/capabilities_tests.cpp | 42 ++++++++++++++++++++++++ 5 files changed, 81 insertions(+), 2 deletions(-) diff --git a/docs/modernization/build-inventory.md b/docs/modernization/build-inventory.md index 65e066a..d7f237e 100644 --- a/docs/modernization/build-inventory.md +++ b/docs/modernization/build-inventory.md @@ -212,7 +212,8 @@ Known local toolchain state: queries, active-uniform count query, and matrix-uniform transpose token used by legacy `Shader` creation also live here. Renderer API blend factor/op to OpenGL token mapping is tested here with explicit support flags so `GL_ZERO` - stays distinguishable from unsupported enum values. `Shader` no longer spells GL enum + stays distinguishable from unsupported enum values. Renderer API depth + compare-op to OpenGL depth-function mapping is tested here too. `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. App OpenGL initialization debug severity, debug output, GL info string, diff --git a/docs/modernization/roadmap.md b/docs/modernization/roadmap.md index c7caced..d74151f 100644 --- a/docs/modernization/roadmap.md +++ b/docs/modernization/roadmap.md @@ -469,7 +469,9 @@ binding catalog, shader stage tokens, compile/link status queries, active-unifor count query, and matrix-uniform transpose token also live in `pp_renderer_gl` and are consumed by legacy `Shader` creation. Renderer API blend factor/op to OpenGL token mapping also lives in `pp_renderer_gl`, with explicit support flags -so `GL_ZERO` remains distinguishable from unsupported enum values. Shader uniform hashing, catalog +so `GL_ZERO` remains distinguishable from unsupported enum values. Renderer API +depth compare-op to OpenGL depth-function mapping also lives in +`pp_renderer_gl`. 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. App OpenGL initialization debug severity, debug output, GL info diff --git a/src/renderer_gl/opengl_capabilities.cpp b/src/renderer_gl/opengl_capabilities.cpp index 82afb73..915e417 100644 --- a/src/renderer_gl/opengl_capabilities.cpp +++ b/src/renderer_gl/opengl_capabilities.cpp @@ -52,6 +52,14 @@ constexpr std::uint32_t gl_blend = 0x0BE2U; constexpr std::uint32_t gl_color_clear_value = 0x0C22U; constexpr std::uint32_t gl_scissor_test = 0x0C11U; constexpr std::uint32_t gl_depth_test = 0x0B71U; +constexpr std::uint32_t gl_never = 0x0200U; +constexpr std::uint32_t gl_less = 0x0201U; +constexpr std::uint32_t gl_equal = 0x0202U; +constexpr std::uint32_t gl_lequal = 0x0203U; +constexpr std::uint32_t gl_greater = 0x0204U; +constexpr std::uint32_t gl_notequal = 0x0205U; +constexpr std::uint32_t gl_gequal = 0x0206U; +constexpr std::uint32_t gl_always = 0x0207U; constexpr std::uint32_t gl_current_program = 0x8B8DU; constexpr std::uint32_t gl_active_texture = 0x84E0U; constexpr std::uint32_t gl_texture_binding_2d = 0x8069U; @@ -664,6 +672,30 @@ std::uint32_t depth_test_state() noexcept return gl_depth_test; } +OpenGlEnumMapping compare_function_for_renderer_compare_op(pp::renderer::CompareOp op) noexcept +{ + switch (op) { + case pp::renderer::CompareOp::never: + return OpenGlEnumMapping { .value = gl_never, .supported = true }; + case pp::renderer::CompareOp::less: + return OpenGlEnumMapping { .value = gl_less, .supported = true }; + case pp::renderer::CompareOp::equal: + return OpenGlEnumMapping { .value = gl_equal, .supported = true }; + case pp::renderer::CompareOp::less_or_equal: + return OpenGlEnumMapping { .value = gl_lequal, .supported = true }; + case pp::renderer::CompareOp::greater: + return OpenGlEnumMapping { .value = gl_greater, .supported = true }; + case pp::renderer::CompareOp::not_equal: + return OpenGlEnumMapping { .value = gl_notequal, .supported = true }; + case pp::renderer::CompareOp::greater_or_equal: + return OpenGlEnumMapping { .value = gl_gequal, .supported = true }; + case pp::renderer::CompareOp::always: + return OpenGlEnumMapping { .value = gl_always, .supported = true }; + default: + return OpenGlEnumMapping {}; + } +} + std::uint32_t scissor_test_state() noexcept { return gl_scissor_test; diff --git a/src/renderer_gl/opengl_capabilities.h b/src/renderer_gl/opengl_capabilities.h index 1aaa22a..b844637 100644 --- a/src/renderer_gl/opengl_capabilities.h +++ b/src/renderer_gl/opengl_capabilities.h @@ -135,6 +135,8 @@ struct OpenGlWindowsWglContextConfig { [[nodiscard]] std::uint32_t sampler_binding_query() noexcept; [[nodiscard]] std::uint32_t blend_state() noexcept; [[nodiscard]] std::uint32_t depth_test_state() noexcept; +[[nodiscard]] OpenGlEnumMapping compare_function_for_renderer_compare_op( + pp::renderer::CompareOp op) noexcept; [[nodiscard]] std::uint32_t scissor_test_state() noexcept; [[nodiscard]] std::uint32_t program_point_size_state() noexcept; [[nodiscard]] std::uint32_t line_smooth_state() noexcept; diff --git a/tests/renderer_gl/capabilities_tests.cpp b/tests/renderer_gl/capabilities_tests.cpp index fcd3c32..8c0f2df 100644 --- a/tests/renderer_gl/capabilities_tests.cpp +++ b/tests/renderer_gl/capabilities_tests.cpp @@ -487,6 +487,47 @@ void maps_renderer_blend_state_tokens(pp::tests::Harness& h) PP_EXPECT(h, invalid_op.value == 0U); } +void maps_renderer_depth_compare_tokens(pp::tests::Harness& h) +{ + const auto never = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::never); + const auto less = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::less); + const auto equal = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::equal); + const auto less_or_equal = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::less_or_equal); + const auto greater = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::greater); + const auto not_equal = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::not_equal); + const auto greater_or_equal = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::greater_or_equal); + const auto always = pp::renderer::gl::compare_function_for_renderer_compare_op( + pp::renderer::CompareOp::always); + const auto invalid = pp::renderer::gl::compare_function_for_renderer_compare_op( + static_cast(255U)); + + PP_EXPECT(h, never.supported); + PP_EXPECT(h, never.value == 0x0200U); + PP_EXPECT(h, less.supported); + PP_EXPECT(h, less.value == 0x0201U); + PP_EXPECT(h, equal.supported); + PP_EXPECT(h, equal.value == 0x0202U); + PP_EXPECT(h, less_or_equal.supported); + PP_EXPECT(h, less_or_equal.value == 0x0203U); + PP_EXPECT(h, greater.supported); + PP_EXPECT(h, greater.value == 0x0204U); + PP_EXPECT(h, not_equal.supported); + PP_EXPECT(h, not_equal.value == 0x0205U); + PP_EXPECT(h, greater_or_equal.supported); + PP_EXPECT(h, greater_or_equal.value == 0x0206U); + PP_EXPECT(h, always.supported); + PP_EXPECT(h, always.value == 0x0207U); + PP_EXPECT(h, !invalid.supported); + PP_EXPECT(h, invalid.value == 0U); +} + void maps_windows_wgl_core_context_parameters(pp::tests::Harness& h) { const auto config = pp::renderer::gl::windows_wgl_core_context_3_3_config(); @@ -616,6 +657,7 @@ int main() harness.run("exposes_shader_attribute_binding_catalog", exposes_shader_attribute_binding_catalog); harness.run("maps_app_initialization_parameters", maps_app_initialization_parameters); harness.run("maps_renderer_blend_state_tokens", maps_renderer_blend_state_tokens); + harness.run("maps_renderer_depth_compare_tokens", maps_renderer_depth_compare_tokens); harness.run("maps_windows_wgl_core_context_parameters", maps_windows_wgl_core_context_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);