brogress

flake.nix

@@ -22,24 +22,13 @@
           packages = builtins.attrValues {
             inherit
               (pkgs)
-              libxkbcommon
-              libGL
               wayland
-              SDL2
-              SDL2_ttf
-              boost
-              cmake
-              catch2
-              glm
-              gcc
-              pkg-config
               cargo
-              glfw3
+              bacon
-              mesa
+              clippy
-              glslang
+              rustfmt
-              renderdoc
+              rust-analyzer
-              spirv-tools
+
-              vulkan-volk
               vulkan-tools
               vulkan-loader
               vulkan-headers

src/main.rs

@@ -1,8 +1,11 @@
 #![allow(unused)]
+use std::sync::Arc;
+
 fn main() {
     use vulkano::VulkanLibrary;
     use vulkano::instance::{Instance, InstanceCreateFlags, InstanceCreateInfo};
 
+    // An instance specifies the mapping between vulkano and the local Vulkan library.
     let library = VulkanLibrary::new().expect("no local Vulkan library/DLL");
     let instance = Instance::new(
         library,
@@ -12,4 +15,92 @@ fn main() {
         },
     )
     .expect("failed to create instance");
+
+    // get the physical device to run vulcan on
+    let physical_device = instance
+        .enumerate_physical_devices()
+        .expect("could not enumerate devices")
+        .next()
+        .expect("no devices available");
+    for family in physical_device.queue_family_properties() {
+        println!(
+            "Found a queue family with {:?} queue(s)",
+            family.queue_count
+        );
+        use vulkano::device::QueueFlags;
+
+        let queue_family_index = physical_device
+            .queue_family_properties()
+            .iter()
+            .enumerate()
+            .position(|(_queue_family_index, queue_family_properties)| {
+                queue_family_properties
+                    .queue_flags
+                    .contains(QueueFlags::GRAPHICS)
+            })
+            .expect("couldn't find a graphical queue family")
+            as u32;
+    }
+
+    use vulkano::device::QueueFlags;
+
+    let queue_family_index = physical_device
+        .queue_family_properties()
+        .iter()
+        .enumerate()
+        .position(|(_queue_family_index, queue_family_properties)| {
+            queue_family_properties
+                .queue_flags
+                .contains(QueueFlags::GRAPHICS)
+        })
+        .expect("couldn't find a graphical queue family") as u32;
+
+    use vulkano::device::{Device, DeviceCreateInfo, QueueCreateInfo};
+
+    let (device, mut queues) = Device::new(
+        physical_device,
+        DeviceCreateInfo {
+            // here we pass the desired queue family to use by index
+            queue_create_infos: vec![QueueCreateInfo {
+                queue_family_index,
+                ..Default::default()
+            }],
+            ..Default::default()
+        },
+    )
+    .expect("failed to create device");
+
+    let queue = queues.next().unwrap();
+
+    use vulkano::memory::allocator::StandardMemoryAllocator;
+
+    let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
+
+    use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage};
+    use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter};
+
+    use vulkano::buffer::BufferContents;
+
+    #[derive(BufferContents)]
+    #[repr(C)]
+    struct MyStruct {
+        a: u32,
+        b: u32,
+    }
+
+    let data = MyStruct { a: 5, b: 69 };
+    let buffer = Buffer::from_data(
+        memory_allocator.clone(),
+        BufferCreateInfo {
+            usage: BufferUsage::UNIFORM_BUFFER,
+            ..Default::default()
+        },
+        AllocationCreateInfo {
+            memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
+                | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+            ..Default::default()
+        },
+        data,
+    )
+    .expect("failed to create buffer");
 }