physical_device_internal.h

#pragma once
 
#include <volk.h>
 
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace pixelbullet
{
enum class GraphicsDevicePreference : uint8_t;
}
 
namespace pixelbullet::graphics_internal
{
inline constexpr uint32_t k_supported_vulkan_api_version = VK_API_VERSION_1_3;
 
struct ResolvedQueueFamilies
{
    uint32_t graphics_family = 0;
    uint32_t present_family = 0;
    std::optional<uint32_t> compute_family;
    std::optional<uint32_t> transfer_family;
};
 
struct PhysicalDeviceCompatibilityEvaluation
{
    bool is_compatible = false;
    uint32_t score = 0;
    std::vector<std::string> rejection_reasons;
    std::optional<ResolvedQueueFamilies> queue_families;
};
 
struct PhysicalDeviceSelectionResult
{
    std::optional<std::size_t> selected_index;
    bool matched_preference = false;
    bool exact_index_requested = false;
    bool exact_index_in_range = false;
};
 
struct PhysicalDeviceSelectionRequest
{
    GraphicsDevicePreference preference;
    std::optional<std::size_t> exact_device_index;
};
 
struct PhysicalDeviceDiagnosticsEntry
{
    VkPhysicalDevice device = VK_NULL_HANDLE;
    VkPhysicalDeviceProperties properties = {};
    std::vector<VkExtensionProperties> available_extensions;
    PhysicalDeviceCompatibilityEvaluation evaluation;
    bool matches_preference = false;
    bool selected = false;
};
 
struct PhysicalDeviceDiagnosticsReport
{
    std::vector<PhysicalDeviceDiagnosticsEntry> entries;
    std::optional<std::size_t> selected_index;
    bool matched_preference = false;
    PhysicalDeviceSelectionResult selection_result;
};
 
std::string FormatVulkanApiVersion(uint32_t version);
std::string_view DescribeGraphicsDevicePreference(GraphicsDevicePreference preference) noexcept;
std::string_view DescribePhysicalDeviceType(VkPhysicalDeviceType device_type) noexcept;
const std::vector<const char*>& GetRequiredGraphicsDeviceExtensions() noexcept;
 
std::optional<ResolvedQueueFamilies> ResolveQueueFamilies(const std::vector<VkQueueFamilyProperties>& queue_family_properties,
                                                          const std::vector<VkBool32>& present_support) noexcept;
 
bool MatchesGraphicsDevicePreference(VkPhysicalDeviceType device_type, GraphicsDevicePreference preference) noexcept;
 
PhysicalDeviceCompatibilityEvaluation EvaluatePhysicalDeviceCompatibility(
    const VkPhysicalDeviceProperties& properties, const std::vector<VkExtensionProperties>& available_extensions,
    const std::vector<const char*>& required_extensions, const std::vector<VkQueueFamilyProperties>& queue_family_properties,
    const std::vector<VkBool32>& present_support, uint32_t surface_format_count, uint32_t present_mode_count);
 
PhysicalDeviceSelectionResult ChooseCompatiblePhysicalDevice(const std::vector<VkPhysicalDeviceProperties>& properties,
                                                             const std::vector<PhysicalDeviceCompatibilityEvaluation>& evaluations,
                                                             PhysicalDeviceSelectionRequest selection_request) noexcept;
 
std::optional<std::size_t>
ChooseBestCompatiblePhysicalDeviceIndex(const std::vector<PhysicalDeviceCompatibilityEvaluation>& evaluations) noexcept;
 
PhysicalDeviceDiagnosticsReport BuildPhysicalDeviceDiagnosticsReport(
    const std::vector<VkPhysicalDevice>& devices, const std::vector<VkPhysicalDeviceProperties>& properties,
    const std::vector<std::vector<VkExtensionProperties>>& available_extensions,
    const std::vector<PhysicalDeviceCompatibilityEvaluation>& evaluations, PhysicalDeviceSelectionRequest selection_request);
 
PhysicalDeviceDiagnosticsReport EnumeratePhysicalDeviceDiagnostics(VkInstance instance, VkSurfaceKHR surface,
                                                                   PhysicalDeviceSelectionRequest selection_request);
 
std::string BuildUnsupportedPhysicalDeviceMessage(std::size_t enumerated_device_count);
std::string BuildRequestedPhysicalDeviceOutOfRangeMessage(std::size_t requested_index, std::size_t enumerated_device_count);
std::string BuildRequestedPhysicalDeviceIncompatibleMessage(std::size_t requested_index, const VkPhysicalDeviceProperties& properties,
                                                            const std::vector<std::string>& rejection_reasons);
} // namespace pixelbullet::graphics_internal