Init

src/render/display.rs

@@ -0,0 +1,3 @@
+pub fn debug(data: &impl std::fmt::Debug) {
+    println!("{:#?}", data);
+}

src/render/mod.rs

@@ -0,0 +1,4 @@
+mod display;
+pub mod vulkan;
+
+pub use display::debug;

src/render/vulkan/mod.rs

@@ -0,0 +1,50 @@
+use vulkano::sync::GpuFuture;
+use vulkano::command_buffer::CommandBuffer;
+use vulkano::command_buffer::AutoCommandBufferBuilder;
+use vulkano::buffer::BufferUsage;
+use vulkano::buffer::CpuAccessibleBuffer;
+use vulkano::device::DeviceExtensions;
+use vulkano::device::Features;
+use vulkano::device::Device;
+use vulkano::instance::PhysicalDevice;
+use vulkano::instance::Instance;
+use vulkano::instance::InstanceExtensions;
+
+pub fn test() {
+    let instance = Instance::new(None, &InstanceExtensions::none(), None)
+                        .expect("Failed to create instance");
+
+    let physical = PhysicalDevice::enumerate(&instance).next().expect("No device available");
+
+    let queue_family = physical.queue_families()
+                            .find(|&q| q.supports_graphics())
+                            .expect("couldn't find a graphical queue family");
+
+    let (device, mut queues) = {
+        Device::new(physical, &Features::none(), &DeviceExtensions::none(),
+                    [(queue_family, 0.5)].iter().cloned()).expect("failed to create device")
+    };
+
+    let queue = queues.next().unwrap();
+
+    let source_content = 0 .. 64;
+    let source = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), false,
+                                            source_content).expect("failed to create buffer");
+
+    let dest_content = (0 .. 64).map(|_| 0);
+    let dest = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), false,
+                                            dest_content).expect("failed to create buffer");
+
+    let mut builder = AutoCommandBufferBuilder::new(device.clone(), queue.family()).unwrap();
+    builder.copy_buffer(source.clone(), dest.clone()).unwrap();
+    let command_buffer = builder.build().unwrap();
+
+    let finished = command_buffer.execute(queue.clone()).unwrap();
+
+    finished.then_signal_fence_and_flush().unwrap()
+                        .wait(None).unwrap();
+
+    let src_content = source.read().unwrap();
+    let dest_content = dest.read().unwrap();
+    assert_eq!(&*src_content, &*dest_content);
+}