Add the triangle guide example (#720)

examples/src/bin/guide-triangle.rs

@@ -0,0 +1,173 @@
+// Copyright (c) 2017 The vulkano developers
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+// license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+
+//! This example contains the source code of the fourth part of the guide at http://vulkano.rs.
+//!
+//! It is not commented, as the explanations can be found in the guide itself.
+
+extern crate image;
+#[macro_use]
+extern crate vulkano;
+#[macro_use]
+extern crate vulkano_shader_derive;
+
+use std::sync::Arc;
+use image::ImageBuffer;
+use image::Rgba;
+use vulkano::buffer::BufferUsage;
+use vulkano::buffer::CpuAccessibleBuffer;
+use vulkano::command_buffer::AutoCommandBufferBuilder;
+use vulkano::command_buffer::CommandBuffer;
+use vulkano::command_buffer::DynamicState;
+use vulkano::device::Device;
+use vulkano::device::DeviceExtensions;
+use vulkano::format::Format;
+use vulkano::framebuffer::Framebuffer;
+use vulkano::framebuffer::Subpass;
+use vulkano::image::Dimensions;
+use vulkano::image::StorageImage;
+use vulkano::instance::Features;
+use vulkano::instance::Instance;
+use vulkano::instance::InstanceExtensions;
+use vulkano::instance::PhysicalDevice;
+use vulkano::pipeline::GraphicsPipeline;
+use vulkano::pipeline::viewport::Viewport;
+use vulkano::sync::GpuFuture;
+
+fn main() {
+    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 image = StorageImage::new(device.clone(), Dimensions::Dim2d { width: 1024, height: 1024 },
+                                  Format::R8G8B8A8Unorm, Some(queue.family())).unwrap();
+
+    let buf = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(),
+                                             Some(queue.family()),
+                                             (0 .. 1024 * 1024 * 4).map(|_| 0u8))
+                                             .expect("failed to create buffer");
+
+    #[derive(Copy, Clone)]
+    struct Vertex {
+        position: [f32; 2],
+    }
+    impl_vertex!(Vertex, position);
+    let vertex1 = Vertex { position: [-0.5, -0.5] };
+    let vertex2 = Vertex { position: [ 0.0,  0.5] };
+    let vertex3 = Vertex { position: [ 0.5, -0.25] };
+    let vertex_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(),
+                                                    Some(queue.family()),
+                                                    vec![vertex1, vertex2, vertex3].into_iter()).unwrap();
+                                                    
+    let render_pass = Arc::new(single_pass_renderpass!(device.clone(),
+        attachments: {
+            color: {
+                load: Clear,
+                store: Store,
+                format: Format::R8G8B8A8Unorm,
+                samples: 1,
+            }
+        },
+        pass: {
+            color: [color],
+            depth_stencil: {}
+        }
+    ).unwrap());
+
+    let framebuffer = Arc::new(Framebuffer::start(render_pass.clone())
+        .add(image.clone()).unwrap()
+        .build().unwrap());
+
+    mod vs {
+        #[derive(VulkanoShader)]
+        #[ty = "vertex"]
+        #[src = "
+    #version 450
+
+    layout(location = 0) in vec2 position;
+
+    void main() {
+        gl_Position = vec4(position, 0.0, 1.0);
+    }
+    "]
+        struct Dummy;
+    }
+
+    mod fs {
+        #[derive(VulkanoShader)]
+        #[ty = "fragment"]
+        #[src = "
+    #version 450
+
+    layout(location = 0) out vec4 f_color;
+
+    void main() {
+        f_color = vec4(1.0, 0.0, 0.0, 1.0);
+    }
+    "]
+        struct Dummy;
+    }
+
+    let vs = vs::Shader::load(device.clone()).expect("failed to create shader module");
+    let fs = fs::Shader::load(device.clone()).expect("failed to create shader module");
+    
+    let pipeline = Arc::new(GraphicsPipeline::start()
+        .vertex_input_single_buffer::<Vertex>()
+        .vertex_shader(vs.main_entry_point(), ())
+        .viewports_dynamic_scissors_irrelevant(1)
+        .fragment_shader(fs.main_entry_point(), ())
+        .render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
+        .build(device.clone())
+        .unwrap());
+
+    let dynamic_state = DynamicState {
+        viewports: Some(vec![Viewport {
+            origin: [0.0, 0.0],
+            dimensions: [1024.0, 1024.0],
+            depth_range: 0.0 .. 1.0,
+        }]),
+        .. DynamicState::none()
+    };
+
+    let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap()
+        .begin_render_pass(framebuffer.clone(), false, vec![[0.0, 0.0, 1.0, 1.0].into()])
+        .unwrap()
+
+        .draw(pipeline.clone(), dynamic_state, vertex_buffer.clone(), (), ())
+        .unwrap()
+
+        .end_render_pass()
+        .unwrap()
+
+        .copy_image_to_buffer(image.clone(), buf.clone())
+        .unwrap()
+
+        .build()
+        .unwrap();
+
+    let finished = command_buffer.execute(queue.clone()).unwrap();
+    finished.then_signal_fence_and_flush().unwrap()
+        .wait(None).unwrap();
+
+    let buffer_content = buf.read().unwrap();
+    let image = ImageBuffer::<Rgba<u8>, _>::from_raw(1024, 1024, &buffer_content[..]).unwrap();
+    image.save("triangle.png").unwrap();
+}