fix writing

Author: float3

README.md

@@ -1,31 +1,73 @@
 # vkfetch
 
 this is a rewrite of https://github.com/Wunkolo/vkfetch \
-I referenced the code and took some of the ASCII art from it \
+I referenced the code and copied the ASCII art from it \
 thanks to wunkolo for writing the original \
-I rewrote it because I wanted to have vkfetch on an easy to access package manager \
-I believe we now have feature parity with the original vkfetch
+I rewrote it because I wanted to have vkfetch on an easy to access package manager and wanted to extend it \
+I believe we now have feature parity with the original vkfetch + some extra info not present in the original
 
-# vkfetch-rs
+# installation
 
-you need to have vulkanloader installed
-on nix that's the `vulkanloader` package
-on ubuntu it looks like this:
+## dependencies
 
+### nix
+
+```nix
+  environment.systemPackages = [
+    pkgs.vulkan-loader
+  ];
+```
+
+```sh
+nix-shell -p vulkan-loader
+```
+
+```sh
+nix-env -iA nixos.vulkan-loader
+```
+
+### ubuntu
 
 ```sh
 wget -qO- https://packages.lunarg.com/lunarg-signing-key-pub.asc | sudo tee /etc/apt/trusted.gpg.d/lunarg.asc
 sudo wget -qO /etc/apt/sources.list.d/lunarg-vulkan-noble.list http://packages.lunarg.com/vulkan/lunarg-vulkan-noble.list
 sudo apt update
 sudo apt install vulkan-sdk
 ```
+or
+```sh
+sudo apt update
+sudo apt install vulkan-sdk
+```
+
+### brew
+
+```sh
+brew install vulkan-loader
+```
+
+### other distributions
+
+check your own package managers or
+
+https://vulkan.lunarg.com/sdk/home#linux
+
+
+### windows and mac
+
+https://vulkan.lunarg.com/sdk/home#linux
+
+## vkfetch-rs
+
 
 ```sh
 cargo install vkfetch-rs
 ```
 
 ## build it from source
 
+if you use nix then you can use my flake `nix develop`
+
 ```sh
 git clone https://github.com/float3/vkfetch-rs
 cd vkfetch-rs

flake.nix

@@ -26,6 +26,7 @@
             llvmPackages.bintools
             rustup
             git
+            rustfmt
             vulkan-loader
           ];
 

src/device.rs

@@ -10,7 +10,7 @@ use crate::vendor::Vendor;
 
 /// Represents a physical GPU device.
 #[derive(Debug)]
-pub struct PhysicalDevice {
+pub struct Device {
     pub vendor: Vendor,
     pub device_name: String,
     pub device_type: DeviceType,
@@ -53,7 +53,7 @@ pub struct GPUCharacteristics {
     pub supports_ray_tracing: bool,
 }
 
-impl PhysicalDevice {
+impl Device {
     /// Constructs a new `PhysicalDevice` by querying Vulkan properties.
     pub fn new(instance: &Instance, physical_device: vk::PhysicalDevice) -> Self {
         // Get the core properties and limits.
@@ -214,7 +214,7 @@ impl PhysicalDevice {
             }
         };
 
-        PhysicalDevice {
+        Device {
             vendor,
             device_name,
             device_type,

src/lib.rs

@@ -3,7 +3,7 @@ pub mod device;
 pub mod vendor;
 
 use ash::{self, vk, Entry, Instance};
-use device::PhysicalDevice;
+use device::Device;
 use std::error::Error;
 use vendor::Vendor;
 
@@ -27,14 +27,14 @@ pub fn fetch_device(
         .unwrap_or_else(|| panic!("unknown vendor: {}", properties.vendor_id));
     let art = vendor.get_ascii_art();
 
-    let device = PhysicalDevice::new(instance, device_handle);
+    let device = Device::new(instance, device_handle);
     let info = get_device_info(&device, vendor.get_styles()[0]);
 
-    let x = art.get(0).unwrap().len();
-    let empty = " ".repeat(x);
-
     for i in 0..art.len().max(info.len()) {
-        let art_line = art.get(i).map(String::as_str).unwrap_or(&empty);
+        let art_line = art
+            .get(i)
+            .map(String::as_str)
+            .unwrap_or(r#"                                               "#);
         let info_line = info.get(i).map(String::as_str).unwrap_or(EMPTY);
         println!(" {} {}", art_line, info_line);
     }
@@ -46,7 +46,7 @@ pub fn fetch_device(
 /// Returns a vector of formatted strings representing the device info,
 /// including extra vendor-specific and general device limits.
 /// Lines for optional fields are only included if available.
-fn get_device_info(device: &PhysicalDevice, color: &str) -> Vec<String> {
+fn get_device_info(device: &Device, color: &str) -> Vec<String> {
     let mut lines = Vec::new();
 
     let title = format!(
@@ -188,39 +188,18 @@ fn get_device_info(device: &PhysicalDevice, color: &str) -> Vec<String> {
                 .into()
         )
     ));
+
+    let checkbox = |b: bool| if b { "[x]" } else { "[ ]" };
+    let x = checkbox(device.characteristics.supports_ray_tracing);
+    let y = checkbox(device.characteristics.dedicated_transfer_queue);
+    let z = checkbox(device.characteristics.dedicated_async_compute_queue);
+
     lines.push(format!(
-        "{} | {} | {}",
-        format!(
-            "{}{}Raytracing{}: {}",
-            ALIGNMENT,
-            color,
-            RESET,
-            if device.characteristics.supports_ray_tracing {
-                "[x]"
-            } else {
-                "[ ]"
-            },
-        ),
-        format!(
-            "{}Dedicated Transfer Queue{}: {}",
-            color,
-            RESET,
-            if device.characteristics.supports_ray_tracing {
-                "[x]"
-            } else {
-                "[ ]"
-            },
-        ),
-        format!(
-            "{}Dedicated Async Compute Queue{}: {}",
-            color,
-            RESET,
-            if device.characteristics.supports_ray_tracing {
-                "[x]"
-            } else {
-                "[ ]"
-            },
-        ),
+        "{}{}Raytracing{}: {} | {}Dedicated Transfer Queue{}: {} | {}Dedicated Async Compute Queue{}: {}",
+        ALIGNMENT,
+        color, RESET, x,
+        color, RESET, y,
+        color, RESET, z,
     ));
 
     lines
@@ -247,7 +226,7 @@ fn format_bytes(bytes: u64) -> String {
 }
 
 /// Iterates through API versions and prints info for every physical device
-pub fn iterate_devices() {
+pub fn iterate_devices() -> Result<(), Box<dyn Error>> {
     let entry = {
         #[cfg(not(feature = "loaded"))]
         {
@@ -259,7 +238,7 @@ pub fn iterate_devices() {
                 Ok(entry) => entry,
                 Err(e) => {
                     eprintln!("Failed to load entry: {:?}", e);
-                    return;
+                    return Ok(());
                 }
             }
         }
@@ -277,32 +256,32 @@ pub fn iterate_devices() {
         };
         let create_info = vk::InstanceCreateInfo::default().application_info(&app_info);
 
-        let instance = match unsafe { entry.create_instance(&create_info, None) } {
-            Ok(instance) => instance,
+        match unsafe { entry.create_instance(&create_info, None) } {
+            Ok(instance) => match unsafe { instance.enumerate_physical_devices() } {
+                Ok(devices) => {
+                    for device in devices {
+                        fetch_device(&instance, device)?;
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Failed to enumerate physical devices: {:?}", e);
+                }
+            },
             Err(e) => {
                 eprintln!("Failed to create instance: {:?}", e);
                 continue;
             }
         };
 
-        match unsafe { instance.enumerate_physical_devices() } {
-            Ok(devices) => {
-                for device in devices {
-                    fetch_device(&instance, device);
-                }
-            }
-            Err(e) => {
-                eprintln!("Failed to enumerate physical devices: {:?}", e);
-            }
-        }
         break;
     }
+    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::device::{GPUCharacteristics, PhysicalDevice};
+    use crate::device::{Device, GPUCharacteristics};
     use crate::vendor::Vendor;
 
     /// For testing purposes we use the Unknown vendor variant.
@@ -313,8 +292,8 @@ mod tests {
     }
 
     /// Creates a dummy PhysicalDevice instance for tests.
-    fn dummy_physical_device() -> PhysicalDevice {
-        PhysicalDevice {
+    fn dummy_physical_device() -> Device {
+        Device {
             vendor: Vendor::dummy(),
             device_name: "TestDevice".to_string(),
             device_type: crate::device::DeviceType::DiscreteGPU,

src/main.rs

@@ -13,7 +13,7 @@ fn main() {
     // let vendor = vkfetch_rs::vendor::Vendor::AMD;
     // debug(vendor.get_ascii_art());
 
-    iterate_devices()
+    iterate_devices().unwrap()
 }
 
 // fn debug(x: Vec<String>) {