Move shader feature negotiation into renderer backend

src/app_shaders.cpp

@@ -6,15 +6,14 @@
 
 namespace {
 
-[[nodiscard]] pp::renderer::gl::OpenGlCapabilities shader_manager_capabilities() noexcept
+void apply_shader_manager_feature_state(pp::renderer::gl::OpenGlFeatureState feature_state) noexcept
 {
-    pp::renderer::gl::OpenGlCapabilities capabilities;
-    capabilities.framebuffer_fetch = ShaderManager::ext_framebuffer_fetch;
-    capabilities.map_buffer_alignment = ShaderManager::ext_map_aligned;
-    capabilities.float32_textures = ShaderManager::ext_float32;
-    capabilities.float32_linear = ShaderManager::ext_float32_linear;
-    capabilities.float16_textures = ShaderManager::ext_float16;
-    return capabilities;
+    ShaderManager::ext_framebuffer_fetch = feature_state.capabilities.framebuffer_fetch;
+    ShaderManager::ext_map_aligned = feature_state.capabilities.map_buffer_alignment;
+    ShaderManager::ext_float32 = feature_state.capabilities.float32_textures;
+    ShaderManager::ext_float32_linear = feature_state.capabilities.float32_linear;
+    ShaderManager::ext_float16 = feature_state.capabilities.float16_textures;
+    ShaderManager::set_render_device_features(feature_state.features);
 }
 
 void query_gl_integer(std::uint32_t name, std::int32_t* value) noexcept
@@ -40,42 +39,28 @@ void App::initShaders()
 #endif // _DEBUG
 
     render_task([] {
-        const auto extensions_result = pp::renderer::gl::query_opengl_extensions(
+        const auto detection_result = pp::renderer::gl::query_opengl_capability_detection(
             pp::renderer::gl::OpenGlExtensionQueryDispatch {
                 .get_integer = query_gl_integer,
                 .get_string_indexed = query_gl_string_indexed,
-            });
-        if (!extensions_result.ok()) {
-            LOG("OpenGL extension query failed: %s", extensions_result.status().message);
+            },
+            pp::renderer::gl::opengl_runtime_for_current_build());
+        if (!detection_result.ok()) {
+            LOG("OpenGL capability detection failed: %s", detection_result.status().message);
             return;
         }
 
-        const auto& extension_storage = extensions_result.value();
-        std::vector<std::string_view> extension_views;
-        extension_views.reserve(extension_storage.size());
-        for (const auto& extension : extension_storage) {
-            extension_views.push_back(extension);
+        const auto& detection = detection_result.value();
+        for (const auto& extension : detection.extensions) {
             LOG("EXT: %s", extension.c_str());
         }
 
-        const auto runtime = pp::renderer::gl::opengl_runtime_for_current_build();
-        const auto capabilities = pp::renderer::gl::detect_opengl_capabilities(extension_views, runtime);
-        ShaderManager::ext_framebuffer_fetch = capabilities.framebuffer_fetch;
-        ShaderManager::ext_map_aligned = capabilities.map_buffer_alignment;
-        ShaderManager::ext_float32 = capabilities.float32_textures;
-        ShaderManager::ext_float32_linear = capabilities.float32_linear;
-        ShaderManager::ext_float16 = capabilities.float16_textures;
-        ShaderManager::set_render_device_features(pp::renderer::gl::render_device_features(capabilities));
+        apply_shader_manager_feature_state(detection.feature_state);
     });
     
-    if (pp::renderer::gl::opengl_runtime_for_current_build().desktop_gl) {
-        // In OpenGL 3.3 these should be already available.
-        ShaderManager::ext_float32_linear = true;
-        ShaderManager::ext_float32 = true;
-        ShaderManager::ext_float16 = true;
-    }
-    ShaderManager::set_render_device_features(
-        pp::renderer::gl::render_device_features(shader_manager_capabilities()));
+    apply_shader_manager_feature_state(pp::renderer::gl::detect_opengl_feature_state(
+        std::span<const std::string_view> {},
+        pp::renderer::gl::opengl_runtime_for_current_build()));
 
     LOG("Shader Extension shader_framebuffer_fetch: %s", ShaderManager::ext_framebuffer_fetch ? "enabled" : "disabled");
 

src/renderer_gl/opengl_capabilities.cpp

@@ -228,6 +228,17 @@ pp::renderer::RenderDeviceFeatures render_device_features(OpenGlCapabilities cap
     };
 }
 
+OpenGlFeatureState detect_opengl_feature_state(
+    std::span<const std::string_view> extensions,
+    OpenGlRuntime runtime) noexcept
+{
+    const auto capabilities = detect_opengl_capabilities(extensions, runtime);
+    return OpenGlFeatureState {
+        .capabilities = capabilities,
+        .features = render_device_features(capabilities),
+    };
+}
+
 OpenGlInitialState panopainter_initial_state() noexcept
 {
     return OpenGlInitialState {
@@ -369,6 +380,28 @@ pp::foundation::Result<std::vector<std::string>> query_opengl_extensions(
     return pp::foundation::Result<std::vector<std::string>>::success(std::move(extensions));
 }
 
+pp::foundation::Result<OpenGlCapabilityDetectionResult> query_opengl_capability_detection(
+    OpenGlExtensionQueryDispatch dispatch,
+    OpenGlRuntime runtime)
+{
+    auto extensions_result = query_opengl_extensions(dispatch);
+    if (!extensions_result.ok()) {
+        return pp::foundation::Result<OpenGlCapabilityDetectionResult>::failure(extensions_result.status());
+    }
+
+    auto extensions = std::move(extensions_result.value());
+    std::vector<std::string_view> extension_views;
+    extension_views.reserve(extensions.size());
+    for (const auto& extension : extensions) {
+        extension_views.push_back(extension);
+    }
+
+    return pp::foundation::Result<OpenGlCapabilityDetectionResult>::success(OpenGlCapabilityDetectionResult {
+        .extensions = std::move(extensions),
+        .feature_state = detect_opengl_feature_state(extension_views, runtime),
+    });
+}
+
 OpenGlDefaultClear panopainter_default_clear() noexcept
 {
     return OpenGlDefaultClear {

src/renderer_gl/opengl_capabilities.h

@@ -27,6 +27,16 @@ struct OpenGlCapabilities {
     bool float16_textures = false;
 };
 
+struct OpenGlFeatureState {
+    OpenGlCapabilities capabilities;
+    pp::renderer::RenderDeviceFeatures features;
+};
+
+struct OpenGlCapabilityDetectionResult {
+    std::vector<std::string> extensions;
+    OpenGlFeatureState feature_state;
+};
+
 struct OpenGlPixelFormat {
     std::uint32_t internal_format = 0;
     std::uint32_t pixel_format = 0;
@@ -689,6 +699,12 @@ struct OpenGlMeshDeleteDispatch {
 [[nodiscard]] OpenGlRuntime opengl_runtime_for_current_build() noexcept;
 [[nodiscard]] pp::renderer::RenderDeviceFeatures render_device_features(
     OpenGlCapabilities capabilities) noexcept;
+[[nodiscard]] OpenGlFeatureState detect_opengl_feature_state(
+    std::span<const std::string_view> extensions,
+    OpenGlRuntime runtime) noexcept;
+[[nodiscard]] pp::foundation::Result<OpenGlCapabilityDetectionResult> query_opengl_capability_detection(
+    OpenGlExtensionQueryDispatch dispatch,
+    OpenGlRuntime runtime);
 [[nodiscard]] OpenGlInitialState panopainter_initial_state() noexcept;
 [[nodiscard]] pp::foundation::Status apply_panopainter_initial_state(OpenGlStateDispatch dispatch) noexcept;
 [[nodiscard]] pp::foundation::Result<OpenGlSavedState> snapshot_opengl_state(