Method init_vulkan

cake-core/src/backends/vulkan/mod.rs:162–468

()

    }

    unsafe fn init_vulkan() -> std::result::Result<Self, String> {
        // 1. Entry + Instance
        let entry = ash::Entry::linked();
        let app_info = vk::ApplicationInfo::default()
            .application_name(c"cake-vulkan")
            .api_version(vk::make_api_version(0, 1, 3, 0));
        let instance_ci = vk::InstanceCreateInfo::default().application_info(&app_info);
        let instance = entry
            .create_instance(&instance_ci, None)
            .map_err(|e| format!("vkCreateInstance: {e}"))?;

        // 2. Physical device
        let phys_devices = instance
            .enumerate_physical_devices()
            .map_err(|e| format!("enumerate_physical_devices: {e}"))?;
        if phys_devices.is_empty() {
            return Err("no Vulkan physical devices found".into());
        }
        // Prefer discrete, fall back to first
        let physical_device = phys_devices
            .iter()
            .find(|&&pd| {
                let props = instance.get_physical_device_properties(pd);
                props.device_type == vk::PhysicalDeviceType::DISCRETE_GPU
            })
            .copied()
            .unwrap_or(phys_devices[0]);

        let props = instance.get_physical_device_properties(physical_device);
        let dev_name = CStr::from_ptr(props.device_name.as_ptr())
            .to_string_lossy()
            .to_string();
        log::info!("Vulkan backend (ash): {dev_name}");

        // 3. Queue family
        let queue_families =
            instance.get_physical_device_queue_family_properties(physical_device);
        let queue_family_index = queue_families
            .iter()
            .position(|qf| qf.queue_flags.contains(vk::QueueFlags::COMPUTE))
            .ok_or("no compute queue family")? as u32;

        // 4. Logical device + queue
        let queue_priorities = [1.0f32];
        let queue_ci =
            vk::DeviceQueueCreateInfo::default()
                .queue_family_index(queue_family_index)
                .queue_priorities(&queue_priorities);
        let device_ci = vk::DeviceCreateInfo::default().queue_create_infos(std::slice::from_ref(&queue_ci));
        let vk_device = instance
            .create_device(physical_device, &device_ci, None)
            .map_err(|e| format!("vkCreateDevice: {e}"))?;
        let queue = vk_device.get_device_queue(queue_family_index, 0);

        // 5. Command pool + buffer
        let pool_ci = vk::CommandPoolCreateInfo::default()
            .queue_family_index(queue_family_index)
            .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER);