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

Map renderer depth compares to OpenGL

Browse Source
This commit is contained in:
omigamedev
2026-06-02 18:25:25 +02:00
parent b6c66f3e41
commit c5c31f0a56
5 changed files with 81 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

4
docs/modernization/roadmap.md
View File

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

32
src/renderer_gl/opengl_capabilities.cpp
View File

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

2
src/renderer_gl/opengl_capabilities.h
View File

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

42
tests/renderer_gl/capabilities_tests.cpp
View File

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