Plan renderer diagnostics in app status

src/app_core/app_status.h

@@ -33,6 +33,23 @@ struct RecordingFrameLabel {
     std::string text;
 };
 
+struct RendererDiagnosticsInput {
+    bool framebuffer_fetch = false;
+    bool float32_render_targets = false;
+    bool float32_linear_filtering = false;
+    bool float16_render_targets = false;
+};
+
+struct RendererDiagnosticIndicator {
+    bool supported = false;
+    std::string_view label;
+};
+
+struct RendererDiagnosticsPlan {
+    RendererDiagnosticIndicator framebuffer_fetch;
+    RendererDiagnosticIndicator floating_point_targets;
+};
+
 [[nodiscard]] inline pp::foundation::Result<int> display_resolution_from_index(int index)
 {
     if (index < 0 || static_cast<std::size_t>(index) >= document_resolution_values.size()) {
@@ -116,4 +133,38 @@ struct RecordingFrameLabel {
     };
 }
 
+[[nodiscard]] inline RendererDiagnosticsPlan plan_renderer_diagnostics(
+    RendererDiagnosticsInput input) noexcept
+{
+    RendererDiagnosticsPlan plan;
+    plan.framebuffer_fetch = {
+        input.framebuffer_fetch,
+        "FBF",
+    };
+
+    if (input.float32_linear_filtering) {
+        plan.floating_point_targets = {
+            true,
+            "F32L",
+        };
+    } else if (input.float32_render_targets) {
+        plan.floating_point_targets = {
+            true,
+            "F32",
+        };
+    } else if (input.float16_render_targets) {
+        plan.floating_point_targets = {
+            true,
+            "F16",
+        };
+    } else {
+        plan.floating_point_targets = {
+            false,
+            "",
+        };
+    }
+
+    return plan;
+}
+
 }

src/app_layout.cpp

@@ -2179,23 +2179,28 @@ void App::initLayout()
             version_label->set_text(g_version);
         }
 
+        const auto renderer_features = ShaderManager::render_device_features();
+        const auto renderer_diagnostics = pp::app::plan_renderer_diagnostics({
+            .framebuffer_fetch = renderer_features.framebuffer_fetch,
+            .float32_render_targets = renderer_features.float32_render_targets,
+            .float32_linear_filtering = ShaderManager::ext_float32_linear,
+            .float16_render_targets = renderer_features.float16_render_targets,
+        });
+
         if (auto x = layout[main_id]->find<NodeBorder>("ext-fbf"))
         {
-            x->m_color = ShaderManager::ext_framebuffer_fetch ? glm::vec4(0, 1, 0, 1) : glm::vec4(1, 0, 0, 1);
+            x->m_color = renderer_diagnostics.framebuffer_fetch.supported ?
+                glm::vec4(0, 1, 0, 1) :
+                glm::vec4(1, 0, 0, 1);
         }
 
         if (auto x = layout[main_id]->find<NodeBorder>("ext-flt"))
         {
-            if (ShaderManager::ext_float32 || ShaderManager::ext_float16)
+            if (renderer_diagnostics.floating_point_targets.supported)
             {
                 if (auto t = x->find<NodeText>("ext-flt-text"))
                 {
-                    if (ShaderManager::ext_float32_linear)
-                        t->set_text("F32L");
-                    else if (ShaderManager::ext_float32)
-                        t->set_text("F32");
-                    else if (ShaderManager::ext_float16)
-                        t->set_text("F16");
+                    t->set_text(std::string(renderer_diagnostics.floating_point_targets.label));
                 }
                 x->m_color = glm::vec4(0, 1, 0, 1);
             }