Map renderer depth compares to OpenGL

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,

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

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;

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;

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<pp::renderer::CompareOp>(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);