[ll][render] encoder.draw draft

examples/render/quad_render/main.rs

@@ -7,14 +7,13 @@ extern crate gfx_backend_vulkan as back;
 extern crate winit;
 extern crate image;
 
-use std::mem;
 use std::io::Cursor;
 
 use core::{command, device as d, image as i, pso, state};
 use core::{Adapter, Device, Instance, Primitive};
 use gfx::format::{Srgba8 as ColorFormat};
 use core::target::Rect;
-use gfx::pso::{Descriptors, GraphicsPipelineMeta};
+use gfx::pso::Descriptors;
 use gfx::allocators::StackAllocator as Allocator;
 
 gfx_buffer_struct! {
@@ -34,16 +33,16 @@ const QUAD: [Vertex; 6] = [
     Vertex { a_Pos: [ -0.5,-0.33 ], a_Uv: [0.0, 0.0] },
 ];
 
-gfx_descriptor_struct! {
-    SampleDesc {
+gfx_descriptors! {
+    desc {
         sampled_image: gfx::pso::SampledImage,
         sampler: gfx::pso::Sampler,
     }
 }
 
 gfx_graphics_pipeline! {
     pipe {
-        sample: gfx::pso::DescriptorSet<SampleDesc<B>>, // TODO remove <B>
+        desc: gfx::pso::DescriptorSet<desc::Set<B>>, // TODO: improve
         color: gfx::pso::RenderTarget<ColorFormat>,
         vertices: gfx::pso::VertexBuffer<Vertex>,
     }
@@ -81,9 +80,9 @@ fn main() {
     let vs_module = device.create_shader_module(include_bytes!("data/vs_main.spv")).unwrap();
     let fs_module = device.create_shader_module(include_bytes!("data/ps_main.spv")).unwrap();
 
-    let sample_desc = context.mut_device().create_descriptors(1).pop().unwrap();
+    let (desc, mut desc_data) = context.mut_device().create_descriptors(1).pop().unwrap();
     let pipe_init = pipe::Init {
-        sample: &sample_desc,
+        desc: &desc,
         color: pso::ColorInfo {
             mask: state::MASK_ALL,
             color: Some(state::BlendChannel {
@@ -120,7 +119,7 @@ fn main() {
     }).collect::<Vec<_>>();
     let framebuffers = frame_rtvs.iter().map(|rtv| {
         let extent = d::Extent { width: pixel_width as _, height: pixel_height as _, depth: 1 };
-        device.create_framebuffer(pipeline.render_pass(), &[rtv.resource()], &[], extent)
+        context.mut_device().create_framebuffer(&pipeline, &[&rtv], &[], extent)
     }).collect::<Vec<_>>();
 
     let mut upload = Allocator::new(
@@ -196,8 +195,8 @@ fn main() {
     );
 
     context.mut_device().update_descriptor_sets()
-        .write(sample_desc.sampled_image(), 0, vec![&image_srv])
-        .write(sample_desc.sampler(), 0, vec![&sampler])
+        .write(desc_data.sampled_image(&desc), 0, &[&image_srv as _])
+        .write(desc_data.sampler(&desc), 0, &[&sampler as _])
         .finish();
 
     // Rendering setup
@@ -259,37 +258,23 @@ fn main() {
         let mut encoder_pool = context.acquire_encoder_pool();
         let mut encoder = encoder_pool.acquire_encoder();
 
-        // Rendering
         {
-            let cmd_buffer = encoder.mut_buffer();
-
-            cmd_buffer.set_viewports(&[viewport]);
-            cmd_buffer.set_scissors(&[scissor]);
-            cmd_buffer.bind_graphics_pipeline(pipeline.pipeline());
-            // TODO: data instead of upload ?
-            // TODO: vertex access ?
-            cmd_buffer.bind_vertex_buffers(pso::VertexBufferSet(vec![(vertex_buffer.resource(), 0)]));
-            cmd_buffer.bind_graphics_descriptor_sets(pipeline.layout(), 0, &[&sample_desc.set()]); // TODO
-
-            {
-                let mut encoder = cmd_buffer.begin_renderpass_inline(
-                    pipeline.render_pass(),
-                    &framebuffers[frame.id()],
-                    Rect { x: 0, y: 0, w: pixel_width, h: pixel_height },
-                    &[command::ClearValue::Color(command::ClearColor::Float([0.8, 0.8, 0.8, 1.0]))],
-                );
-                encoder.draw(0..6, 0..1);
-            }
+            let data = pipe::Data {
+                desc: (&desc, &desc_data),
+                color: &frame_rtvs[frame.id()],
+                vertices: &vertex_buffer,
+                viewports: &[viewport],
+                scissors: &[scissor],
+                framebuffer: &framebuffers[frame.id()],
+            };
+            encoder.draw(0..6, &pipeline, data);
         }
 
         submits.push(encoder.finish());
-        context.present(mem::replace(&mut submits, Vec::new()));
+        context.present(submits.drain(..).collect::<Vec<_>>());
     }
 
     println!("cleanup!");
     device.destroy_shader_module(vs_module);
     device.destroy_shader_module(fs_module);
-    for framebuffer in framebuffers {
-        device.destroy_framebuffer(framebuffer);
-    }
 }

src/backend/gl/src/native.rs

@@ -88,11 +88,8 @@ pub struct DescriptorSetLayout;
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct DescriptorSet;
 
-<<<<<<< HEAD
 #[allow(missing_copy_implementations)]
 #[derive(Debug)]
-=======
->>>>>>> 5495511ec01856d486eb3b7cbf2d4c3a9bb49244
 pub struct DescriptorPool {}
 
 impl core::DescriptorPool<Backend> for DescriptorPool {

src/render/src/allocators/stack.rs

@@ -1,6 +1,7 @@
 use std::sync::mpsc;
+use std::collections::HashMap;
 
-use core::{self, Device as CoreDevice};
+use core::{self, MemoryType, Device as CoreDevice};
 use core::memory::Requirements;
 use memory::{self, Allocator, Memory, ReleaseFn, Provider, Dependency};
 use {buffer, image};
@@ -11,10 +12,9 @@ pub struct StackAllocator<B: Backend>(Provider<InnerStackAllocator<B>>);
 pub struct InnerStackAllocator<B: Backend> {
     device: B::Device,
     usage: memory::Usage,
-    // TODO: Any support ?
-    buffers: ChunkStack<B>,
-    images: ChunkStack<B>,
-    targets: ChunkStack<B>,
+    // stacks by memory type
+    // TODO: VecMap ?
+    stacks: HashMap<usize, ChunkStack<B>>,
     chunk_size: u64,
 }
 
@@ -38,9 +38,7 @@ impl<B: Backend> StackAllocator<B> {
         StackAllocator(Provider::new(InnerStackAllocator {
             device: (*device.ref_raw()).clone(),
             usage,
-            buffers: ChunkStack::new(),
-            images: ChunkStack::new(),
-            targets: ChunkStack::new(),
+            stacks: HashMap::new(),
             chunk_size,
         }))
     }
@@ -52,9 +50,9 @@ impl<B: Backend> StackAllocator<B> {
 
 impl<B: Backend> InnerStackAllocator<B> {
     fn shrink(&mut self) {
-        self.buffers.shrink(&mut self.device);
-        self.images.shrink(&mut self.device);
-        self.targets.shrink(&mut self.device);
+        for (_, stack) in &mut self.stacks {
+            stack.shrink(&mut self.device);
+        }
     }
 }
 
@@ -68,9 +66,12 @@ impl<B: Backend> Allocator<B> for StackAllocator<B> {
         let inner: &mut InnerStackAllocator<B> = &mut self.0;
         let requirements = core::buffer::complete_requirements::<B>(
             device.mut_raw(), &buffer, usage);
-        let (memory, offset, release) = inner.buffers.allocate(
+        let memory_type = device.find_usage_memory(inner.usage, requirements.type_mask)
+            .expect("could not find suitable memory");
+        let mut stack = inner.stacks.entry(memory_type.id)
+            .or_insert_with(|| ChunkStack::new(memory_type));
+        let (memory, offset, release) = stack.allocate(
             device,
-            inner.usage,
             inner.chunk_size,
             requirements,
             dependency,
@@ -82,20 +83,18 @@ impl<B: Backend> Allocator<B> for StackAllocator<B> {
 
     fn allocate_image(&mut self,
         device: &mut Device<B>,
-        usage: image::Usage,
+        _: image::Usage,
         image: B::UnboundImage
     ) -> (B::Image, Memory) {
         let dependency = self.0.dependency();
         let inner: &mut InnerStackAllocator<B> = &mut self.0;
         let requirements = device.mut_raw().get_image_requirements(&image);
-        let stack = if usage.can_target() {
-            &mut inner.targets
-        } else {
-            &mut inner.images
-        };
+        let memory_type = device.find_usage_memory(inner.usage, requirements.type_mask)
+            .expect("could not find suitable memory");
+        let mut stack = inner.stacks.entry(memory_type.id)
+            .or_insert_with(|| ChunkStack::new(memory_type));
         let (memory, offset, release) = stack.allocate(
             device,
-            inner.usage,
             inner.chunk_size,
             requirements,
             dependency,
@@ -107,6 +106,7 @@ impl<B: Backend> Allocator<B> for StackAllocator<B> {
 }
 
 struct ChunkStack<B: Backend> {
+    memory_type: MemoryType,
     chunks: Vec<B::Memory>,
     allocs: Vec<StackAlloc>,
     receiver: mpsc::Receiver<usize>,
@@ -120,10 +120,11 @@ struct StackAlloc {
 }
 
 impl<B: Backend> ChunkStack<B> {
-    fn new() -> Self {
+    fn new(memory_type: MemoryType) -> Self {
         let (sender, receiver) = mpsc::channel();
 
         ChunkStack {
+            memory_type,
             chunks: Vec::new(),
             allocs: Vec::new(),
             receiver,
@@ -133,7 +134,6 @@ impl<B: Backend> ChunkStack<B> {
 
     fn allocate(&mut self,
         device: &mut Device<B>,
-        usage: memory::Usage,
         chunk_size: u64,
         req: Requirements,
         dependency: Dependency<InnerStackAllocator<B>>,
@@ -161,7 +161,7 @@ impl<B: Backend> ChunkStack<B> {
             };
 
         if chunk_index == self.chunks.len() {
-            self.grow(device, usage, chunk_size);
+            self.grow(device, chunk_size);
         }
 
         let alloc_index = self.allocs.len();
@@ -182,13 +182,10 @@ impl<B: Backend> ChunkStack<B> {
 
     fn grow(&mut self,
         device: &mut Device<B>,
-        usage: memory::Usage,
         chunk_size: u64
     ) {
-        let type_mask = 0xFF; //TODO
-        let memory_type = device.find_usage_memory(usage, type_mask).unwrap();
         let memory = device.mut_raw()
-            .allocate_memory(&memory_type, chunk_size)
+            .allocate_memory(&self.memory_type, chunk_size)
             .unwrap();
         self.chunks.push(memory);
     }

src/render/src/device.rs

@@ -10,7 +10,7 @@ use memory::{self, Allocator, Typed};
 use handle::{self, GarbageSender};
 use handle::inner::*;
 use {core, buffer, image, format, mapping, pso};
-use {Backend, Primitive};
+use {Backend, Primitive, Extent};
 
 #[derive(Clone)]
 pub struct Device<B: Backend> {
@@ -426,20 +426,19 @@ impl<B: Backend> Device<B> {
     }
 
     // TODO: smarter allocation
-    pub fn create_descriptors<D>(&mut self, count: usize) -> Vec<D>
+    pub fn create_descriptors<D>(&mut self, count: usize) -> Vec<(D, D::Data)>
         where D: pso::Descriptors<B>
     {
         use core::DescriptorPool as CDP;
 
         let bindings = &D::layout_bindings()[..];
         let layout = self.create_descriptor_set_layout(bindings);
-        let mut ranges = Vec::new();
-        for binding in bindings {
-            ranges.push(core::pso::DescriptorRangeDesc {
+        let ranges = bindings.iter().map(|binding| {
+            core::pso::DescriptorRangeDesc {
                 ty: binding.ty,
                 count: binding.count * count,
-            });
-        }
+            }
+        }).collect::<Vec<_>>();
 
         let mut pool = self.raw.create_descriptor_pool(count, &ranges[..]);
         let sets = {
@@ -515,6 +514,28 @@ impl<B: Backend> Device<B> {
     {
         init.create(self, shader_entries, primitive, rasterizer)
     }
+
+    // TODO?: typed
+    pub fn create_framebuffer<P>(
+        &mut self,
+        pipeline: &P,
+        rtvs: &[&handle::raw::RenderTargetView<B>],
+        dsvs: &[&handle::raw::DepthStencilView<B>],
+        extent: Extent,
+    ) -> handle::raw::FrameBuffer<B>
+        where P: pso::GraphicsPipelineMeta<B>
+    {
+        let rtv_res: Vec<_> = rtvs.iter().map(|&rtv| rtv.resource()).collect();
+        let dsv_res: Vec<_> = dsvs.iter().map(|&dsv| dsv.resource()).collect();
+        let buffer = self.raw.create_framebuffer(
+            pipeline.render_pass(), &rtv_res[..], &dsv_res[..], extent);
+        let info = handle::FrameBufferInfo {
+            rtvs: rtvs.iter().map(|&rtv| rtv.clone()).collect(),
+            dsvs: dsvs.iter().map(|&dsv| dsv.clone()).collect(),
+            extent,
+        };
+        FrameBuffer::new(buffer, info, self.garbage.clone()).into()
+    }
 /*
     /// Creates a `ShaderSet` from the supplied vertex and pixel shader source code.
     fn create_shader_set(&mut self, vs_code: &[u8], ps_code: &[u8])