// Enable the extension when creating the device
std::vector<const char*> device_extensions = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
    VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME,
    VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME
};

// Create a pipeline that reads from attachments
vk::PipelineRenderingCreateInfoKHR rendering_create_info;
rendering_create_info.setColorAttachmentCount(1);
rendering_create_info.setColorAttachmentFormats(color_format);
rendering_create_info.setDepthAttachmentFormat(depth_format);

// Set up the attachment local read info
vk::AttachmentSampleCountInfoAMD sample_count_info;
sample_count_info.setColorAttachmentSamples(vk::SampleCountFlagBits::e1);
sample_count_info.setDepthStencilAttachmentSamples(vk::SampleCountFlagBits::e1);

vk::RenderingAttachmentLocationInfoKHR location_info;
location_info.setColorAttachmentLocations(0);  // Location 0 for the color attachment

vk::RenderingInputAttachmentIndexInfoKHR input_index_info;
input_index_info.setColorInputAttachmentIndices(0);  // Index 0 for the color attachment

// Create the graphics pipeline
vk::GraphicsPipelineCreateInfo pipeline_info;
pipeline_info.setPNext(&rendering_create_info);
// ... set other pipeline creation parameters

// In your fragment shader, you can now read from the attachment
// using subpassLoad() or texture sampling with the appropriate extension
// Fragment shader example (GLSL):
// #extension GL_EXT_shader_tile_image : require
// layout(location = 0) out vec4 outColor;
// layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInput inputColor;
// void main() {
//     vec4 color = subpassLoad(inputColor);
//     outColor = color * 2.0;  // Double the brightness
// }

// Enable the extension when creating the device
std::vector<const char*> device_extensions = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
    VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME
};

// When creating your shader module, make sure your shader uses the extension
// GLSL example:
// #extension GL_EXT_shader_tile_image : require
//
// layout(tile_image, set = 0, binding = 0) uniform tileImageColor { vec4 color; } tileColor;
//
// void main() {
//     // Read from tile memory
//     vec4 current_color = tileColor.color;
//
//     // Process the color
//     vec4 new_color = process(current_color);
//
//     // Write back to tile memory
//     tileColor.color = new_color;
// }

// Common vendor IDs (used here only for labeling/logging output)
const uint32_t VENDOR_ID_QUALCOMM = 0x5143; // Adreno
const uint32_t VENDOR_ID_ARM = 0x13B5;      // Mali
const uint32_t VENDOR_ID_IMAGINATION = 0x1010; // PowerVR
const uint32_t VENDOR_ID_HUAWEI = 0x19E5;   // Kirin
const uint32_t VENDOR_ID_APPLE = 0x106B;    // Apple

bool log_device_extension_support(vk::PhysicalDevice physical_device) {
    vk::PhysicalDeviceProperties props = physical_device.getProperties();
    std::string vendor_name;

    // Identify vendor for display purposes only
    switch (props.vendorID) {
        case VENDOR_ID_QUALCOMM: vendor_name = "Qualcomm"; break;
        case VENDOR_ID_ARM: vendor_name = "ARM Mali"; break;
        case VENDOR_ID_IMAGINATION: vendor_name = "PowerVR"; break;
        case VENDOR_ID_HUAWEI: vendor_name = "Huawei"; break;
        case VENDOR_ID_APPLE: vendor_name = "Apple"; break;
        default: vendor_name = "Unknown"; break;
    }

    // Check for widely useful EXT/KHR extensions on this device
    auto available_extensions = physical_device.enumerateDeviceExtensionProperties();
    bool has_dynamic_rendering = false;
    bool has_dynamic_rendering_local_read = false;
    bool has_shader_tile_image = false;

    for (const auto& ext : available_extensions) {
        std::string ext_name = ext.extensionName;
        if (ext_name == VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME) {
            has_dynamic_rendering = true;
        } else if (ext_name == VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME) {
            has_dynamic_rendering_local_read = true;
        } else if (ext_name == VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME) {
            has_shader_tile_image = true;
        }
    }

    // Log the extension support
    std::cout << vendor_name << " device detected with extension support:" << std::endl;
    std::cout << "  Dynamic Rendering: " << (has_dynamic_rendering ? "Yes" : "No") << std::endl;
    std::cout << "  Dynamic Rendering Local Read: " << (has_dynamic_rendering_local_read ? "Yes" : "No") << std::endl;
    std::cout << "  Shader Tile Image: " << (has_shader_tile_image ? "Yes" : "No") << std::endl;

    return has_dynamic_rendering || has_dynamic_rendering_local_read || has_shader_tile_image;
}