Remove associated Desc from Node

command/src/buffer/encoder.rs

@@ -229,12 +229,7 @@ where
         dependencies: gfx_hal::memory::Dependencies,
         barriers: impl IntoIterator<Item = gfx_hal::memory::Barrier<'b, B>>,
     ) {
-        gfx_hal::command::CommandBuffer::pipeline_barrier(
-            self.raw,
-            stages,
-            dependencies,
-            barriers,
-        )
+        gfx_hal::command::CommandBuffer::pipeline_barrier(self.raw, stages, dependencies, barriers)
     }
 
     /// Push graphics constants.

command/src/family/mod.rs

@@ -79,7 +79,8 @@ where
                 let pos = queue_groups.iter().position(|qg| qg.family.0 == id.index);
                 let group = queue_groups.swap_remove(pos.unwrap());
                 assert_eq!(group.queues.len(), count);
-                group.queues
+                group
+                    .queues
                     .into_iter()
                     .enumerate()
                     .map(|(index, queue)| Queue::new(queue, QueueId { family: id, index }))
@@ -222,6 +223,19 @@ where
     pub fn indices(&self) -> &[usize] {
         &self.families_indices
     }
+
+    /// Find family id matching predicate
+    pub fn find<F>(&self, predicate: F) -> Option<FamilyId>
+    where
+        F: FnMut(&&Family<B>) -> bool,
+    {
+        self.families.iter().find(predicate).map(Family::id)
+    }
+
+    /// Get first matching family id with specified capability
+    pub fn with_capability<C: Capability>(&self) -> Option<FamilyId> {
+        self.find(|family| Supports::<C>::supports(&family.capability()).is_some())
+    }
 }
 
 /// Query queue families from device.

command/src/fence.rs

@@ -3,7 +3,7 @@ use {
         family::QueueId,
         util::{device_owned, Device, DeviceId},
     },
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
 };
 
 /// Queue epoch is the point in particluar queue timeline when fence is submitted.

command/src/pool.rs

@@ -2,7 +2,7 @@
 
 use {
     crate::{buffer::*, capability::*, family::FamilyId, util::Device},
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
 };
 
 /// Simple pool wrapper.

factory/src/blitter.rs

@@ -307,8 +307,7 @@ pub unsafe fn blit_image<B, C, L>(
     dst_image: &Handle<Image<B>>,
     filter: gfx_hal::image::Filter,
     regions: impl IntoIterator<Item = BlitRegion>,
-)
-where
+) where
     B: gfx_hal::Backend,
     C: Supports<Graphics>,
     L: Level,

factory/src/factory.rs

@@ -10,12 +10,13 @@ use {
         resource::*,
         upload::{BufferState, ImageState, ImageStateOrLayout, Uploader},
         util::{rendy_backend_match, rendy_with_slow_safety_checks, Device, DeviceId, Instance},
-        wsi::{SwapchainError, Surface, Target},
+        wsi::{Surface, SwapchainError, Target},
     },
     gfx_hal::{
-        buffer, format, image,
         adapter::{Adapter, Gpu, PhysicalDevice},
+        buffer,
         device::{AllocationError, Device as _, MapError, OomOrDeviceLost, OutOfMemory, WaitFor},
+        format, image,
         pso::DescriptorSetLayoutBinding,
         window::{Extent2D, Surface as GfxSurface},
         Backend, Features, Limits,
@@ -804,8 +805,11 @@ where
         }
 
         let timeout = !unsafe {
-            self.device
-                .wait_for_fences(fences.iter().map(|f| f.raw()), wait_for.clone(), timeout_ns)
+            self.device.wait_for_fences(
+                fences.iter().map(|f| f.raw()),
+                wait_for.clone(),
+                timeout_ns,
+            )
         }?;
 
         if timeout {
@@ -1122,14 +1126,22 @@ where
 
         log::debug!("Queues: {:#?}", get_queues);
 
-        let Gpu { device, mut queue_groups } = unsafe {
+        let Gpu {
+            device,
+            mut queue_groups,
+        } = unsafe {
             adapter
                 .physical_device
                 .open(&create_queues, adapter.physical_device.features())
         }?;
 
         let families = unsafe {
-            families_from_device(device_id, &mut queue_groups, get_queues, &adapter.queue_families)
+            families_from_device(
+                device_id,
+                &mut queue_groups,
+                get_queues,
+                &adapter.queue_families,
+            )
         };
         (device, families)
     };

graph/src/graph/mod.rs

@@ -5,8 +5,13 @@ use {
         factory::Factory,
         frame::{Fences, Frame, Frames},
         memory::Data,
-        node::{BufferBarrier, DynNode, ImageBarrier, NodeBuffer, NodeBuilder, NodeBuildError, NodeImage},
-        resource::{Buffer, BufferCreationError, BufferInfo, Handle, Image, ImageCreationError, ImageInfo},
+        node::{
+            BufferBarrier, DynNode, ImageBarrier, NodeBuffer, NodeBuildError, NodeBuilder,
+            NodeImage,
+        },
+        resource::{
+            Buffer, BufferCreationError, BufferInfo, Handle, Image, ImageCreationError, ImageInfo,
+        },
         util::{device_owned, DeviceId},
         BufferId, ImageId, NodeId,
     },
@@ -572,7 +577,7 @@ where
     let images = builder.images();
     chain::Node {
         id,
-        family: QueueFamilyId(builder.family(factory, families.as_slice()).unwrap().index),
+        family: QueueFamilyId(builder.family(factory, families).unwrap().index),
         dependencies: builder.dependencies().into_iter().map(|id| id.0).collect(),
         buffers: buffers
             .into_iter()

graph/src/node/mod.rs

@@ -6,7 +6,7 @@ pub mod render;
 
 use {
     crate::{
-        command::{Capability, Family, FamilyId, Fence, Queue, Submission, Submittable, Supports},
+        command::{Capability, Families, Family, FamilyId, Fence, Queue, Submission, Submittable},
         factory::{Factory, UploadError},
         frame::Frames,
         graph::GraphContext,
@@ -155,26 +155,6 @@ pub trait Node<B: Backend, T: ?Sized>:
     /// Graph will execute this node on command queue that supports this capability level.
     type Capability: Capability;
 
-    /// Description type to instantiate the node.
-    type Desc: NodeDesc<B, T, Node = Self>;
-
-    /// Desc creation.
-    /// Convenient method if `Self::Desc` implements `Default`.
-    fn desc() -> Self::Desc
-    where
-        Self::Desc: Default,
-    {
-        Default::default()
-    }
-
-    /// Builder creation.
-    fn builder() -> DescBuilder<B, T, Self::Desc>
-    where
-        Self::Desc: Default,
-    {
-        Self::desc().builder()
-    }
-
     /// Record commands required by node.
     /// Returned submits are guaranteed to be submitted within specified frame.
     fn run<'a>(
@@ -315,7 +295,7 @@ pub enum NodeBuildError {
 /// Dynamic node builder that emits `DynNode`.
 pub trait NodeBuilder<B: Backend, T: ?Sized>: std::fmt::Debug {
     /// Pick family for this node to be executed onto.
-    fn family(&self, factory: &mut Factory<B>, families: &[Family<B>]) -> Option<FamilyId>;
+    fn family(&self, factory: &mut Factory<B>, families: &Families<B>) -> Option<FamilyId>;
 
     /// Get buffer accessed by the node.
     fn buffers(&self) -> Vec<(BufferId, BufferAccess)>;
@@ -414,14 +394,8 @@ where
     T: ?Sized,
     N: NodeDesc<B, T>,
 {
-    fn family(&self, _factory: &mut Factory<B>, families: &[Family<B>]) -> Option<FamilyId> {
-        families
-            .iter()
-            .find(|family| {
-                Supports::<<N::Node as Node<B, T>>::Capability>::supports(&family.capability())
-                    .is_some()
-            })
-            .map(|family| family.id())
+    fn family(&self, _factory: &mut Factory<B>, families: &Families<B>) -> Option<FamilyId> {
+        families.with_capability::<<N::Node as Node<B, T>>::Capability>()
     }
 
     fn buffers(&self) -> Vec<(BufferId, BufferAccess)> {

graph/src/node/present.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     command::{
-        CommandBuffer, CommandPool, ExecutableState, Family, FamilyId, Fence, MultiShot,
+        CommandBuffer, CommandPool, ExecutableState, Families, Family, FamilyId, Fence, MultiShot,
         PendingState, Queue, SimultaneousUse, Submission, Submit,
     },
     factory::Factory,
@@ -359,12 +359,9 @@ where
     B: gfx_hal::Backend,
     T: ?Sized,
 {
-    fn family(&self, factory: &mut Factory<B>, families: &[Family<B>]) -> Option<FamilyId> {
+    fn family(&self, factory: &mut Factory<B>, families: &Families<B>) -> Option<FamilyId> {
         // Find correct queue family.
-        families
-            .iter()
-            .find(|family| factory.surface_support(family.id(), &self.surface))
-            .map(Family::id)
+        families.find(|family| factory.surface_support(family.id(), &self.surface))
     }
 
     fn buffers(&self) -> Vec<(BufferId, BufferAccess)> {

graph/src/node/render/group/simple.rs

@@ -9,7 +9,7 @@ use {
         },
         resource::{DescriptorSetLayout, Handle},
     },
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
 };
 
 pub use crate::util::types::{Layout, SetLayout};

graph/src/node/render/pass.rs

@@ -1,9 +1,9 @@
 use {
     crate::{
         command::{
-            CommandBuffer, CommandPool, ExecutableState, Family, FamilyId, Fence, Graphics,
-            IndividualReset, MultiShot, NoSimultaneousUse, PendingState, Queue, QueueId,
-            SecondaryLevel, SimultaneousUse, Submission, Submit, Supports,
+            CommandBuffer, CommandPool, ExecutableState, Families, Family, FamilyId, Fence,
+            Graphics, IndividualReset, MultiShot, NoSimultaneousUse, PendingState, Queue, QueueId,
+            SecondaryLevel, SimultaneousUse, Submission, Submit,
         },
         factory::Factory,
         frame::{
@@ -14,13 +14,13 @@ use {
         node::{
             gfx_acquire_barriers, gfx_release_barriers, is_metal,
             render::group::{RenderGroup, RenderGroupBuilder},
-            BufferAccess, DynNode, ImageAccess, NodeBuffer, NodeBuilder, NodeBuildError, NodeImage,
+            BufferAccess, DynNode, ImageAccess, NodeBuffer, NodeBuildError, NodeBuilder, NodeImage,
         },
         wsi::{Surface, Target},
         BufferId, ImageId, NodeId,
     },
     either::Either,
-    gfx_hal::{image::Layout, Backend, device::Device as _},
+    gfx_hal::{device::Device as _, image::Layout, Backend},
     std::{cmp::min, collections::HashMap},
 };
 
@@ -220,11 +220,8 @@ where
     B: Backend,
     T: ?Sized + 'static,
 {
-    fn family(&self, _factory: &mut Factory<B>, families: &[Family<B>]) -> Option<FamilyId> {
-        families
-            .iter()
-            .find(|family| Supports::<Graphics>::supports(&family.capability()).is_some())
-            .map(|family| family.id())
+    fn family(&self, _factory: &mut Factory<B>, families: &Families<B>) -> Option<FamilyId> {
+        families.with_capability::<Graphics>()
     }
 
     fn buffers(&self) -> Vec<(BufferId, BufferAccess)> {
@@ -448,7 +445,7 @@ where
                         }
 
                         let (caps, _f, present_modes_caps) = factory.get_surface_compatibility(&surface);
-         
+
                         let present_mode = *present_modes_caps
                             .iter()
                             .max_by_key(|mode| match mode {
@@ -458,10 +455,10 @@ where
                                 gfx_hal::window::PresentMode::Immediate => 0,
                             })
                             .unwrap();
-            
+
                         let img_count_caps = caps.image_count;
                         let image_count = 3.min(*img_count_caps.end()).max(*img_count_caps.start());
-             
+
                         let target = factory
                             .create_target(
                                 surface,
@@ -766,7 +763,8 @@ where
                             .buffers()
                             .into_iter()
                             .map(|(id, _)| {
-                                buffers.iter()
+                                buffers
+                                    .iter()
                                     .find(|b| b.id == id)
                                     .expect("Transient buffer wasn't provided")
                                     .clone()
@@ -776,7 +774,8 @@ where
                             .images()
                             .into_iter()
                             .map(|(id, _)| {
-                                images.iter()
+                                images
+                                    .iter()
                                     .find(|i| i.id == id)
                                     .expect("Transient image wasn't provided")
                                     .clone()

memory/src/allocator/dedicated.rs

@@ -7,7 +7,7 @@ use {
         mapping::{mapped_fitting_range, MappedRange},
         memory::*,
     },
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
 };
 
 /// Memory block allocated from `DedicatedAllocator`

memory/src/allocator/dynamic.rs

@@ -13,7 +13,7 @@ use {
         memory::*,
         util::*,
     },
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
     hibitset::{BitSet, BitSetLike as _},
 };
 

memory/src/allocator/linear.rs

@@ -8,7 +8,7 @@ use {
         memory::*,
         util::*,
     },
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
 };
 
 /// Memory block allocated from `LinearAllocator`

memory/src/mapping/mod.rs

@@ -3,7 +3,7 @@ pub(crate) mod write;
 
 use {
     crate::{memory::Memory, util::fits_usize},
-    gfx_hal::{Backend, device::Device as _},
+    gfx_hal::{device::Device as _, Backend},
     std::{ops::Range, ptr::NonNull},
 };
 

mesh/src/mesh.rs

@@ -254,10 +254,11 @@ impl<'a> MeshBuilder<'a> {
             )
             .map_err(UploadError::Create)?;
 
-        let mut mapped = staging.map(factory, 0..aligned_size)
-            .map_err(UploadError::Map)?;
-        let mut writer = unsafe { mapped.write(factory, 0..aligned_size) }
+        let mut mapped = staging
+            .map(factory, 0..aligned_size)
             .map_err(UploadError::Map)?;
+        let mut writer =
+            unsafe { mapped.write(factory, 0..aligned_size) }.map_err(UploadError::Map)?;
         let staging_slice = unsafe { writer.slice() };
 
         let mut offset = 0usize;
@@ -293,7 +294,8 @@ impl<'a> MeshBuilder<'a> {
                     .create_buffer(
                         BufferInfo {
                             size: indices.len() as _,
-                            usage: gfx_hal::buffer::Usage::INDEX | gfx_hal::buffer::Usage::TRANSFER_DST,
+                            usage: gfx_hal::buffer::Usage::INDEX
+                                | gfx_hal::buffer::Usage::TRANSFER_DST,
                         },
                         Data,
                     )