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

Move GL state utility mapping to renderer gl

Browse Source
This commit is contained in:
omigamedev
2026-06-02 08:43:42 +02:00
parent 92e9de0441
commit dbaf50cb6e
6 changed files with 112 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -186,6 +186,9 @@ Known local toolchain state:
backend-owned texture readback formats, sampler filters, depth/blend state,
depth clears, viewport queries, color-mask booleans, active texture units,
and float render-target formats.
Legacy `util.cpp` OpenGL error naming and `gl_state` save/restore also
consume backend-owned error codes, state queries, framebuffer targets,
texture binding targets, and active texture units.
- `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.

3
docs/modernization/roadmap.md
View File

@@ -453,6 +453,9 @@ and RGBA8 read/write pixel mapping to `pp_renderer_gl`.
readback formats, sampler filters, depth/blend state, depth clears, viewport
queries, color-mask booleans, active texture units, and float render-target
formats to `pp_renderer_gl`.
Legacy `util.cpp` OpenGL error naming and `gl_state` save/restore now delegate
error codes, state queries, framebuffer targets, texture binding targets, and
active texture units to `pp_renderer_gl`.
The existing renderer classes are not yet fully
behind the renderer interfaces.

61
src/renderer_gl/opengl_capabilities.cpp
View File

@@ -11,6 +11,12 @@ constexpr std::uint32_t gl_unsigned_short = 0x1403U;
constexpr std::uint32_t gl_unsigned_int = 0x1405U;
constexpr std::uint32_t gl_float = 0x1406U;
constexpr std::uint32_t gl_half_float = 0x140BU;
constexpr std::uint32_t gl_no_error = 0U;
constexpr std::uint32_t gl_invalid_enum = 0x0500U;
constexpr std::uint32_t gl_invalid_value = 0x0501U;
constexpr std::uint32_t gl_invalid_operation = 0x0502U;
constexpr std::uint32_t gl_out_of_memory = 0x0505U;
constexpr std::uint32_t gl_invalid_framebuffer_operation = 0x0506U;
constexpr std::uint32_t gl_false = 0U;
constexpr std::uint32_t gl_points = 0x0000U;
constexpr std::uint32_t gl_lines = 0x0001U;
@@ -40,6 +46,11 @@ 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_current_program = 0x8B8DU;
constexpr std::uint32_t gl_active_texture = 0x84E0U;
constexpr std::uint32_t gl_texture_binding_2d = 0x8069U;
constexpr std::uint32_t gl_texture_binding_cube_map = 0x8514U;
constexpr std::uint32_t gl_sampler_binding = 0x8919U;
constexpr std::uint32_t gl_func_add = 0x8006U;
constexpr std::uint32_t gl_max = 0x8008U;
constexpr std::uint32_t gl_program_point_size = 0x8642U;
@@ -159,6 +170,31 @@ std::uint32_t extension_string_name() noexcept
return gl_extensions;
}
std::uint32_t no_error_code() noexcept
{
return gl_no_error;
}
const char* opengl_error_name(std::uint32_t error_code) noexcept
{
switch (error_code) {
case gl_no_error:
return "GL_NO_ERROR";
case gl_invalid_enum:
return "GL_INVALID_ENUM";
case gl_invalid_value:
return "GL_INVALID_VALUE";
case gl_invalid_operation:
return "GL_INVALID_OPERATION";
case gl_invalid_framebuffer_operation:
return "GL_INVALID_FRAMEBUFFER_OPERATION";
case gl_out_of_memory:
return "GL_OUT_OF_MEMORY";
default:
return "Unknown";
}
}
std::uint32_t texture_upload_type_for_internal_format(std::uint32_t internal_format) noexcept
{
switch (internal_format) {
@@ -496,6 +532,31 @@ std::uint32_t color_clear_value_query() noexcept
return gl_color_clear_value;
}
std::uint32_t current_program_query() noexcept
{
return gl_current_program;
}
std::uint32_t active_texture_query() noexcept
{
return gl_active_texture;
}
std::uint32_t texture_binding_2d_query() noexcept
{
return gl_texture_binding_2d;
}
std::uint32_t texture_binding_cube_map_query() noexcept
{
return gl_texture_binding_cube_map;
}
std::uint32_t sampler_binding_query() noexcept
{
return gl_sampler_binding;
}
std::uint32_t blend_state() noexcept
{
return gl_blend;

7
src/renderer_gl/opengl_capabilities.h
View File

@@ -44,6 +44,8 @@ struct OpenGlReadbackFormat {
[[nodiscard]] std::uint32_t extension_count_query() noexcept;
[[nodiscard]] std::uint32_t extension_string_name() noexcept;
[[nodiscard]] std::uint32_t no_error_code() noexcept;
[[nodiscard]] const char* opengl_error_name(std::uint32_t error_code) noexcept;
[[nodiscard]] std::uint32_t texture_upload_type_for_internal_format(std::uint32_t internal_format) noexcept;
[[nodiscard]] std::uint32_t unsigned_byte_component_type() noexcept;
[[nodiscard]] std::uint32_t rgba_pixel_format() noexcept;
@@ -101,6 +103,11 @@ struct OpenGlReadbackFormat {
[[nodiscard]] std::uint32_t shading_language_version_string_name() noexcept;
[[nodiscard]] std::uint32_t viewport_query() noexcept;
[[nodiscard]] std::uint32_t color_clear_value_query() noexcept;
[[nodiscard]] std::uint32_t current_program_query() noexcept;
[[nodiscard]] std::uint32_t active_texture_query() noexcept;
[[nodiscard]] std::uint32_t texture_binding_2d_query() noexcept;
[[nodiscard]] std::uint32_t texture_binding_cube_map_query() noexcept;
[[nodiscard]] std::uint32_t sampler_binding_query() noexcept;
[[nodiscard]] std::uint32_t blend_state() noexcept;
[[nodiscard]] std::uint32_t depth_test_state() noexcept;
[[nodiscard]] std::uint32_t scissor_test_state() noexcept;

56
src/util.cpp
View File

@@ -3,6 +3,7 @@
#include "util.h"
#include <poly2tri.h>
#include "app.h"
#include "renderer_gl/opengl_capabilities.h"
template<>
std::vector<vertex_t> poly_remove_duplicate<vertex_t>(const std::vector<vertex_t>& v, const float tollerance)
@@ -628,16 +629,7 @@ std::string str_replace(const std::string& string, const std::string& search, co
static const char* gl2str(GLenum err)
{
switch (err)
{
case GL_NO_ERROR: return "GL_NO_ERROR";
case GL_INVALID_ENUM: return "GL_INVALID_ENUM";
case GL_INVALID_VALUE: return "GL_INVALID_VALUE";
case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
case GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION";
case GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY";
default: return "Unknown";
}
return pp::renderer::gl::opengl_error_name(err);
}
double now_seconds()
@@ -657,7 +649,7 @@ double now_seconds()
void check_OpenGLError(const char* stmt, const char* fname, int line)
{
GLenum err;
while ((err = glGetError()) != GL_NO_ERROR)
while ((err = glGetError()) != pp::renderer::gl::no_error_code())
{
LOG("OpenGL error %08x (%s), at %s:%i - for %s", err, gl2str(err), fname, line, stmt);
}
@@ -735,41 +727,41 @@ void parallel_for(size_t nb_elements, std::function<void(size_t i)> functor, boo
void gl_state::save()
{
assert(App::I->is_render_thread());
blend = glIsEnabled(GL_BLEND);
depth_test = glIsEnabled(GL_DEPTH_TEST);
scissor_test = glIsEnabled(GL_SCISSOR_TEST);
glGetIntegerv(GL_VIEWPORT, vp);
glGetFloatv(GL_COLOR_CLEAR_VALUE, cc);
glGetIntegerv(GL_CURRENT_PROGRAM, &program);
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &fbd);
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &fbr);
glGetIntegerv(GL_ACTIVE_TEXTURE, &active_tex);
glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &cube);
blend = glIsEnabled(pp::renderer::gl::blend_state());
depth_test = glIsEnabled(pp::renderer::gl::depth_test_state());
scissor_test = glIsEnabled(pp::renderer::gl::scissor_test_state());
glGetIntegerv(pp::renderer::gl::viewport_query(), vp);
glGetFloatv(pp::renderer::gl::color_clear_value_query(), cc);
glGetIntegerv(pp::renderer::gl::current_program_query(), &program);
glGetIntegerv(pp::renderer::gl::draw_framebuffer_binding_query(), &fbd);
glGetIntegerv(pp::renderer::gl::read_framebuffer_binding_query(), &fbr);
glGetIntegerv(pp::renderer::gl::active_texture_query(), &active_tex);
glGetIntegerv(pp::renderer::gl::texture_binding_cube_map_query(), &cube);
for (int i = 0; i < 10; ++i)
{
glActiveTexture(GL_TEXTURE0 + i);
glGetIntegerv(GL_TEXTURE_BINDING_2D, tex + i);
glGetIntegerv(GL_SAMPLER_BINDING, sampler + i);
glActiveTexture(pp::renderer::gl::active_texture_unit(static_cast<std::uint32_t>(i)));
glGetIntegerv(pp::renderer::gl::texture_binding_2d_query(), tex + i);
glGetIntegerv(pp::renderer::gl::sampler_binding_query(), sampler + i);
}
}
void gl_state::restore()
{
assert(App::I->is_render_thread());
blend ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
depth_test ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
scissor_test ? glEnable(GL_SCISSOR_TEST) : glDisable(GL_SCISSOR_TEST);
blend ? glEnable(pp::renderer::gl::blend_state()) : glDisable(pp::renderer::gl::blend_state());
depth_test ? glEnable(pp::renderer::gl::depth_test_state()) : glDisable(pp::renderer::gl::depth_test_state());
scissor_test ? glEnable(pp::renderer::gl::scissor_test_state()) : glDisable(pp::renderer::gl::scissor_test_state());
glViewport(vp[0], vp[1], vp[2], vp[3]);
glClearColor(cc[0], cc[1], cc[2], cc[3]);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbd);
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbr);
glBindFramebuffer(pp::renderer::gl::draw_framebuffer_target(), fbd);
glBindFramebuffer(pp::renderer::gl::read_framebuffer_target(), fbr);
glUseProgram(program);
for (int i = 0; i < 10; ++i)
{
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, tex[i]);
glActiveTexture(pp::renderer::gl::active_texture_unit(static_cast<std::uint32_t>(i)));
glBindTexture(pp::renderer::gl::texture_2d_target(), tex[i]);
glBindSampler(i, sampler[i]);
}
glActiveTexture(active_tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, cube);
glBindTexture(pp::renderer::gl::texture_cube_map_target(), cube);
}

14
tests/renderer_gl/capabilities_tests.cpp
View File

@@ -18,6 +18,15 @@ void detects_common_extension_capabilities(pp::tests::Harness& h)
PP_EXPECT(h, pp::renderer::gl::extension_count_query() == 0x821DU);
PP_EXPECT(h, pp::renderer::gl::extension_string_name() == 0x1F03U);
PP_EXPECT(h, pp::renderer::gl::no_error_code() == 0U);
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0U) == std::string_view("GL_NO_ERROR"));
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0x0500U) == std::string_view("GL_INVALID_ENUM"));
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0x0501U) == std::string_view("GL_INVALID_VALUE"));
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0x0502U) == std::string_view("GL_INVALID_OPERATION"));
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0x0505U) == std::string_view("GL_OUT_OF_MEMORY"));
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0x0506U)
== std::string_view("GL_INVALID_FRAMEBUFFER_OPERATION"));
PP_EXPECT(h, pp::renderer::gl::opengl_error_name(0xffffffffU) == std::string_view("Unknown"));
const auto capabilities = pp::renderer::gl::detect_opengl_capabilities(
extensions,
@@ -326,6 +335,11 @@ void maps_app_initialization_parameters(pp::tests::Harness& h)
PP_EXPECT(h, pp::renderer::gl::viewport_query() == 0x0BA2U);
PP_EXPECT(h, pp::renderer::gl::color_clear_value_query() == 0x0C22U);
PP_EXPECT(h, pp::renderer::gl::current_program_query() == 0x8B8DU);
PP_EXPECT(h, pp::renderer::gl::active_texture_query() == 0x84E0U);
PP_EXPECT(h, pp::renderer::gl::texture_binding_2d_query() == 0x8069U);
PP_EXPECT(h, pp::renderer::gl::texture_binding_cube_map_query() == 0x8514U);
PP_EXPECT(h, pp::renderer::gl::sampler_binding_query() == 0x8919U);
PP_EXPECT(h, pp::renderer::gl::blend_state() == 0x0BE2U);
PP_EXPECT(h, pp::renderer::gl::depth_test_state() == 0x0B71U);
PP_EXPECT(h, pp::renderer::gl::scissor_test_state() == 0x0C11U);