From 3bfd84544e0ce61579ea9d3238ae654f0fe27d8a Mon Sep 17 00:00:00 2001 From: tomaka Date: Sat, 5 Aug 2017 10:32:14 +0200 Subject: [PATCH] Add the triangle guide example (#720) --- examples/src/bin/guide-triangle.rs | 173 +++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) create mode 100644 examples/src/bin/guide-triangle.rs diff --git a/examples/src/bin/guide-triangle.rs b/examples/src/bin/guide-triangle.rs new file mode 100644 index 00000000..4b9d9f2c --- /dev/null +++ b/examples/src/bin/guide-triangle.rs @@ -0,0 +1,173 @@ +// Copyright (c) 2017 The vulkano developers +// Licensed under the Apache License, Version 2.0 +// or the MIT +// license , +// 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_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::, _>::from_raw(1024, 1024, &buffer_content[..]).unwrap(); + image.save("triangle.png").unwrap(); +}