18_vertex_buffer.rs.diff

--- a/16_swap_chain_recreation.rs
+++ b/18_vertex_buffer.rs
@@ -35,8 +35,7 @@ use vulkano::image::{ImageUsage, swapchain::SwapchainImage};
 use vulkano::sync::{self, SharingMode, GpuFuture};
 use vulkano::pipeline::{
     GraphicsPipeline,
-    vertex::BufferlessDefinition,
-    vertex::BufferlessVertices,
+    GraphicsPipelineAbstract,
     viewport::Viewport,
 };
 use vulkano::framebuffer::{
@@ -45,12 +44,16 @@ use vulkano::framebuffer::{
     FramebufferAbstract,
     Framebuffer,
 };
-use vulkano::descriptor::PipelineLayoutAbstract;
 use vulkano::command_buffer::{
     AutoCommandBuffer,
     AutoCommandBufferBuilder,
     DynamicState,
 };
+use vulkano::buffer::{
+    cpu_access::CpuAccessibleBuffer,
+    BufferUsage,
+    BufferAccess,
+};
 
 const WIDTH: u32 = 800;
 const HEIGHT: u32 = 600;
@@ -86,7 +89,25 @@ impl QueueFamilyIndices {
     }
 }
 
-type ConcreteGraphicsPipeline = GraphicsPipeline<BufferlessDefinition, Box<PipelineLayoutAbstract + Send + Sync + 'static>, Arc<RenderPassAbstract + Send + Sync + 'static>>;
+#[derive(Copy, Clone)]
+struct Vertex {
+    pos: [f32; 2],
+    color: [f32; 3],
+}
+impl Vertex {
+    fn new(pos: [f32; 2], color: [f32; 3]) -> Self {
+        Self { pos, color }
+    }
+}
+impl_vertex!(Vertex, pos, color);
+
+fn vertices() -> [Vertex; 3] {
+    [
+        Vertex::new([0.0, -0.5], [1.0, 1.0, 1.0]),
+        Vertex::new([0.5, 0.5], [0.0, 1.0, 0.0]),
+        Vertex::new([-0.5, 0.5], [0.0, 0.0, 1.])
+    ]
+}
 
 struct HelloTriangleApplication {
     instance: Arc<Instance>,
@@ -106,14 +127,11 @@ struct HelloTriangleApplication {
     swap_chain_images: Vec<Arc<SwapchainImage<Window>>>,
 
     render_pass: Arc<RenderPassAbstract + Send + Sync>,
-    // NOTE: We need to the full type of
-    // self.graphics_pipeline, because `BufferlessVertices` only
-    // works when the concrete type of the graphics pipeline is visible
-    // to the command buffer.
-    graphics_pipeline: Arc<ConcreteGraphicsPipeline>,
+    graphics_pipeline: Arc<GraphicsPipelineAbstract + Send + Sync>,
 
     swap_chain_framebuffers: Vec<Arc<FramebufferAbstract + Send + Sync>>,
 
+    vertex_buffer: Arc<BufferAccess + Send + Sync>,
     command_buffers: Vec<Arc<AutoCommandBuffer>>,
 
     previous_frame_end: Option<Box<GpuFuture>>,
@@ -138,6 +156,8 @@ impl HelloTriangleApplication {
 
         let swap_chain_framebuffers = Self::create_framebuffers(&swap_chain_images, &render_pass);
 
+        let vertex_buffer = Self::create_vertex_buffer(&device);
+
         let previous_frame_end = Some(Self::create_sync_objects(&device));
 
         let mut app = Self {
@@ -161,6 +181,7 @@ impl HelloTriangleApplication {
 
             swap_chain_framebuffers,
 
+            vertex_buffer,
             command_buffers: vec![],
 
             previous_frame_end,
@@ -367,18 +388,18 @@ impl HelloTriangleApplication {
         device: &Arc<Device>,
         swap_chain_extent: [u32; 2],
         render_pass: &Arc<RenderPassAbstract + Send + Sync>,
-    ) -> Arc<ConcreteGraphicsPipeline> {
+    ) -> Arc<GraphicsPipelineAbstract + Send + Sync> {
         mod vertex_shader {
             vulkano_shaders::shader! {
                ty: "vertex",
-               path: "src/bin/09_shader_base.vert"
+               path: "src/bin/17_shader_vertexbuffer.vert"
             }
         }
 
         mod fragment_shader {
             vulkano_shaders::shader! {
                 ty: "fragment",
-                path: "src/bin/09_shader_base.frag"
+                path: "src/bin/17_shader_vertexbuffer.frag"
             }
         }
 
@@ -395,7 +416,7 @@ impl HelloTriangleApplication {
         };
 
         Arc::new(GraphicsPipeline::start()
-            .vertex_input(BufferlessDefinition {})
+            .vertex_input_single_buffer::<Vertex>()
             .vertex_shader(vert_shader_module.main_entry_point(), ())
             .triangle_list()
             .primitive_restart(false)
@@ -429,17 +450,21 @@ impl HelloTriangleApplication {
         ).collect::<Vec<_>>()
     }
 
+    fn create_vertex_buffer(device: &Arc<Device>) -> Arc<BufferAccess + Send + Sync> {
+        CpuAccessibleBuffer::from_iter(device.clone(),
+            BufferUsage::vertex_buffer(), vertices().iter().cloned()).unwrap()
+    }
+
     fn create_command_buffers(&mut self) {
         let queue_family = self.graphics_queue.family();
         self.command_buffers = self.swap_chain_framebuffers.iter()
             .map(|framebuffer| {
-                let vertices = BufferlessVertices { vertices: 3, instances: 1 };
                 Arc::new(AutoCommandBufferBuilder::primary_simultaneous_use(self.device.clone(), queue_family)
                     .unwrap()
                     .begin_render_pass(framebuffer.clone(), false, vec![[0.0, 0.0, 0.0, 1.0].into()])
                     .unwrap()
                     .draw(self.graphics_pipeline.clone(), &DynamicState::none(),
-                        vertices, (), ())
+                        vec![self.vertex_buffer.clone()], (), ())
                     .unwrap()
                     .end_render_pass()
                     .unwrap()