new architecture

crates/gfx_hal/src/device.rs

@@ -0,0 +1,223 @@
+use ash::vk;
+use parking_lot::Mutex;
+use std::ffi::CStr;
+use std::{collections::HashMap, sync::Arc};
+
+use crate::error::{GfxHalError, Result};
+use crate::instance::Instance;
+use crate::physical_device::{PhysicalDevice, QueueFamilyIndices};
+use crate::queue::Queue;
+
+/// Represents the logical Vulkan device, created from a `PhysicalDevice`.
+///
+/// Owns the `ash::Device` and provides access to device functions and queues.
+pub struct Device {
+    instance: Arc<Instance>,
+    physical_device: vk::PhysicalDevice,
+    device: ash::Device,
+    queues: Mutex<HashMap<(u32, u32), Arc<Queue>>>,
+    graphics_queue_family_index: u32,
+    compute_queue_family_index: Option<u32>,
+    transfer_queue_family_index: Option<u32>,
+}
+
+impl Device {
+    /// Creates a new logical device. Typically called via `PhysicalDevice::create_logical_device`.
+    ///
+    /// # Saftey
+    /// - `instance` and `physical_device_handle` must be valid.
+    /// - `queue_family_indicies` must be valid indicies obtained from the `physical_device_handle`.
+    /// - `required_extensions` must be supported by the `physical_device_handle`.
+    /// - `enabled_features` and `mesh_features` must be supported by the `physical_device_handle`.
+    pub(crate) unsafe fn new(
+        instance: Arc<Instance>,
+        physical_device_handle: vk::PhysicalDevice,
+        queue_family_indicies: &QueueFamilyIndices,
+        required_extensions: &[&CStr],
+        enabled_features: &vk::PhysicalDeviceFeatures,
+        mesh_features: Option<&vk::PhysicalDeviceMeshShaderFeaturesEXT>,
+    ) -> Result<Arc<Self>> {
+        let mut queue_create_infos = Vec::new();
+        let mut unique_queue_families = std::collections::HashSet::new();
+
+        let graphics_family = queue_family_indicies.graphics_family.ok_or_else(|| {
+            GfxHalError::MissingQueueFamily("Graphics Queue Family Missing".to_string())
+        })?;
+        unique_queue_families.insert(graphics_family);
+
+        if let Some(compute_family) = queue_family_indicies.compute_family {
+            unique_queue_families.insert(compute_family);
+        }
+        if let Some(transfer_family) = queue_family_indicies.transfer_family {
+            unique_queue_families.insert(transfer_family);
+        }
+
+        let queue_priorities = [1.0f32];
+        for &family_index in &unique_queue_families {
+            let queue_create_info = vk::DeviceQueueCreateInfo::default()
+                .queue_family_index(family_index)
+                .queue_priorities(&queue_priorities);
+            queue_create_infos.push(queue_create_info);
+        }
+
+        let extension_names_raw: Vec<*const i8> =
+            required_extensions.iter().map(|s| s.as_ptr()).collect();
+
+        let mut features2 = vk::PhysicalDeviceFeatures2::default().features(*enabled_features);
+        let mut mesh_features_copy;
+
+        if let Some(mesh_feats) = mesh_features {
+            mesh_features_copy = *mesh_feats;
+            features2 = features2.push_next(&mut mesh_features_copy);
+        }
+
+        let device_create_info = vk::DeviceCreateInfo::default()
+            .queue_create_infos(&queue_create_infos)
+            .enabled_extension_names(&extension_names_raw)
+            .push_next(&mut features2);
+
+        tracing::info!(
+            "Creating logical device with extensions: {:?}",
+            required_extensions
+        );
+        let device = instance.ash_instance().create_device(
+            physical_device_handle,
+            &device_create_info,
+            None,
+        )?;
+        tracing::info!("logical device created successfully.");
+
+        let mut queues_map = HashMap::new();
+        let arc_device_placeholder = Arc::new(Self {
+            instance,
+            physical_device: physical_device_handle,
+            device,
+            queues: Mutex::new(HashMap::new()),
+            graphics_queue_family_index: graphics_family,
+            compute_queue_family_index: queue_family_indicies.compute_family,
+            transfer_queue_family_index: queue_family_indicies.transfer_family,
+        });
+
+        for &family_index in &unique_queue_families {
+            let queue_handler = arc_device_placeholder
+                .device
+                .get_device_queue(family_index, 0);
+            let queue_wrapper = Arc::new(Queue::new(
+                Arc::clone(&arc_device_placeholder),
+                queue_handler,
+                family_index,
+            ));
+            queues_map.insert((family_index, 0), queue_wrapper);
+        }
+
+        let device_handle = unsafe {
+            arc_device_placeholder
+                .instance
+                .ash_instance()
+                .create_device(physical_device_handle, &device_create_info, None)?
+        };
+
+        let final_device = Arc::new(Self {
+            instance: Arc::clone(&arc_device_placeholder.instance), // Clone from placeholder
+            physical_device: physical_device_handle,
+            device: device_handle,          // Use the newly created handle
+            queues: Mutex::new(queues_map), // Use the populated map
+            graphics_queue_family_index: graphics_family,
+            compute_queue_family_index: queue_family_indicies.compute_family,
+            transfer_queue_family_index: queue_family_indicies.transfer_family,
+        });
+
+        Ok(final_device)
+    }
+
+    /// Provides raw access to the underlying `ash::Device`.
+    /// Use with caution, prefer safe wrappers where possible.
+    pub fn raw(&self) -> &ash::Device {
+        &self.device
+    }
+
+    /// Gets the handle of the physical device this logical device was created from.
+    pub fn physical_device_handle(&self) -> vk::PhysicalDevice {
+        self.physical_device
+    }
+
+    /// Gets the primary graphics queue family index used by this device.
+    pub fn graphics_queue_family_index(&self) -> u32 {
+        self.graphics_queue_family_index
+    }
+
+    /// Gets the compute queue family index, if a distinct one was found/used.
+    pub fn compute_queue_family_index(&self) -> Option<u32> {
+        self.compute_queue_family_index
+    }
+
+    /// Gets the transfer queue family index, if a distinct one was found/used.
+    pub fn transfer_queue_family_index(&self) -> Option<u32> {
+        self.transfer_queue_family_index
+    }
+
+    /// Gets a wrapped queue handle.
+    /// Currently only supports queue index 0 for each family.
+    pub fn get_queue(&self, family_index: u32, queue_index: u32) -> Option<Arc<Queue>> {
+        if queue_index != 0 {
+            tracing::warn!("get_queue currently only supports queue_index 0");
+            return None;
+        }
+        self.queues
+            .lock()
+            .get(&(family_index, queue_index))
+            .cloned()
+    }
+
+    /// Gets the primary graphics queue (family index from `graphics_queue_family_index`, queue index 0).
+    /// Panics if the graphics queue wasn't successfully created.
+    pub fn get_graphics_queue(&self) -> Arc<Queue> {
+        self.get_queue(self.graphics_queue_family_index, 0)
+            .expect("Graphics queue should always exist")
+    }
+
+    /// Waits until the logical device becomes idle.
+    /// This is a heavy operation and should be used sparingly (e.g., before destruction).
+    pub fn wait_idle(&self) -> Result<()> {
+        tracing::debug!("Waiting for device idle...");
+        unsafe { self.device.device_wait_idle()? };
+        tracing::debug!("Device idle.");
+        Ok(())
+    }
+}
+
+impl Drop for Device {
+    fn drop(&mut self) {
+        tracing::debug!("Destroying logical device...");
+        if let Err(e) = self.wait_idle() {
+            tracing::error!("Error waiting for device idle during drop: {}", e);
+        }
+        unsafe {
+            self.device.destroy_device(None);
+        }
+        tracing::debug!("Logical device destroyed.");
+    }
+}
+
+impl PhysicalDevice {
+    /// Creates the logical device (`Device`) from this physical device.
+    ///
+    /// # Safety
+    /// See `Device::new` safety comments.
+    pub unsafe fn create_logical_device(
+        &self,
+        required_extensions: &[&CStr],
+        queue_family_indices: &QueueFamilyIndices,
+        enabled_features: &vk::PhysicalDeviceFeatures,
+        mesh_features: Option<&vk::PhysicalDeviceMeshShaderFeaturesEXT>,
+    ) -> Result<Arc<Device>> {
+        Device::new(
+            Arc::clone(self.instance()),
+            self.handle(),
+            queue_family_indices,
+            required_extensions,
+            enabled_features,
+            mesh_features,
+        )
+    }
+}