Inital commit

src/main.rs

@@ -0,0 +1,122 @@
+use std::sync::Arc;
+
+use vulkano::command_buffer::{AutoCommandBufferBuilder, CommandBufferUsage, CopyBufferInfo, PrimaryAutoCommandBuffer};
+use vulkano::command_buffer::allocator::{StandardCommandBufferAllocator, StandardCommandBufferAllocatorCreateInfo};
+use vulkano::sync::GpuFuture;
+use vulkano::{VulkanLibrary, buffer, sync};
+use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage};
+use vulkano::instance::{Instance, InstanceCreateFlags, InstanceCreateInfo};
+use vulkano::device::{Device, DeviceCreateInfo, QueueFlags, QueueCreateInfo};
+use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator};
+
+fn main() {
+    let library = VulkanLibrary::new().expect("No Vulkan Available");
+    let instance = Instance::new(
+        library, 
+        InstanceCreateInfo { 
+            flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
+            ..Default::default()        
+        }
+    ).expect("Failed to initialize Vulkan instance");
+
+    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);
+    }
+
+    let queue_family_index = physical_device
+        .queue_family_properties()
+        .iter()
+        .position(|queue_family_properties| {
+            queue_family_properties.queue_flags.contains(QueueFlags::GRAPHICS)
+        })
+        .expect("couldn't find a graphical queue family") as u32;
+
+    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();
+
+    let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));
+
+    /*let data: i32 = 12;
+
+    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");*/
+
+    let source_content = 0..64;
+    let source = Buffer::from_iter(
+        memory_allocator.clone(), 
+        BufferCreateInfo { 
+            usage: BufferUsage::TRANSFER_SRC,
+            ..Default::default()
+        }, 
+        AllocationCreateInfo { 
+            memory_type_filter: MemoryTypeFilter::PREFER_HOST|MemoryTypeFilter::HOST_RANDOM_ACCESS, 
+            ..Default::default()
+        }, 
+        source_content
+    ).expect("Failed to create source buffer");
+
+    let destination_content = (0..64).map(|_| 0);
+    let destination = Buffer::from_iter(
+        memory_allocator.clone(),
+        BufferCreateInfo { 
+            usage: BufferUsage::TRANSFER_DST, 
+            ..Default::default()
+        },
+        AllocationCreateInfo { 
+            memory_type_filter: MemoryTypeFilter::PREFER_HOST|MemoryTypeFilter::HOST_RANDOM_ACCESS, 
+            ..Default::default()
+        },
+        destination_content
+    ).expect("Failed to create destination buffer");
+
+    let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
+        device.clone(), 
+        StandardCommandBufferAllocatorCreateInfo::default()
+    ));
+
+    let mut builder = AutoCommandBufferBuilder::primary(command_buffer_allocator.clone(), queue_family_index, CommandBufferUsage::OneTimeSubmit).unwrap();
+    builder.copy_buffer(CopyBufferInfo::buffers(source.clone(), destination.clone())).unwrap();
+
+    let command_buffer = builder.build().unwrap();
+
+    //sync::now(device.clone()).then_execute(queue.clone(), command_buffer).unwrap().flush().unwrap();
+
+    let future = sync::now(device.clone()).then_execute(queue.clone(), command_buffer).unwrap().then_signal_fence_and_flush().unwrap();
+    future.wait(None).unwrap();
+
+    let src_content = source.read().unwrap();
+    let dst_content = destination.read().unwrap();
+
+    assert_eq!(&*src_content, &*dst_content);
+
+    println!("Success!");
+
+}

src/shader.glsl

@@ -0,0 +1,12 @@
+#version 460
+
+layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in
+
+layout(set = 0, binding = 0) buffer Data{
+    uint data[];
+} buf;
+
+void main() {
+    uint idx = gl_GlobalInvocationID.x;
+    buf.data[idx] *= 12;
+}