[WIP] Implement extension chaining

README.md

@@ -82,6 +82,23 @@ Builders implement `Deref` targeting their corresponding Vulkan struct, so refer
 to Vulkan functions. This is encouraged as doing so allows Rust to check the lifetimes of captured objects are valid,
 whereas calling `build` discards lifetime information, making inadvertent use-after-free errors more likely.
 
+### Pointer chains
+
+```Rust
+let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder();
+let mut corner =
+    vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder();
+;
+let mut device_create_info = vk::DeviceCreateInfo::builder()
+    .push_next(&mut corner)
+    .push_next(&mut variable_pointers);
+```
+
+Pointer chains in builders differ from raw Vulkan. Instead of chaining every struct manually, you instead use `.push_next` on the struct that you are going to pass into the function. Those structs then get *pepended* into the chain.
+
+`push_next` is also type checked, you can only add valid structs to the chain. Both the structs and the builders can be passed into `push_next`. Only builders for structs that can be passed into functions will implement a `push_next`.
+
+
 ### Flags and constants as associated constants
 
 ```Rust

ash/src/extensions/experimental/amd.rs

@@ -657,11 +657,19 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> {
-    pub fn next<T>(mut self, next: &'a mut T) -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a>
+    pub fn push_next<T>(
+        mut self,
+        next: &'a mut T,
+    ) -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a>
     where
         T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd,
     {
-        self.inner.p_next = next as *mut T as *mut c_void;
+        unsafe {
+            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr as _;
+        }
         self
     }
     pub fn build(self) -> PhysicalDeviceWaveLimitPropertiesAmd {

ash/src/extensions/nv/ray_tracing.rs

@@ -28,11 +28,10 @@ impl RayTracing {
         pdevice: vk::PhysicalDevice,
     ) -> vk::PhysicalDeviceRayTracingPropertiesNV {
         let mut props_rt = vk::PhysicalDeviceRayTracingPropertiesNV::default();
-        let mut props = vk::PhysicalDeviceProperties2::builder()
-            .next(&mut props_rt)
-            .build();
-
-        instance.get_physical_device_properties2(pdevice, &mut props);
+        {
+            let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt);
+            instance.get_physical_device_properties2(pdevice, &mut props);
+        }
         props_rt
     }
 

ash/src/lib.rs

@@ -31,3 +31,27 @@ impl<'r, T> RawPtr<T> for Option<&'r T> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::vk;
+    #[test]
+    fn test_ptr_chains() {
+        let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder();
+        let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder();
+        let chain = vec![
+            &variable_pointers as *const _ as usize,
+            &corner as *const _ as usize,
+        ];
+        let mut device_create_info = vk::DeviceCreateInfo::builder()
+            .push_next(&mut corner)
+            .push_next(&mut variable_pointers);
+        let chain2: Vec<usize> = unsafe {
+            vk::ptr_chain_iter(&mut device_create_info)
+                .skip(1)
+                .map(|ptr| ptr as usize)
+                .collect()
+        };
+        assert_eq!(chain, chain2);
+    }
+}