diff --git a/ash-window/examples/winit.rs b/ash-window/examples/winit.rs index 4987bbb..f309efe 100644 --- a/ash-window/examples/winit.rs +++ b/ash-window/examples/winit.rs @@ -17,8 +17,8 @@ fn main() -> Result<(), Box> { unsafe { let entry = ash::Entry::linked(); let surface_extensions = ash_window::enumerate_required_extensions(&window)?; - let app_desc = vk::ApplicationInfo::builder().api_version(vk::make_api_version(0, 1, 0, 0)); - let instance_desc = vk::InstanceCreateInfo::builder() + let app_desc = vk::ApplicationInfo::default().api_version(vk::make_api_version(0, 1, 0, 0)); + let instance_desc = vk::InstanceCreateInfo::default() .application_info(&app_desc) .enabled_extension_names(surface_extensions); diff --git a/ash-window/src/lib.rs b/ash-window/src/lib.rs index cc6ad31..d6cb0f3 100644 --- a/ash-window/src/lib.rs +++ b/ash-window/src/lib.rs @@ -26,7 +26,7 @@ pub unsafe fn create_surface( match window_handle.raw_window_handle() { #[cfg(target_os = "windows")] RawWindowHandle::Windows(handle) => { - let surface_desc = vk::Win32SurfaceCreateInfoKHR::builder() + let surface_desc = vk::Win32SurfaceCreateInfoKHR::default() .hinstance(handle.hinstance) .hwnd(handle.hwnd); let surface_fn = khr::Win32Surface::new(entry, instance); @@ -41,7 +41,7 @@ pub unsafe fn create_surface( target_os = "openbsd" ))] RawWindowHandle::Wayland(handle) => { - let surface_desc = vk::WaylandSurfaceCreateInfoKHR::builder() + let surface_desc = vk::WaylandSurfaceCreateInfoKHR::default() .display(handle.display) .surface(handle.surface); let surface_fn = khr::WaylandSurface::new(entry, instance); @@ -56,7 +56,7 @@ pub unsafe fn create_surface( target_os = "openbsd" ))] RawWindowHandle::Xlib(handle) => { - let surface_desc = vk::XlibSurfaceCreateInfoKHR::builder() + let surface_desc = vk::XlibSurfaceCreateInfoKHR::default() .dpy(handle.display as *mut _) .window(handle.window); let surface_fn = khr::XlibSurface::new(entry, instance); @@ -71,7 +71,7 @@ pub unsafe fn create_surface( target_os = "openbsd" ))] RawWindowHandle::Xcb(handle) => { - let surface_desc = vk::XcbSurfaceCreateInfoKHR::builder() + let surface_desc = vk::XcbSurfaceCreateInfoKHR::default() .connection(handle.connection) .window(handle.window); let surface_fn = khr::XcbSurface::new(entry, instance); @@ -81,7 +81,7 @@ pub unsafe fn create_surface( #[cfg(any(target_os = "android"))] RawWindowHandle::Android(handle) => { let surface_desc = - vk::AndroidSurfaceCreateInfoKHR::builder().window(handle.a_native_window); + vk::AndroidSurfaceCreateInfoKHR::default().window(handle.a_native_window); let surface_fn = khr::AndroidSurface::new(entry, instance); surface_fn.create_android_surface(&surface_desc, allocation_callbacks) } @@ -95,7 +95,7 @@ pub unsafe fn create_surface( Layer::None => return Err(vk::Result::ERROR_INITIALIZATION_FAILED), }; - let surface_desc = vk::MetalSurfaceCreateInfoEXT::builder().layer(&*layer); + let surface_desc = vk::MetalSurfaceCreateInfoEXT::default().layer(&*layer); let surface_fn = ext::MetalSurface::new(entry, instance); surface_fn.create_metal_surface(&surface_desc, allocation_callbacks) } @@ -109,7 +109,7 @@ pub unsafe fn create_surface( Layer::None => return Err(vk::Result::ERROR_INITIALIZATION_FAILED), }; - let surface_desc = vk::MetalSurfaceCreateInfoEXT::builder().layer(&*layer); + let surface_desc = vk::MetalSurfaceCreateInfoEXT::default().layer(&*layer); let surface_fn = ext::MetalSurface::new(entry, instance); surface_fn.create_metal_surface(&surface_desc, allocation_callbacks) } diff --git a/ash/src/extensions/ext/physical_device_drm.rs b/ash/src/extensions/ext/physical_device_drm.rs index 2847b65..06052a4 100644 --- a/ash/src/extensions/ext/physical_device_drm.rs +++ b/ash/src/extensions/ext/physical_device_drm.rs @@ -12,7 +12,7 @@ impl PhysicalDeviceDrm { ) -> vk::PhysicalDeviceDrmPropertiesEXT { let mut props_drm = vk::PhysicalDeviceDrmPropertiesEXT::default(); { - let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_drm); + let mut props = vk::PhysicalDeviceProperties2::default().push_next(&mut props_drm); instance.get_physical_device_properties2(pdevice, &mut props); } props_drm diff --git a/ash/src/extensions/khr/acceleration_structure.rs b/ash/src/extensions/khr/acceleration_structure.rs index 8bb2ced..b0ebe67 100644 --- a/ash/src/extensions/khr/acceleration_structure.rs +++ b/ash/src/extensions/khr/acceleration_structure.rs @@ -26,7 +26,7 @@ impl AccelerationStructure { ) -> vk::PhysicalDeviceAccelerationStructurePropertiesKHR { let mut props_rt = vk::PhysicalDeviceAccelerationStructurePropertiesKHR::default(); { - let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + let mut props = vk::PhysicalDeviceProperties2::default().push_next(&mut props_rt); instance.get_physical_device_properties2(pdevice, &mut props); } props_rt diff --git a/ash/src/extensions/khr/ray_tracing_pipeline.rs b/ash/src/extensions/khr/ray_tracing_pipeline.rs index 5ec75ae..0661fb5 100644 --- a/ash/src/extensions/khr/ray_tracing_pipeline.rs +++ b/ash/src/extensions/khr/ray_tracing_pipeline.rs @@ -26,7 +26,7 @@ impl RayTracingPipeline { ) -> vk::PhysicalDeviceRayTracingPipelinePropertiesKHR { let mut props_rt = vk::PhysicalDeviceRayTracingPipelinePropertiesKHR::default(); { - let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + let mut props = vk::PhysicalDeviceProperties2::default().push_next(&mut props_rt); instance.get_physical_device_properties2(pdevice, &mut props); } props_rt diff --git a/ash/src/extensions/nv/ray_tracing.rs b/ash/src/extensions/nv/ray_tracing.rs index 1df468f..d11c731 100755 --- a/ash/src/extensions/nv/ray_tracing.rs +++ b/ash/src/extensions/nv/ray_tracing.rs @@ -26,7 +26,7 @@ impl RayTracing { ) -> vk::PhysicalDeviceRayTracingPropertiesNV { let mut props_rt = vk::PhysicalDeviceRayTracingPropertiesNV::default(); { - let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + let mut props = vk::PhysicalDeviceProperties2::default().push_next(&mut props_rt); instance.get_physical_device_properties2(pdevice, &mut props); } props_rt diff --git a/ash/src/lib.rs b/ash/src/lib.rs index 50c9d8f..30add6c 100644 --- a/ash/src/lib.rs +++ b/ash/src/lib.rs @@ -71,13 +71,13 @@ mod tests { use super::vk; #[test] fn test_ptr_chains() { - let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); - let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::default(); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::default(); let chain = vec![ <*mut _>::cast(&mut variable_pointers), <*mut _>::cast(&mut corner), ]; - let mut device_create_info = vk::DeviceCreateInfo::builder() + let mut device_create_info = vk::DeviceCreateInfo::default() .push_next(&mut corner) .push_next(&mut variable_pointers); let chain2: Vec<*mut vk::BaseOutStructure> = unsafe { diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index ef6940b..5ea1fae 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -45,198 +45,216 @@ pub type ChromaLocationKHR = ChromaLocation; pub type SamplerReductionModeEXT = SamplerReductionMode; pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence; pub type DriverIdKHR = DriverId; -pub type DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; -pub type PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; -pub type PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; -pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; -pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; -pub type FormatProperties2KHR = FormatProperties2; -pub type ImageFormatProperties2KHR = ImageFormatProperties2; -pub type PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; -pub type QueueFamilyProperties2KHR = QueueFamilyProperties2; -pub type PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; -pub type SparseImageFormatProperties2KHR = SparseImageFormatProperties2; -pub type PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; +pub type DevicePrivateDataCreateInfoEXT<'a> = DevicePrivateDataCreateInfo<'a>; +pub type PrivateDataSlotCreateInfoEXT<'a> = PrivateDataSlotCreateInfo<'a>; +pub type PhysicalDevicePrivateDataFeaturesEXT<'a> = PhysicalDevicePrivateDataFeatures<'a>; +pub type PhysicalDeviceFeatures2KHR<'a> = PhysicalDeviceFeatures2<'a>; +pub type PhysicalDeviceProperties2KHR<'a> = PhysicalDeviceProperties2<'a>; +pub type FormatProperties2KHR<'a> = FormatProperties2<'a>; +pub type ImageFormatProperties2KHR<'a> = ImageFormatProperties2<'a>; +pub type PhysicalDeviceImageFormatInfo2KHR<'a> = PhysicalDeviceImageFormatInfo2<'a>; +pub type QueueFamilyProperties2KHR<'a> = QueueFamilyProperties2<'a>; +pub type PhysicalDeviceMemoryProperties2KHR<'a> = PhysicalDeviceMemoryProperties2<'a>; +pub type SparseImageFormatProperties2KHR<'a> = SparseImageFormatProperties2<'a>; +pub type PhysicalDeviceSparseImageFormatInfo2KHR<'a> = PhysicalDeviceSparseImageFormatInfo2<'a>; pub type ConformanceVersionKHR = ConformanceVersion; -pub type PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; -pub type PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; -pub type PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; -pub type PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; +pub type PhysicalDeviceDriverPropertiesKHR<'a> = PhysicalDeviceDriverProperties<'a>; +pub type PhysicalDeviceVariablePointersFeaturesKHR<'a> = PhysicalDeviceVariablePointersFeatures<'a>; +pub type PhysicalDeviceVariablePointerFeaturesKHR<'a> = PhysicalDeviceVariablePointersFeatures<'a>; +pub type PhysicalDeviceVariablePointerFeatures<'a> = PhysicalDeviceVariablePointersFeatures<'a>; pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties; -pub type PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; -pub type ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; -pub type PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; -pub type ExternalBufferPropertiesKHR = ExternalBufferProperties; -pub type PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; -pub type ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; -pub type ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; -pub type ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; -pub type PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; -pub type ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; -pub type ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; -pub type PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; -pub type ExternalFencePropertiesKHR = ExternalFenceProperties; -pub type ExportFenceCreateInfoKHR = ExportFenceCreateInfo; -pub type PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; -pub type PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; -pub type RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; -pub type PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; -pub type MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; -pub type BindBufferMemoryInfoKHR = BindBufferMemoryInfo; -pub type BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; -pub type BindImageMemoryInfoKHR = BindImageMemoryInfo; -pub type BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; -pub type DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; -pub type DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; -pub type DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; -pub type DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; -pub type DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; +pub type PhysicalDeviceExternalImageFormatInfoKHR<'a> = PhysicalDeviceExternalImageFormatInfo<'a>; +pub type ExternalImageFormatPropertiesKHR<'a> = ExternalImageFormatProperties<'a>; +pub type PhysicalDeviceExternalBufferInfoKHR<'a> = PhysicalDeviceExternalBufferInfo<'a>; +pub type ExternalBufferPropertiesKHR<'a> = ExternalBufferProperties<'a>; +pub type PhysicalDeviceIDPropertiesKHR<'a> = PhysicalDeviceIDProperties<'a>; +pub type ExternalMemoryImageCreateInfoKHR<'a> = ExternalMemoryImageCreateInfo<'a>; +pub type ExternalMemoryBufferCreateInfoKHR<'a> = ExternalMemoryBufferCreateInfo<'a>; +pub type ExportMemoryAllocateInfoKHR<'a> = ExportMemoryAllocateInfo<'a>; +pub type PhysicalDeviceExternalSemaphoreInfoKHR<'a> = PhysicalDeviceExternalSemaphoreInfo<'a>; +pub type ExternalSemaphorePropertiesKHR<'a> = ExternalSemaphoreProperties<'a>; +pub type ExportSemaphoreCreateInfoKHR<'a> = ExportSemaphoreCreateInfo<'a>; +pub type PhysicalDeviceExternalFenceInfoKHR<'a> = PhysicalDeviceExternalFenceInfo<'a>; +pub type ExternalFencePropertiesKHR<'a> = ExternalFenceProperties<'a>; +pub type ExportFenceCreateInfoKHR<'a> = ExportFenceCreateInfo<'a>; +pub type PhysicalDeviceMultiviewFeaturesKHR<'a> = PhysicalDeviceMultiviewFeatures<'a>; +pub type PhysicalDeviceMultiviewPropertiesKHR<'a> = PhysicalDeviceMultiviewProperties<'a>; +pub type RenderPassMultiviewCreateInfoKHR<'a> = RenderPassMultiviewCreateInfo<'a>; +pub type PhysicalDeviceGroupPropertiesKHR<'a> = PhysicalDeviceGroupProperties<'a>; +pub type MemoryAllocateFlagsInfoKHR<'a> = MemoryAllocateFlagsInfo<'a>; +pub type BindBufferMemoryInfoKHR<'a> = BindBufferMemoryInfo<'a>; +pub type BindBufferMemoryDeviceGroupInfoKHR<'a> = BindBufferMemoryDeviceGroupInfo<'a>; +pub type BindImageMemoryInfoKHR<'a> = BindImageMemoryInfo<'a>; +pub type BindImageMemoryDeviceGroupInfoKHR<'a> = BindImageMemoryDeviceGroupInfo<'a>; +pub type DeviceGroupRenderPassBeginInfoKHR<'a> = DeviceGroupRenderPassBeginInfo<'a>; +pub type DeviceGroupCommandBufferBeginInfoKHR<'a> = DeviceGroupCommandBufferBeginInfo<'a>; +pub type DeviceGroupSubmitInfoKHR<'a> = DeviceGroupSubmitInfo<'a>; +pub type DeviceGroupBindSparseInfoKHR<'a> = DeviceGroupBindSparseInfo<'a>; +pub type DeviceGroupDeviceCreateInfoKHR<'a> = DeviceGroupDeviceCreateInfo<'a>; pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; -pub type DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; +pub type DescriptorUpdateTemplateCreateInfoKHR<'a> = DescriptorUpdateTemplateCreateInfo<'a>; pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; -pub type RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; -pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; -pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = - PhysicalDeviceShaderSubgroupExtendedTypesFeatures; -pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; -pub type DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; -pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; -pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; -pub type DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; -pub type MemoryRequirements2KHR = MemoryRequirements2; -pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; -pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; -pub type MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; -pub type MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; -pub type ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; -pub type PipelineTessellationDomainOriginStateCreateInfoKHR = - PipelineTessellationDomainOriginStateCreateInfo; -pub type SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; -pub type SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; -pub type BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; -pub type ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; -pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = - PhysicalDeviceSamplerYcbcrConversionFeatures; -pub type SamplerYcbcrConversionImageFormatPropertiesKHR = - SamplerYcbcrConversionImageFormatProperties; -pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = - PhysicalDeviceSamplerFilterMinmaxProperties; -pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; -pub type PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; -pub type PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; -pub type WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; -pub type DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; -pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; -pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; -pub type PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; -pub type PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; -pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; -pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; -pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; -pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; -pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; -pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; -pub type DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR; -pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT = - PhysicalDeviceGlobalPriorityQueryFeaturesKHR; -pub type QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR; -pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; -pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; -pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; -pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT = - DescriptorSetVariableDescriptorCountAllocateInfo; -pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT = - DescriptorSetVariableDescriptorCountLayoutSupport; -pub type AttachmentDescription2KHR = AttachmentDescription2; -pub type AttachmentReference2KHR = AttachmentReference2; -pub type SubpassDescription2KHR = SubpassDescription2; -pub type SubpassDependency2KHR = SubpassDependency2; -pub type RenderPassCreateInfo2KHR = RenderPassCreateInfo2; -pub type SubpassBeginInfoKHR = SubpassBeginInfo; -pub type SubpassEndInfoKHR = SubpassEndInfo; -pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; -pub type PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; -pub type SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; -pub type TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; -pub type SemaphoreWaitInfoKHR = SemaphoreWaitInfo; -pub type SemaphoreSignalInfoKHR = SemaphoreSignalInfo; -pub type PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; -pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; -pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; -pub type PhysicalDeviceDepthStencilResolvePropertiesKHR = - PhysicalDeviceDepthStencilResolveProperties; -pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; -pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; -pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; -pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = - PhysicalDeviceUniformBufferStandardLayoutFeatures; -pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; -pub type PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; -pub type BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; -pub type BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; -pub type BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; -pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; -pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; -pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; -pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; -pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = - PhysicalDeviceTextureCompressionASTCHDRFeatures; +pub type RenderPassInputAttachmentAspectCreateInfoKHR<'a> = + RenderPassInputAttachmentAspectCreateInfo<'a>; +pub type PhysicalDevice16BitStorageFeaturesKHR<'a> = PhysicalDevice16BitStorageFeatures<'a>; +pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR<'a> = + PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a>; +pub type BufferMemoryRequirementsInfo2KHR<'a> = BufferMemoryRequirementsInfo2<'a>; +pub type DeviceBufferMemoryRequirementsKHR<'a> = DeviceBufferMemoryRequirements<'a>; +pub type ImageMemoryRequirementsInfo2KHR<'a> = ImageMemoryRequirementsInfo2<'a>; +pub type ImageSparseMemoryRequirementsInfo2KHR<'a> = ImageSparseMemoryRequirementsInfo2<'a>; +pub type DeviceImageMemoryRequirementsKHR<'a> = DeviceImageMemoryRequirements<'a>; +pub type MemoryRequirements2KHR<'a> = MemoryRequirements2<'a>; +pub type SparseImageMemoryRequirements2KHR<'a> = SparseImageMemoryRequirements2<'a>; +pub type PhysicalDevicePointClippingPropertiesKHR<'a> = PhysicalDevicePointClippingProperties<'a>; +pub type MemoryDedicatedRequirementsKHR<'a> = MemoryDedicatedRequirements<'a>; +pub type MemoryDedicatedAllocateInfoKHR<'a> = MemoryDedicatedAllocateInfo<'a>; +pub type ImageViewUsageCreateInfoKHR<'a> = ImageViewUsageCreateInfo<'a>; +pub type PipelineTessellationDomainOriginStateCreateInfoKHR<'a> = + PipelineTessellationDomainOriginStateCreateInfo<'a>; +pub type SamplerYcbcrConversionInfoKHR<'a> = SamplerYcbcrConversionInfo<'a>; +pub type SamplerYcbcrConversionCreateInfoKHR<'a> = SamplerYcbcrConversionCreateInfo<'a>; +pub type BindImagePlaneMemoryInfoKHR<'a> = BindImagePlaneMemoryInfo<'a>; +pub type ImagePlaneMemoryRequirementsInfoKHR<'a> = ImagePlaneMemoryRequirementsInfo<'a>; +pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR<'a> = + PhysicalDeviceSamplerYcbcrConversionFeatures<'a>; +pub type SamplerYcbcrConversionImageFormatPropertiesKHR<'a> = + SamplerYcbcrConversionImageFormatProperties<'a>; +pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT<'a> = + PhysicalDeviceSamplerFilterMinmaxProperties<'a>; +pub type SamplerReductionModeCreateInfoEXT<'a> = SamplerReductionModeCreateInfo<'a>; +pub type PhysicalDeviceInlineUniformBlockFeaturesEXT<'a> = + PhysicalDeviceInlineUniformBlockFeatures<'a>; +pub type PhysicalDeviceInlineUniformBlockPropertiesEXT<'a> = + PhysicalDeviceInlineUniformBlockProperties<'a>; +pub type WriteDescriptorSetInlineUniformBlockEXT<'a> = WriteDescriptorSetInlineUniformBlock<'a>; +pub type DescriptorPoolInlineUniformBlockCreateInfoEXT<'a> = + DescriptorPoolInlineUniformBlockCreateInfo<'a>; +pub type ImageFormatListCreateInfoKHR<'a> = ImageFormatListCreateInfo<'a>; +pub type PhysicalDeviceMaintenance3PropertiesKHR<'a> = PhysicalDeviceMaintenance3Properties<'a>; +pub type PhysicalDeviceMaintenance4FeaturesKHR<'a> = PhysicalDeviceMaintenance4Features<'a>; +pub type PhysicalDeviceMaintenance4PropertiesKHR<'a> = PhysicalDeviceMaintenance4Properties<'a>; +pub type DescriptorSetLayoutSupportKHR<'a> = DescriptorSetLayoutSupport<'a>; +pub type PhysicalDeviceShaderDrawParameterFeatures<'a> = + PhysicalDeviceShaderDrawParametersFeatures<'a>; +pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR<'a> = + PhysicalDeviceShaderFloat16Int8Features<'a>; +pub type PhysicalDeviceFloat16Int8FeaturesKHR<'a> = PhysicalDeviceShaderFloat16Int8Features<'a>; +pub type PhysicalDeviceFloatControlsPropertiesKHR<'a> = PhysicalDeviceFloatControlsProperties<'a>; +pub type PhysicalDeviceHostQueryResetFeaturesEXT<'a> = PhysicalDeviceHostQueryResetFeatures<'a>; +pub type DeviceQueueGlobalPriorityCreateInfoEXT<'a> = DeviceQueueGlobalPriorityCreateInfoKHR<'a>; +pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT<'a> = + PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'a>; +pub type QueueFamilyGlobalPriorityPropertiesEXT<'a> = QueueFamilyGlobalPriorityPropertiesKHR<'a>; +pub type PhysicalDeviceDescriptorIndexingFeaturesEXT<'a> = + PhysicalDeviceDescriptorIndexingFeatures<'a>; +pub type PhysicalDeviceDescriptorIndexingPropertiesEXT<'a> = + PhysicalDeviceDescriptorIndexingProperties<'a>; +pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT<'a> = + DescriptorSetLayoutBindingFlagsCreateInfo<'a>; +pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT<'a> = + DescriptorSetVariableDescriptorCountAllocateInfo<'a>; +pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT<'a> = + DescriptorSetVariableDescriptorCountLayoutSupport<'a>; +pub type AttachmentDescription2KHR<'a> = AttachmentDescription2<'a>; +pub type AttachmentReference2KHR<'a> = AttachmentReference2<'a>; +pub type SubpassDescription2KHR<'a> = SubpassDescription2<'a>; +pub type SubpassDependency2KHR<'a> = SubpassDependency2<'a>; +pub type RenderPassCreateInfo2KHR<'a> = RenderPassCreateInfo2<'a>; +pub type SubpassBeginInfoKHR<'a> = SubpassBeginInfo<'a>; +pub type SubpassEndInfoKHR<'a> = SubpassEndInfo<'a>; +pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR<'a> = + PhysicalDeviceTimelineSemaphoreFeatures<'a>; +pub type PhysicalDeviceTimelineSemaphorePropertiesKHR<'a> = + PhysicalDeviceTimelineSemaphoreProperties<'a>; +pub type SemaphoreTypeCreateInfoKHR<'a> = SemaphoreTypeCreateInfo<'a>; +pub type TimelineSemaphoreSubmitInfoKHR<'a> = TimelineSemaphoreSubmitInfo<'a>; +pub type SemaphoreWaitInfoKHR<'a> = SemaphoreWaitInfo<'a>; +pub type SemaphoreSignalInfoKHR<'a> = SemaphoreSignalInfo<'a>; +pub type PhysicalDevice8BitStorageFeaturesKHR<'a> = PhysicalDevice8BitStorageFeatures<'a>; +pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR<'a> = + PhysicalDeviceVulkanMemoryModelFeatures<'a>; +pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR<'a> = + PhysicalDeviceShaderAtomicInt64Features<'a>; +pub type PhysicalDeviceDepthStencilResolvePropertiesKHR<'a> = + PhysicalDeviceDepthStencilResolveProperties<'a>; +pub type SubpassDescriptionDepthStencilResolveKHR<'a> = SubpassDescriptionDepthStencilResolve<'a>; +pub type ImageStencilUsageCreateInfoEXT<'a> = ImageStencilUsageCreateInfo<'a>; +pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT<'a> = + PhysicalDeviceScalarBlockLayoutFeatures<'a>; +pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR<'a> = + PhysicalDeviceUniformBufferStandardLayoutFeatures<'a>; +pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR<'a> = + PhysicalDeviceBufferDeviceAddressFeatures<'a>; +pub type PhysicalDeviceBufferAddressFeaturesEXT<'a> = + PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a>; +pub type BufferDeviceAddressInfoKHR<'a> = BufferDeviceAddressInfo<'a>; +pub type BufferDeviceAddressInfoEXT<'a> = BufferDeviceAddressInfo<'a>; +pub type BufferOpaqueCaptureAddressCreateInfoKHR<'a> = BufferOpaqueCaptureAddressCreateInfo<'a>; +pub type PhysicalDeviceImagelessFramebufferFeaturesKHR<'a> = + PhysicalDeviceImagelessFramebufferFeatures<'a>; +pub type FramebufferAttachmentsCreateInfoKHR<'a> = FramebufferAttachmentsCreateInfo<'a>; +pub type FramebufferAttachmentImageInfoKHR<'a> = FramebufferAttachmentImageInfo<'a>; +pub type RenderPassAttachmentBeginInfoKHR<'a> = RenderPassAttachmentBeginInfo<'a>; +pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT<'a> = + PhysicalDeviceTextureCompressionASTCHDRFeatures<'a>; pub type PipelineCreationFeedbackEXT = PipelineCreationFeedback; -pub type PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; -pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; -pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = - PhysicalDeviceSeparateDepthStencilLayoutsFeatures; -pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; -pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; -pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = - PhysicalDeviceShaderDemoteToHelperInvocationFeatures; -pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT = - PhysicalDeviceTexelBufferAlignmentProperties; -pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; -pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT = - PhysicalDeviceSubgroupSizeControlProperties; -pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = - PipelineShaderStageRequiredSubgroupSizeCreateInfo; -pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; -pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; -pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT = - PhysicalDevicePipelineCreationCacheControlFeatures; -pub type PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; +pub type PipelineCreationFeedbackCreateInfoEXT<'a> = PipelineCreationFeedbackCreateInfo<'a>; +pub type QueryPoolCreateInfoINTEL<'a> = QueryPoolPerformanceQueryCreateInfoINTEL<'a>; +pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR<'a> = + PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a>; +pub type AttachmentReferenceStencilLayoutKHR<'a> = AttachmentReferenceStencilLayout<'a>; +pub type AttachmentDescriptionStencilLayoutKHR<'a> = AttachmentDescriptionStencilLayout<'a>; +pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT<'a> = + PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a>; +pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT<'a> = + PhysicalDeviceTexelBufferAlignmentProperties<'a>; +pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT<'a> = + PhysicalDeviceSubgroupSizeControlFeatures<'a>; +pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT<'a> = + PhysicalDeviceSubgroupSizeControlProperties<'a>; +pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT<'a> = + PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a>; +pub type MemoryOpaqueCaptureAddressAllocateInfoKHR<'a> = MemoryOpaqueCaptureAddressAllocateInfo<'a>; +pub type DeviceMemoryOpaqueCaptureAddressInfoKHR<'a> = DeviceMemoryOpaqueCaptureAddressInfo<'a>; +pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT<'a> = + PhysicalDevicePipelineCreationCacheControlFeatures<'a>; +pub type PhysicalDeviceToolPropertiesEXT<'a> = PhysicalDeviceToolProperties<'a>; pub type AabbPositionsNV = AabbPositionsKHR; pub type TransformMatrixNV = TransformMatrixKHR; pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; -pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = - PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; -pub type PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; -pub type BufferCopy2KHR = BufferCopy2; -pub type ImageCopy2KHR = ImageCopy2; -pub type ImageBlit2KHR = ImageBlit2; -pub type BufferImageCopy2KHR = BufferImageCopy2; -pub type ImageResolve2KHR = ImageResolve2; -pub type CopyBufferInfo2KHR = CopyBufferInfo2; -pub type CopyImageInfo2KHR = CopyImageInfo2; -pub type BlitImageInfo2KHR = BlitImageInfo2; -pub type CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; -pub type CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; -pub type ResolveImageInfo2KHR = ResolveImageInfo2; -pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR = - PhysicalDeviceShaderTerminateInvocationFeatures; -pub type MemoryBarrier2KHR = MemoryBarrier2; -pub type ImageMemoryBarrier2KHR = ImageMemoryBarrier2; -pub type BufferMemoryBarrier2KHR = BufferMemoryBarrier2; -pub type DependencyInfoKHR = DependencyInfo; -pub type SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; -pub type CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; -pub type SubmitInfo2KHR = SubmitInfo2; -pub type PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; -pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR = - PhysicalDeviceShaderIntegerDotProductFeatures; -pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR = - PhysicalDeviceShaderIntegerDotProductProperties; -pub type FormatProperties3KHR = FormatProperties3; -pub type PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; -pub type RenderingInfoKHR = RenderingInfo; -pub type RenderingAttachmentInfoKHR = RenderingAttachmentInfo; -pub type PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; -pub type CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; -pub type AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; +pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR<'a> = + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a>; +pub type PhysicalDeviceImageRobustnessFeaturesEXT<'a> = PhysicalDeviceImageRobustnessFeatures<'a>; +pub type BufferCopy2KHR<'a> = BufferCopy2<'a>; +pub type ImageCopy2KHR<'a> = ImageCopy2<'a>; +pub type ImageBlit2KHR<'a> = ImageBlit2<'a>; +pub type BufferImageCopy2KHR<'a> = BufferImageCopy2<'a>; +pub type ImageResolve2KHR<'a> = ImageResolve2<'a>; +pub type CopyBufferInfo2KHR<'a> = CopyBufferInfo2<'a>; +pub type CopyImageInfo2KHR<'a> = CopyImageInfo2<'a>; +pub type BlitImageInfo2KHR<'a> = BlitImageInfo2<'a>; +pub type CopyBufferToImageInfo2KHR<'a> = CopyBufferToImageInfo2<'a>; +pub type CopyImageToBufferInfo2KHR<'a> = CopyImageToBufferInfo2<'a>; +pub type ResolveImageInfo2KHR<'a> = ResolveImageInfo2<'a>; +pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR<'a> = + PhysicalDeviceShaderTerminateInvocationFeatures<'a>; +pub type MemoryBarrier2KHR<'a> = MemoryBarrier2<'a>; +pub type ImageMemoryBarrier2KHR<'a> = ImageMemoryBarrier2<'a>; +pub type BufferMemoryBarrier2KHR<'a> = BufferMemoryBarrier2<'a>; +pub type DependencyInfoKHR<'a> = DependencyInfo<'a>; +pub type SemaphoreSubmitInfoKHR<'a> = SemaphoreSubmitInfo<'a>; +pub type CommandBufferSubmitInfoKHR<'a> = CommandBufferSubmitInfo<'a>; +pub type SubmitInfo2KHR<'a> = SubmitInfo2<'a>; +pub type PhysicalDeviceSynchronization2FeaturesKHR<'a> = PhysicalDeviceSynchronization2Features<'a>; +pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR<'a> = + PhysicalDeviceShaderIntegerDotProductFeatures<'a>; +pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR<'a> = + PhysicalDeviceShaderIntegerDotProductProperties<'a>; +pub type FormatProperties3KHR<'a> = FormatProperties3<'a>; +pub type PipelineRenderingCreateInfoKHR<'a> = PipelineRenderingCreateInfo<'a>; +pub type RenderingInfoKHR<'a> = RenderingInfo<'a>; +pub type RenderingAttachmentInfoKHR<'a> = RenderingAttachmentInfo<'a>; +pub type PhysicalDeviceDynamicRenderingFeaturesKHR<'a> = PhysicalDeviceDynamicRenderingFeatures<'a>; +pub type CommandBufferInheritanceRenderingInfoKHR<'a> = CommandBufferInheritanceRenderingInfo<'a>; +pub type AttachmentSampleCountInfoNV<'a> = AttachmentSampleCountInfoAMD<'a>; diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 9e1c2c1..2f3e594 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -7,6 +7,7 @@ use crate::vk::platform_types::*; use crate::vk::prelude::*; use crate::vk::{ptr_chain_iter, Handle}; use std::fmt; +use std::marker::PhantomData; use std::os::raw::*; #[deprecated = "This define is deprecated. VK_MAKE_API_VERSION should be used instead."] #[doc = ""] @@ -501,15 +502,17 @@ pub type PFN_vkDeviceMemoryReportCallbackEXT = Option< #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BaseOutStructure { +pub struct BaseOutStructure<'a> { pub s_type: StructureType, pub p_next: *mut Self, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BaseOutStructure { +impl ::std::default::Default for BaseOutStructure<'_> { fn default() -> Self { Self { s_type: unsafe { ::std::mem::zeroed() }, p_next: ::std::ptr::null_mut(), + _marker: PhantomData, } } } @@ -517,15 +520,17 @@ impl ::std::default::Default for BaseOutStructure { #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BaseInStructure { +pub struct BaseInStructure<'a> { pub s_type: StructureType, pub p_next: *const Self, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BaseInStructure { +impl ::std::default::Default for BaseInStructure<'_> { fn default() -> Self { Self { s_type: unsafe { ::std::mem::zeroed() }, p_next: ::std::ptr::null(), + _marker: PhantomData, } } } @@ -538,44 +543,16 @@ pub struct Offset2D { pub y: i32, } impl Offset2D { - pub fn builder<'a>() -> Offset2DBuilder<'a> { - Offset2DBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Offset2DBuilder<'a> { - inner: Offset2D, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> { - type Target = Offset2D; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Offset2DBuilder<'a> { + #[inline] pub fn x(mut self, x: i32) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: i32) -> Self { - self.inner.y = y; + self.y = y; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Offset2D { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -587,48 +564,21 @@ pub struct Offset3D { pub z: i32, } impl Offset3D { - pub fn builder<'a>() -> Offset3DBuilder<'a> { - Offset3DBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Offset3DBuilder<'a> { - inner: Offset3D, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> { - type Target = Offset3D; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Offset3DBuilder<'a> { + #[inline] pub fn x(mut self, x: i32) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: i32) -> Self { - self.inner.y = y; + self.y = y; self } + #[inline] pub fn z(mut self, z: i32) -> Self { - self.inner.z = z; + self.z = z; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Offset3D { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -639,44 +589,16 @@ pub struct Extent2D { pub height: u32, } impl Extent2D { - pub fn builder<'a>() -> Extent2DBuilder<'a> { - Extent2DBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Extent2DBuilder<'a> { - inner: Extent2D, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> { - type Target = Extent2D; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Extent2DBuilder<'a> { + #[inline] pub fn width(mut self, width: u32) -> Self { - self.inner.width = width; + self.width = width; self } + #[inline] pub fn height(mut self, height: u32) -> Self { - self.inner.height = height; + self.height = height; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Extent2D { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -688,48 +610,21 @@ pub struct Extent3D { pub depth: u32, } impl Extent3D { - pub fn builder<'a>() -> Extent3DBuilder<'a> { - Extent3DBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Extent3DBuilder<'a> { - inner: Extent3D, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> { - type Target = Extent3D; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Extent3DBuilder<'a> { + #[inline] pub fn width(mut self, width: u32) -> Self { - self.inner.width = width; + self.width = width; self } + #[inline] pub fn height(mut self, height: u32) -> Self { - self.inner.height = height; + self.height = height; self } + #[inline] pub fn depth(mut self, depth: u32) -> Self { - self.inner.depth = depth; + self.depth = depth; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Extent3D { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -744,60 +639,36 @@ pub struct Viewport { pub max_depth: f32, } impl Viewport { - pub fn builder<'a>() -> ViewportBuilder<'a> { - ViewportBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ViewportBuilder<'a> { - inner: Viewport, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ViewportBuilder<'a> { - type Target = Viewport; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ViewportBuilder<'a> { + #[inline] pub fn x(mut self, x: f32) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: f32) -> Self { - self.inner.y = y; + self.y = y; self } + #[inline] pub fn width(mut self, width: f32) -> Self { - self.inner.width = width; + self.width = width; self } + #[inline] pub fn height(mut self, height: f32) -> Self { - self.inner.height = height; + self.height = height; self } + #[inline] pub fn min_depth(mut self, min_depth: f32) -> Self { - self.inner.min_depth = min_depth; + self.min_depth = min_depth; self } + #[inline] pub fn max_depth(mut self, max_depth: f32) -> Self { - self.inner.max_depth = max_depth; + self.max_depth = max_depth; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Viewport { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -808,44 +679,16 @@ pub struct Rect2D { pub extent: Extent2D, } impl Rect2D { - pub fn builder<'a>() -> Rect2DBuilder<'a> { - Rect2DBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Rect2DBuilder<'a> { - inner: Rect2D, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> { - type Target = Rect2D; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Rect2DBuilder<'a> { + #[inline] pub fn offset(mut self, offset: Offset2D) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn extent(mut self, extent: Extent2D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Rect2D { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -857,48 +700,21 @@ pub struct ClearRect { pub layer_count: u32, } impl ClearRect { - pub fn builder<'a>() -> ClearRectBuilder<'a> { - ClearRectBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ClearRectBuilder<'a> { - inner: ClearRect, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> { - type Target = ClearRect; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ClearRectBuilder<'a> { + #[inline] pub fn rect(mut self, rect: Rect2D) -> Self { - self.inner.rect = rect; + self.rect = rect; self } + #[inline] pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { - self.inner.base_array_layer = base_array_layer; + self.base_array_layer = base_array_layer; self } + #[inline] pub fn layer_count(mut self, layer_count: u32) -> Self { - self.inner.layer_count = layer_count; + self.layer_count = layer_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ClearRect { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -911,52 +727,26 @@ pub struct ComponentMapping { pub a: ComponentSwizzle, } impl ComponentMapping { - pub fn builder<'a>() -> ComponentMappingBuilder<'a> { - ComponentMappingBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ComponentMappingBuilder<'a> { - inner: ComponentMapping, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> { - type Target = ComponentMapping; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ComponentMappingBuilder<'a> { + #[inline] pub fn r(mut self, r: ComponentSwizzle) -> Self { - self.inner.r = r; + self.r = r; self } + #[inline] pub fn g(mut self, g: ComponentSwizzle) -> Self { - self.inner.g = g; + self.g = g; self } + #[inline] pub fn b(mut self, b: ComponentSwizzle) -> Self { - self.inner.b = b; + self.b = b; self } + #[inline] pub fn a(mut self, a: ComponentSwizzle) -> Self { - self.inner.a = a; + self.a = a; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ComponentMapping { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -1006,72 +796,51 @@ impl ::std::default::Default for PhysicalDeviceProperties { } } impl PhysicalDeviceProperties { - pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> { - PhysicalDevicePropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePropertiesBuilder<'a> { - inner: PhysicalDeviceProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> { - type Target = PhysicalDeviceProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePropertiesBuilder<'a> { + #[inline] pub fn api_version(mut self, api_version: u32) -> Self { - self.inner.api_version = api_version; + self.api_version = api_version; self } + #[inline] pub fn driver_version(mut self, driver_version: u32) -> Self { - self.inner.driver_version = driver_version; + self.driver_version = driver_version; self } + #[inline] pub fn vendor_id(mut self, vendor_id: u32) -> Self { - self.inner.vendor_id = vendor_id; + self.vendor_id = vendor_id; self } + #[inline] pub fn device_id(mut self, device_id: u32) -> Self { - self.inner.device_id = device_id; + self.device_id = device_id; self } + #[inline] pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self { - self.inner.device_type = device_type; + self.device_type = device_type; self } + #[inline] pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self { - self.inner.device_name = device_name; + self.device_name = device_name; self } + #[inline] pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { - self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self.pipeline_cache_uuid = pipeline_cache_uuid; self } + #[inline] pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self { - self.inner.limits = limits; + self.limits = limits; self } + #[inline] pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self { - self.inner.sparse_properties = sparse_properties; + self.sparse_properties = sparse_properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceProperties { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -1100,44 +869,16 @@ impl ::std::default::Default for ExtensionProperties { } } impl ExtensionProperties { - pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> { - ExtensionPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExtensionPropertiesBuilder<'a> { - inner: ExtensionProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> { - type Target = ExtensionProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExtensionPropertiesBuilder<'a> { + #[inline] pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { - self.inner.extension_name = extension_name; + self.extension_name = extension_name; self } + #[inline] pub fn spec_version(mut self, spec_version: u32) -> Self { - self.inner.spec_version = spec_version; + self.spec_version = spec_version; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExtensionProperties { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -1174,58 +915,32 @@ impl ::std::default::Default for LayerProperties { } } impl LayerProperties { - pub fn builder<'a>() -> LayerPropertiesBuilder<'a> { - LayerPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct LayerPropertiesBuilder<'a> { - inner: LayerProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> { - type Target = LayerProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> LayerPropertiesBuilder<'a> { + #[inline] pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { - self.inner.layer_name = layer_name; + self.layer_name = layer_name; self } + #[inline] pub fn spec_version(mut self, spec_version: u32) -> Self { - self.inner.spec_version = spec_version; + self.spec_version = spec_version; self } + #[inline] pub fn implementation_version(mut self, implementation_version: u32) -> Self { - self.inner.implementation_version = implementation_version; + self.implementation_version = implementation_version; self } + #[inline] pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.description = description; + self.description = description; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> LayerProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ApplicationInfo { +pub struct ApplicationInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_application_name: *const c_char, @@ -1233,8 +948,9 @@ pub struct ApplicationInfo { pub p_engine_name: *const c_char, pub engine_version: u32, pub api_version: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ApplicationInfo { +impl ::std::default::Default for ApplicationInfo<'_> { fn default() -> Self { Self { s_type: StructureType::APPLICATION_INFO, @@ -1244,74 +960,51 @@ impl ::std::default::Default for ApplicationInfo { p_engine_name: ::std::ptr::null(), engine_version: u32::default(), api_version: u32::default(), + _marker: PhantomData, } } } -impl ApplicationInfo { - pub fn builder<'a>() -> ApplicationInfoBuilder<'a> { - ApplicationInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ApplicationInfoBuilder<'a> { - inner: ApplicationInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { - type Target = ApplicationInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ApplicationInfoBuilder<'a> { +impl<'a> ApplicationInfo<'a> { + #[inline] pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_application_name = application_name.as_ptr(); + self.p_application_name = application_name.as_ptr(); self } + #[inline] pub fn application_version(mut self, application_version: u32) -> Self { - self.inner.application_version = application_version; + self.application_version = application_version; self } + #[inline] pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_engine_name = engine_name.as_ptr(); + self.p_engine_name = engine_name.as_ptr(); self } + #[inline] pub fn engine_version(mut self, engine_version: u32) -> Self { - self.inner.engine_version = engine_version; + self.engine_version = engine_version; self } + #[inline] pub fn api_version(mut self, api_version: u32) -> Self { - self.inner.api_version = api_version; + self.api_version = api_version; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ApplicationInfo { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AllocationCallbacks { +pub struct AllocationCallbacks<'a> { pub p_user_data: *mut c_void, pub pfn_allocation: PFN_vkAllocationFunction, pub pfn_reallocation: PFN_vkReallocationFunction, pub pfn_free: PFN_vkFreeFunction, pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, pub pfn_internal_free: PFN_vkInternalFreeNotification, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AllocationCallbacks { +impl fmt::Debug for AllocationCallbacks<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AllocationCallbacks") .field("p_user_data", &self.p_user_data) @@ -1335,7 +1028,7 @@ impl fmt::Debug for AllocationCallbacks { .finish() } } -impl ::std::default::Default for AllocationCallbacks { +impl ::std::default::Default for AllocationCallbacks<'_> { fn default() -> Self { Self { p_user_data: ::std::ptr::null_mut(), @@ -1344,81 +1037,59 @@ impl ::std::default::Default for AllocationCallbacks { pfn_free: PFN_vkFreeFunction::default(), pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(), pfn_internal_free: PFN_vkInternalFreeNotification::default(), + _marker: PhantomData, } } } -impl AllocationCallbacks { - pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> { - AllocationCallbacksBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AllocationCallbacksBuilder<'a> { - inner: AllocationCallbacks, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> { - type Target = AllocationCallbacks; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AllocationCallbacksBuilder<'a> { +impl<'a> AllocationCallbacks<'a> { + #[inline] pub fn user_data(mut self, user_data: *mut c_void) -> Self { - self.inner.p_user_data = user_data; + self.p_user_data = user_data; self } + #[inline] pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self { - self.inner.pfn_allocation = pfn_allocation; + self.pfn_allocation = pfn_allocation; self } + #[inline] pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self { - self.inner.pfn_reallocation = pfn_reallocation; + self.pfn_reallocation = pfn_reallocation; self } + #[inline] pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self { - self.inner.pfn_free = pfn_free; + self.pfn_free = pfn_free; self } + #[inline] pub fn pfn_internal_allocation( mut self, pfn_internal_allocation: PFN_vkInternalAllocationNotification, ) -> Self { - self.inner.pfn_internal_allocation = pfn_internal_allocation; + self.pfn_internal_allocation = pfn_internal_allocation; self } + #[inline] pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self { - self.inner.pfn_internal_free = pfn_internal_free; + self.pfn_internal_free = pfn_internal_free; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AllocationCallbacks { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceQueueCreateInfo { +pub struct DeviceQueueCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceQueueCreateFlags, pub queue_family_index: u32, pub queue_count: u32, pub p_queue_priorities: *const f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceQueueCreateInfo { +impl ::std::default::Default for DeviceQueueCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_QUEUE_CREATE_INFO, @@ -1427,86 +1098,61 @@ impl ::std::default::Default for DeviceQueueCreateInfo { queue_family_index: u32::default(), queue_count: u32::default(), p_queue_priorities: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DeviceQueueCreateInfo { - pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> { - DeviceQueueCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceQueueCreateInfoBuilder<'a> { - inner: DeviceQueueCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsDeviceQueueCreateInfo {} -impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> { - type Target = DeviceQueueCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceQueueCreateInfoBuilder<'a> { +impl<'a> DeviceQueueCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { - self.inner.queue_family_index = queue_family_index; + self.queue_family_index = queue_family_index; self } + #[inline] pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self { - self.inner.queue_count = queue_priorities.len() as _; - self.inner.p_queue_priorities = queue_priorities.as_ptr(); + self.queue_count = queue_priorities.len() as _; + self.p_queue_priorities = queue_priorities.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceQueueCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceCreateInfo { +pub struct DeviceCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceCreateFlags, pub queue_create_info_count: u32, - pub p_queue_create_infos: *const DeviceQueueCreateInfo, + pub p_queue_create_infos: *const DeviceQueueCreateInfo<'a>, pub enabled_layer_count: u32, pub pp_enabled_layer_names: *const *const c_char, pub enabled_extension_count: u32, pub pp_enabled_extension_names: *const *const c_char, pub p_enabled_features: *const PhysicalDeviceFeatures, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceCreateInfo { +impl ::std::default::Default for DeviceCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_CREATE_INFO, @@ -1519,94 +1165,71 @@ impl ::std::default::Default for DeviceCreateInfo { enabled_extension_count: u32::default(), pp_enabled_extension_names: ::std::ptr::null(), p_enabled_features: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DeviceCreateInfo { - pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> { - DeviceCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceCreateInfoBuilder<'a> { - inner: DeviceCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsDeviceCreateInfo {} -impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> { - type Target = DeviceCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceCreateInfoBuilder<'a> { +impl<'a> DeviceCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: DeviceCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self { - self.inner.queue_create_info_count = queue_create_infos.len() as _; - self.inner.p_queue_create_infos = queue_create_infos.as_ptr(); + self.queue_create_info_count = queue_create_infos.len() as _; + self.p_queue_create_infos = queue_create_infos.as_ptr(); self } + #[inline] pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self { - self.inner.enabled_layer_count = enabled_layer_names.len() as _; - self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self.enabled_layer_count = enabled_layer_names.len() as _; + self.pp_enabled_layer_names = enabled_layer_names.as_ptr(); self } + #[inline] pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self { - self.inner.enabled_extension_count = enabled_extension_names.len() as _; - self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self.enabled_extension_count = enabled_extension_names.len() as _; + self.pp_enabled_extension_names = enabled_extension_names.as_ptr(); self } + #[inline] pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self { - self.inner.p_enabled_features = enabled_features; + self.p_enabled_features = enabled_features; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct InstanceCreateInfo { +pub struct InstanceCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: InstanceCreateFlags, - pub p_application_info: *const ApplicationInfo, + pub p_application_info: *const ApplicationInfo<'a>, pub enabled_layer_count: u32, pub pp_enabled_layer_names: *const *const c_char, pub enabled_extension_count: u32, pub pp_enabled_extension_names: *const *const c_char, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for InstanceCreateInfo { +impl ::std::default::Default for InstanceCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::INSTANCE_CREATE_INFO, @@ -1617,73 +1240,48 @@ impl ::std::default::Default for InstanceCreateInfo { pp_enabled_layer_names: ::std::ptr::null(), enabled_extension_count: u32::default(), pp_enabled_extension_names: ::std::ptr::null(), + _marker: PhantomData, } } } -impl InstanceCreateInfo { - pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> { - InstanceCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct InstanceCreateInfoBuilder<'a> { - inner: InstanceCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsInstanceCreateInfo {} -impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> { - type Target = InstanceCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> InstanceCreateInfoBuilder<'a> { +impl<'a> InstanceCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: InstanceCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self { - self.inner.p_application_info = application_info; + #[inline] + pub fn application_info(mut self, application_info: &'a ApplicationInfo<'a>) -> Self { + self.p_application_info = application_info; self } + #[inline] pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self { - self.inner.enabled_layer_count = enabled_layer_names.len() as _; - self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self.enabled_layer_count = enabled_layer_names.len() as _; + self.pp_enabled_layer_names = enabled_layer_names.as_ptr(); self } + #[inline] pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self { - self.inner.enabled_extension_count = enabled_extension_names.len() as _; - self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self.enabled_extension_count = enabled_extension_names.len() as _; + self.pp_enabled_extension_names = enabled_extension_names.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> InstanceCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -1696,55 +1294,29 @@ pub struct QueueFamilyProperties { pub min_image_transfer_granularity: Extent3D, } impl QueueFamilyProperties { - pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> { - QueueFamilyPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueueFamilyPropertiesBuilder<'a> { - inner: QueueFamilyProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> { - type Target = QueueFamilyProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueueFamilyPropertiesBuilder<'a> { + #[inline] pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self { - self.inner.queue_flags = queue_flags; + self.queue_flags = queue_flags; self } + #[inline] pub fn queue_count(mut self, queue_count: u32) -> Self { - self.inner.queue_count = queue_count; + self.queue_count = queue_count; self } + #[inline] pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self { - self.inner.timestamp_valid_bits = timestamp_valid_bits; + self.timestamp_valid_bits = timestamp_valid_bits; self } + #[inline] pub fn min_image_transfer_granularity( mut self, min_image_transfer_granularity: Extent3D, ) -> Self { - self.inner.min_image_transfer_granularity = min_image_transfer_granularity; + self.min_image_transfer_granularity = min_image_transfer_granularity; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueueFamilyProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -1767,127 +1339,75 @@ impl ::std::default::Default for PhysicalDeviceMemoryProperties { } } impl PhysicalDeviceMemoryProperties { - pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> { - PhysicalDeviceMemoryPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> { - inner: PhysicalDeviceMemoryProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> { - type Target = PhysicalDeviceMemoryProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> { + #[inline] pub fn memory_type_count(mut self, memory_type_count: u32) -> Self { - self.inner.memory_type_count = memory_type_count; + self.memory_type_count = memory_type_count; self } + #[inline] pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self { - self.inner.memory_types = memory_types; + self.memory_types = memory_types; self } + #[inline] pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self { - self.inner.memory_heap_count = memory_heap_count; + self.memory_heap_count = memory_heap_count; self } + #[inline] pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self { - self.inner.memory_heaps = memory_heaps; + self.memory_heaps = memory_heaps; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMemoryProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryAllocateInfo { +pub struct MemoryAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub allocation_size: DeviceSize, pub memory_type_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryAllocateInfo { +impl ::std::default::Default for MemoryAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_ALLOCATE_INFO, p_next: ::std::ptr::null(), allocation_size: DeviceSize::default(), memory_type_index: u32::default(), + _marker: PhantomData, } } } -impl MemoryAllocateInfo { - pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> { - MemoryAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryAllocateInfoBuilder<'a> { - inner: MemoryAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsMemoryAllocateInfo {} -impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> { - type Target = MemoryAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryAllocateInfoBuilder<'a> { +impl<'a> MemoryAllocateInfo<'a> { + #[inline] pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { - self.inner.allocation_size = allocation_size; + self.allocation_size = allocation_size; self } + #[inline] pub fn memory_type_index(mut self, memory_type_index: u32) -> Self { - self.inner.memory_type_index = memory_type_index; + self.memory_type_index = memory_type_index; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -1899,48 +1419,21 @@ pub struct MemoryRequirements { pub memory_type_bits: u32, } impl MemoryRequirements { - pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> { - MemoryRequirementsBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryRequirementsBuilder<'a> { - inner: MemoryRequirements, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> { - type Target = MemoryRequirements; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryRequirementsBuilder<'a> { + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn alignment(mut self, alignment: DeviceSize) -> Self { - self.inner.alignment = alignment; + self.alignment = alignment; self } + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryRequirements { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -1952,48 +1445,21 @@ pub struct SparseImageFormatProperties { pub flags: SparseImageFormatFlags, } impl SparseImageFormatProperties { - pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> { - SparseImageFormatPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageFormatPropertiesBuilder<'a> { - inner: SparseImageFormatProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> { - type Target = SparseImageFormatProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageFormatPropertiesBuilder<'a> { + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } + #[inline] pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self { - self.inner.image_granularity = image_granularity; + self.image_granularity = image_granularity; self } + #[inline] pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageFormatProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2007,56 +1473,31 @@ pub struct SparseImageMemoryRequirements { pub image_mip_tail_stride: DeviceSize, } impl SparseImageMemoryRequirements { - pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> { - SparseImageMemoryRequirementsBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageMemoryRequirementsBuilder<'a> { - inner: SparseImageMemoryRequirements, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> { - type Target = SparseImageMemoryRequirements; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageMemoryRequirementsBuilder<'a> { + #[inline] pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self { - self.inner.format_properties = format_properties; + self.format_properties = format_properties; self } + #[inline] pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self { - self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod; + self.image_mip_tail_first_lod = image_mip_tail_first_lod; self } + #[inline] pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self { - self.inner.image_mip_tail_size = image_mip_tail_size; + self.image_mip_tail_size = image_mip_tail_size; self } + #[inline] pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self { - self.inner.image_mip_tail_offset = image_mip_tail_offset; + self.image_mip_tail_offset = image_mip_tail_offset; self } + #[inline] pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self { - self.inner.image_mip_tail_stride = image_mip_tail_stride; + self.image_mip_tail_stride = image_mip_tail_stride; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageMemoryRequirements { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2067,44 +1508,16 @@ pub struct MemoryType { pub heap_index: u32, } impl MemoryType { - pub fn builder<'a>() -> MemoryTypeBuilder<'a> { - MemoryTypeBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryTypeBuilder<'a> { - inner: MemoryType, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> { - type Target = MemoryType; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryTypeBuilder<'a> { + #[inline] pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self { - self.inner.property_flags = property_flags; + self.property_flags = property_flags; self } + #[inline] pub fn heap_index(mut self, heap_index: u32) -> Self { - self.inner.heap_index = heap_index; + self.heap_index = heap_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryType { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2115,57 +1528,30 @@ pub struct MemoryHeap { pub flags: MemoryHeapFlags, } impl MemoryHeap { - pub fn builder<'a>() -> MemoryHeapBuilder<'a> { - MemoryHeapBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryHeapBuilder<'a> { - inner: MemoryHeap, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> { - type Target = MemoryHeap; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryHeapBuilder<'a> { + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn flags(mut self, flags: MemoryHeapFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryHeap { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MappedMemoryRange { +pub struct MappedMemoryRange<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, pub offset: DeviceSize, pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MappedMemoryRange { +impl ::std::default::Default for MappedMemoryRange<'_> { fn default() -> Self { Self { s_type: StructureType::MAPPED_MEMORY_RANGE, @@ -2173,52 +1559,26 @@ impl ::std::default::Default for MappedMemoryRange { memory: DeviceMemory::default(), offset: DeviceSize::default(), size: DeviceSize::default(), + _marker: PhantomData, } } } -impl MappedMemoryRange { - pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> { - MappedMemoryRangeBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MappedMemoryRangeBuilder<'a> { - inner: MappedMemoryRange, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { - type Target = MappedMemoryRange; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MappedMemoryRangeBuilder<'a> { +impl<'a> MappedMemoryRange<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MappedMemoryRange { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2230,48 +1590,21 @@ pub struct FormatProperties { pub buffer_features: FormatFeatureFlags, } impl FormatProperties { - pub fn builder<'a>() -> FormatPropertiesBuilder<'a> { - FormatPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FormatPropertiesBuilder<'a> { - inner: FormatProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> { - type Target = FormatProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FormatPropertiesBuilder<'a> { + #[inline] pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self { - self.inner.linear_tiling_features = linear_tiling_features; + self.linear_tiling_features = linear_tiling_features; self } + #[inline] pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self { - self.inner.optimal_tiling_features = optimal_tiling_features; + self.optimal_tiling_features = optimal_tiling_features; self } + #[inline] pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self { - self.inner.buffer_features = buffer_features; + self.buffer_features = buffer_features; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FormatProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2285,56 +1618,31 @@ pub struct ImageFormatProperties { pub max_resource_size: DeviceSize, } impl ImageFormatProperties { - pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> { - ImageFormatPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageFormatPropertiesBuilder<'a> { - inner: ImageFormatProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> { - type Target = ImageFormatProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageFormatPropertiesBuilder<'a> { + #[inline] pub fn max_extent(mut self, max_extent: Extent3D) -> Self { - self.inner.max_extent = max_extent; + self.max_extent = max_extent; self } + #[inline] pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self { - self.inner.max_mip_levels = max_mip_levels; + self.max_mip_levels = max_mip_levels; self } + #[inline] pub fn max_array_layers(mut self, max_array_layers: u32) -> Self { - self.inner.max_array_layers = max_array_layers; + self.max_array_layers = max_array_layers; self } + #[inline] pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self { - self.inner.sample_counts = sample_counts; + self.sample_counts = sample_counts; self } + #[inline] pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self { - self.inner.max_resource_size = max_resource_size; + self.max_resource_size = max_resource_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageFormatProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2346,48 +1654,21 @@ pub struct DescriptorBufferInfo { pub range: DeviceSize, } impl DescriptorBufferInfo { - pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> { - DescriptorBufferInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorBufferInfoBuilder<'a> { - inner: DescriptorBufferInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> { - type Target = DescriptorBufferInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorBufferInfoBuilder<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn range(mut self, range: DeviceSize) -> Self { - self.inner.range = range; + self.range = range; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorBufferInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2399,54 +1680,27 @@ pub struct DescriptorImageInfo { pub image_layout: ImageLayout, } impl DescriptorImageInfo { - pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> { - DescriptorImageInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorImageInfoBuilder<'a> { - inner: DescriptorImageInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> { - type Target = DescriptorImageInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorImageInfoBuilder<'a> { + #[inline] pub fn sampler(mut self, sampler: Sampler) -> Self { - self.inner.sampler = sampler; + self.sampler = sampler; self } + #[inline] pub fn image_view(mut self, image_view: ImageView) -> Self { - self.inner.image_view = image_view; + self.image_view = image_view; self } + #[inline] pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.inner.image_layout = image_layout; + self.image_layout = image_layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorImageInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct WriteDescriptorSet { +pub struct WriteDescriptorSet<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub dst_set: DescriptorSet, @@ -2457,8 +1711,9 @@ pub struct WriteDescriptorSet { pub p_image_info: *const DescriptorImageInfo, pub p_buffer_info: *const DescriptorBufferInfo, pub p_texel_buffer_view: *const BufferView, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for WriteDescriptorSet { +impl ::std::default::Default for WriteDescriptorSet<'_> { fn default() -> Self { Self { s_type: StructureType::WRITE_DESCRIPTOR_SET, @@ -2471,92 +1726,70 @@ impl ::std::default::Default for WriteDescriptorSet { p_image_info: ::std::ptr::null(), p_buffer_info: ::std::ptr::null(), p_texel_buffer_view: ::std::ptr::null(), + _marker: PhantomData, } } } -impl WriteDescriptorSet { - pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> { - WriteDescriptorSetBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct WriteDescriptorSetBuilder<'a> { - inner: WriteDescriptorSet, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsWriteDescriptorSet {} -impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> { - type Target = WriteDescriptorSet; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> WriteDescriptorSetBuilder<'a> { +impl<'a> WriteDescriptorSet<'a> { + #[inline] pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self { - self.inner.dst_set = dst_set; + self.dst_set = dst_set; self } + #[inline] pub fn dst_binding(mut self, dst_binding: u32) -> Self { - self.inner.dst_binding = dst_binding; + self.dst_binding = dst_binding; self } + #[inline] pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { - self.inner.dst_array_element = dst_array_element; + self.dst_array_element = dst_array_element; self } + #[inline] pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { - self.inner.descriptor_type = descriptor_type; + self.descriptor_type = descriptor_type; self } + #[inline] pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self { - self.inner.descriptor_count = image_info.len() as _; - self.inner.p_image_info = image_info.as_ptr(); + self.descriptor_count = image_info.len() as _; + self.p_image_info = image_info.as_ptr(); self } + #[inline] pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self { - self.inner.descriptor_count = buffer_info.len() as _; - self.inner.p_buffer_info = buffer_info.as_ptr(); + self.descriptor_count = buffer_info.len() as _; + self.p_buffer_info = buffer_info.as_ptr(); self } + #[inline] pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self { - self.inner.descriptor_count = texel_buffer_view.len() as _; - self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr(); + self.descriptor_count = texel_buffer_view.len() as _; + self.p_texel_buffer_view = texel_buffer_view.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> WriteDescriptorSet { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyDescriptorSet { +pub struct CopyDescriptorSet<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_set: DescriptorSet, @@ -2566,8 +1799,9 @@ pub struct CopyDescriptorSet { pub dst_binding: u32, pub dst_array_element: u32, pub descriptor_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyDescriptorSet { +impl ::std::default::Default for CopyDescriptorSet<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_DESCRIPTOR_SET, @@ -2579,74 +1813,52 @@ impl ::std::default::Default for CopyDescriptorSet { dst_binding: u32::default(), dst_array_element: u32::default(), descriptor_count: u32::default(), + _marker: PhantomData, } } } -impl CopyDescriptorSet { - pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> { - CopyDescriptorSetBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyDescriptorSetBuilder<'a> { - inner: CopyDescriptorSet, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { - type Target = CopyDescriptorSet; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyDescriptorSetBuilder<'a> { +impl<'a> CopyDescriptorSet<'a> { + #[inline] pub fn src_set(mut self, src_set: DescriptorSet) -> Self { - self.inner.src_set = src_set; + self.src_set = src_set; self } + #[inline] pub fn src_binding(mut self, src_binding: u32) -> Self { - self.inner.src_binding = src_binding; + self.src_binding = src_binding; self } + #[inline] pub fn src_array_element(mut self, src_array_element: u32) -> Self { - self.inner.src_array_element = src_array_element; + self.src_array_element = src_array_element; self } + #[inline] pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self { - self.inner.dst_set = dst_set; + self.dst_set = dst_set; self } + #[inline] pub fn dst_binding(mut self, dst_binding: u32) -> Self { - self.inner.dst_binding = dst_binding; + self.dst_binding = dst_binding; self } + #[inline] pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { - self.inner.dst_array_element = dst_array_element; + self.dst_array_element = dst_array_element; self } + #[inline] pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { - self.inner.descriptor_count = descriptor_count; + self.descriptor_count = descriptor_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyDescriptorSet { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCreateInfo { +pub struct BufferCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: BufferCreateFlags, @@ -2655,8 +1867,9 @@ pub struct BufferCreateInfo { pub sharing_mode: SharingMode, pub queue_family_index_count: u32, pub p_queue_family_indices: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCreateInfo { +impl ::std::default::Default for BufferCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_CREATE_INFO, @@ -2667,82 +1880,58 @@ impl ::std::default::Default for BufferCreateInfo { sharing_mode: SharingMode::default(), queue_family_index_count: u32::default(), p_queue_family_indices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl BufferCreateInfo { - pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> { - BufferCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCreateInfoBuilder<'a> { - inner: BufferCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsBufferCreateInfo {} -impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> { - type Target = BufferCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCreateInfoBuilder<'a> { +impl<'a> BufferCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: BufferCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn usage(mut self, usage: BufferUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { - self.inner.sharing_mode = sharing_mode; + self.sharing_mode = sharing_mode; self } + #[inline] pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { - self.inner.queue_family_index_count = queue_family_indices.len() as _; - self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self.queue_family_index_count = queue_family_indices.len() as _; + self.p_queue_family_indices = queue_family_indices.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferViewCreateInfo { +pub struct BufferViewCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: BufferViewCreateFlags, @@ -2750,8 +1939,9 @@ pub struct BufferViewCreateInfo { pub format: Format, pub offset: DeviceSize, pub range: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferViewCreateInfo { +impl ::std::default::Default for BufferViewCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_VIEW_CREATE_INFO, @@ -2761,60 +1951,36 @@ impl ::std::default::Default for BufferViewCreateInfo { format: Format::default(), offset: DeviceSize::default(), range: DeviceSize::default(), + _marker: PhantomData, } } } -impl BufferViewCreateInfo { - pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> { - BufferViewCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferViewCreateInfoBuilder<'a> { - inner: BufferViewCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { - type Target = BufferViewCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferViewCreateInfoBuilder<'a> { +impl<'a> BufferViewCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn range(mut self, range: DeviceSize) -> Self { - self.inner.range = range; + self.range = range; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferViewCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2826,48 +1992,21 @@ pub struct ImageSubresource { pub array_layer: u32, } impl ImageSubresource { - pub fn builder<'a>() -> ImageSubresourceBuilder<'a> { - ImageSubresourceBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageSubresourceBuilder<'a> { - inner: ImageSubresource, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> { - type Target = ImageSubresource; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageSubresourceBuilder<'a> { + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } + #[inline] pub fn mip_level(mut self, mip_level: u32) -> Self { - self.inner.mip_level = mip_level; + self.mip_level = mip_level; self } + #[inline] pub fn array_layer(mut self, array_layer: u32) -> Self { - self.inner.array_layer = array_layer; + self.array_layer = array_layer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageSubresource { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2880,52 +2019,26 @@ pub struct ImageSubresourceLayers { pub layer_count: u32, } impl ImageSubresourceLayers { - pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> { - ImageSubresourceLayersBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageSubresourceLayersBuilder<'a> { - inner: ImageSubresourceLayers, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> { - type Target = ImageSubresourceLayers; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageSubresourceLayersBuilder<'a> { + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } + #[inline] pub fn mip_level(mut self, mip_level: u32) -> Self { - self.inner.mip_level = mip_level; + self.mip_level = mip_level; self } + #[inline] pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { - self.inner.base_array_layer = base_array_layer; + self.base_array_layer = base_array_layer; self } + #[inline] pub fn layer_count(mut self, layer_count: u32) -> Self { - self.inner.layer_count = layer_count; + self.layer_count = layer_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageSubresourceLayers { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -2939,122 +2052,71 @@ pub struct ImageSubresourceRange { pub layer_count: u32, } impl ImageSubresourceRange { - pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> { - ImageSubresourceRangeBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageSubresourceRangeBuilder<'a> { - inner: ImageSubresourceRange, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> { - type Target = ImageSubresourceRange; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageSubresourceRangeBuilder<'a> { + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } + #[inline] pub fn base_mip_level(mut self, base_mip_level: u32) -> Self { - self.inner.base_mip_level = base_mip_level; + self.base_mip_level = base_mip_level; self } + #[inline] pub fn level_count(mut self, level_count: u32) -> Self { - self.inner.level_count = level_count; + self.level_count = level_count; self } + #[inline] pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { - self.inner.base_array_layer = base_array_layer; + self.base_array_layer = base_array_layer; self } + #[inline] pub fn layer_count(mut self, layer_count: u32) -> Self { - self.inner.layer_count = layer_count; + self.layer_count = layer_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageSubresourceRange { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryBarrier { +pub struct MemoryBarrier<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_access_mask: AccessFlags, pub dst_access_mask: AccessFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryBarrier { +impl ::std::default::Default for MemoryBarrier<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_BARRIER, p_next: ::std::ptr::null(), src_access_mask: AccessFlags::default(), dst_access_mask: AccessFlags::default(), + _marker: PhantomData, } } } -impl MemoryBarrier { - pub fn builder<'a>() -> MemoryBarrierBuilder<'a> { - MemoryBarrierBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryBarrierBuilder<'a> { - inner: MemoryBarrier, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { - type Target = MemoryBarrier; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryBarrierBuilder<'a> { +impl<'a> MemoryBarrier<'a> { + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryBarrier { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferMemoryBarrier { +pub struct BufferMemoryBarrier<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_access_mask: AccessFlags, @@ -3064,8 +2126,9 @@ pub struct BufferMemoryBarrier { pub buffer: Buffer, pub offset: DeviceSize, pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferMemoryBarrier { +impl ::std::default::Default for BufferMemoryBarrier<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_MEMORY_BARRIER, @@ -3077,74 +2140,52 @@ impl ::std::default::Default for BufferMemoryBarrier { buffer: Buffer::default(), offset: DeviceSize::default(), size: DeviceSize::default(), + _marker: PhantomData, } } } -impl BufferMemoryBarrier { - pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> { - BufferMemoryBarrierBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferMemoryBarrierBuilder<'a> { - inner: BufferMemoryBarrier, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { - type Target = BufferMemoryBarrier; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferMemoryBarrierBuilder<'a> { +impl<'a> BufferMemoryBarrier<'a> { + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } + #[inline] pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { - self.inner.src_queue_family_index = src_queue_family_index; + self.src_queue_family_index = src_queue_family_index; self } + #[inline] pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { - self.inner.dst_queue_family_index = dst_queue_family_index; + self.dst_queue_family_index = dst_queue_family_index; self } + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferMemoryBarrier { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageMemoryBarrier { +pub struct ImageMemoryBarrier<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_access_mask: AccessFlags, @@ -3155,8 +2196,9 @@ pub struct ImageMemoryBarrier { pub dst_queue_family_index: u32, pub image: Image, pub subresource_range: ImageSubresourceRange, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageMemoryBarrier { +impl ::std::default::Default for ImageMemoryBarrier<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_MEMORY_BARRIER, @@ -3169,93 +2211,72 @@ impl ::std::default::Default for ImageMemoryBarrier { dst_queue_family_index: u32::default(), image: Image::default(), subresource_range: ImageSubresourceRange::default(), + _marker: PhantomData, } } } -impl ImageMemoryBarrier { - pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> { - ImageMemoryBarrierBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageMemoryBarrierBuilder<'a> { - inner: ImageMemoryBarrier, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageMemoryBarrier {} -impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> { - type Target = ImageMemoryBarrier; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageMemoryBarrierBuilder<'a> { +impl<'a> ImageMemoryBarrier<'a> { + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } + #[inline] pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { - self.inner.old_layout = old_layout; + self.old_layout = old_layout; self } + #[inline] pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { - self.inner.new_layout = new_layout; + self.new_layout = new_layout; self } + #[inline] pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { - self.inner.src_queue_family_index = src_queue_family_index; + self.src_queue_family_index = src_queue_family_index; self } + #[inline] pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { - self.inner.dst_queue_family_index = dst_queue_family_index; + self.dst_queue_family_index = dst_queue_family_index; self } + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { - self.inner.subresource_range = subresource_range; + self.subresource_range = subresource_range; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageMemoryBarrier { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageCreateInfo { +pub struct ImageCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ImageCreateFlags, @@ -3271,8 +2292,9 @@ pub struct ImageCreateInfo { pub queue_family_index_count: u32, pub p_queue_family_indices: *const u32, pub initial_layout: ImageLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageCreateInfo { +impl ::std::default::Default for ImageCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_CREATE_INFO, @@ -3290,104 +2312,87 @@ impl ::std::default::Default for ImageCreateInfo { queue_family_index_count: u32::default(), p_queue_family_indices: ::std::ptr::null(), initial_layout: ImageLayout::default(), + _marker: PhantomData, } } } -impl ImageCreateInfo { - pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> { - ImageCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageCreateInfoBuilder<'a> { - inner: ImageCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageCreateInfo {} -impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> { - type Target = ImageCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageCreateInfoBuilder<'a> { +impl<'a> ImageCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: ImageCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn image_type(mut self, image_type: ImageType) -> Self { - self.inner.image_type = image_type; + self.image_type = image_type; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn extent(mut self, extent: Extent3D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } + #[inline] pub fn mip_levels(mut self, mip_levels: u32) -> Self { - self.inner.mip_levels = mip_levels; + self.mip_levels = mip_levels; self } + #[inline] pub fn array_layers(mut self, array_layers: u32) -> Self { - self.inner.array_layers = array_layers; + self.array_layers = array_layers; self } + #[inline] pub fn samples(mut self, samples: SampleCountFlags) -> Self { - self.inner.samples = samples; + self.samples = samples; self } + #[inline] pub fn tiling(mut self, tiling: ImageTiling) -> Self { - self.inner.tiling = tiling; + self.tiling = tiling; self } + #[inline] pub fn usage(mut self, usage: ImageUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { - self.inner.sharing_mode = sharing_mode; + self.sharing_mode = sharing_mode; self } + #[inline] pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { - self.inner.queue_family_index_count = queue_family_indices.len() as _; - self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self.queue_family_index_count = queue_family_indices.len() as _; + self.p_queue_family_indices = queue_family_indices.as_ptr(); self } + #[inline] pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { - self.inner.initial_layout = initial_layout; + self.initial_layout = initial_layout; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -3401,62 +2406,37 @@ pub struct SubresourceLayout { pub depth_pitch: DeviceSize, } impl SubresourceLayout { - pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> { - SubresourceLayoutBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubresourceLayoutBuilder<'a> { - inner: SubresourceLayout, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> { - type Target = SubresourceLayout; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubresourceLayoutBuilder<'a> { + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self { - self.inner.row_pitch = row_pitch; + self.row_pitch = row_pitch; self } + #[inline] pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self { - self.inner.array_pitch = array_pitch; + self.array_pitch = array_pitch; self } + #[inline] pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self { - self.inner.depth_pitch = depth_pitch; + self.depth_pitch = depth_pitch; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubresourceLayout { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageViewCreateInfo { +pub struct ImageViewCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ImageViewCreateFlags, @@ -3465,8 +2445,9 @@ pub struct ImageViewCreateInfo { pub format: Format, pub components: ComponentMapping, pub subresource_range: ImageSubresourceRange, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageViewCreateInfo { +impl ::std::default::Default for ImageViewCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_VIEW_CREATE_INFO, @@ -3477,79 +2458,56 @@ impl ::std::default::Default for ImageViewCreateInfo { format: Format::default(), components: ComponentMapping::default(), subresource_range: ImageSubresourceRange::default(), + _marker: PhantomData, } } } -impl ImageViewCreateInfo { - pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> { - ImageViewCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageViewCreateInfoBuilder<'a> { - inner: ImageViewCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageViewCreateInfo {} -impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> { - type Target = ImageViewCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageViewCreateInfoBuilder<'a> { +impl<'a> ImageViewCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn view_type(mut self, view_type: ImageViewType) -> Self { - self.inner.view_type = view_type; + self.view_type = view_type; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn components(mut self, components: ComponentMapping) -> Self { - self.inner.components = components; + self.components = components; self } + #[inline] pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { - self.inner.subresource_range = subresource_range; + self.subresource_range = subresource_range; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageViewCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -3561,48 +2519,21 @@ pub struct BufferCopy { pub size: DeviceSize, } impl BufferCopy { - pub fn builder<'a>() -> BufferCopyBuilder<'a> { - BufferCopyBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCopyBuilder<'a> { - inner: BufferCopy, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> { - type Target = BufferCopy; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCopyBuilder<'a> { + #[inline] pub fn src_offset(mut self, src_offset: DeviceSize) -> Self { - self.inner.src_offset = src_offset; + self.src_offset = src_offset; self } + #[inline] pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self { - self.inner.dst_offset = dst_offset; + self.dst_offset = dst_offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCopy { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -3616,56 +2547,31 @@ pub struct SparseMemoryBind { pub flags: SparseMemoryBindFlags, } impl SparseMemoryBind { - pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> { - SparseMemoryBindBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseMemoryBindBuilder<'a> { - inner: SparseMemoryBind, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> { - type Target = SparseMemoryBind; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseMemoryBindBuilder<'a> { + #[inline] pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self { - self.inner.resource_offset = resource_offset; + self.resource_offset = resource_offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { - self.inner.memory_offset = memory_offset; + self.memory_offset = memory_offset; self } + #[inline] pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseMemoryBind { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -3680,257 +2586,156 @@ pub struct SparseImageMemoryBind { pub flags: SparseMemoryBindFlags, } impl SparseImageMemoryBind { - pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> { - SparseImageMemoryBindBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageMemoryBindBuilder<'a> { - inner: SparseImageMemoryBind, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> { - type Target = SparseImageMemoryBind; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageMemoryBindBuilder<'a> { + #[inline] pub fn subresource(mut self, subresource: ImageSubresource) -> Self { - self.inner.subresource = subresource; + self.subresource = subresource; self } + #[inline] pub fn offset(mut self, offset: Offset3D) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn extent(mut self, extent: Extent3D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { - self.inner.memory_offset = memory_offset; + self.memory_offset = memory_offset; self } + #[inline] pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageMemoryBind { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SparseBufferMemoryBindInfo { +pub struct SparseBufferMemoryBindInfo<'a> { pub buffer: Buffer, pub bind_count: u32, pub p_binds: *const SparseMemoryBind, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SparseBufferMemoryBindInfo { +impl ::std::default::Default for SparseBufferMemoryBindInfo<'_> { fn default() -> Self { Self { buffer: Buffer::default(), bind_count: u32::default(), p_binds: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SparseBufferMemoryBindInfo { - pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> { - SparseBufferMemoryBindInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseBufferMemoryBindInfoBuilder<'a> { - inner: SparseBufferMemoryBindInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> { - type Target = SparseBufferMemoryBindInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseBufferMemoryBindInfoBuilder<'a> { +impl<'a> SparseBufferMemoryBindInfo<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self { - self.inner.bind_count = binds.len() as _; - self.inner.p_binds = binds.as_ptr(); + self.bind_count = binds.len() as _; + self.p_binds = binds.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseBufferMemoryBindInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SparseImageOpaqueMemoryBindInfo { +pub struct SparseImageOpaqueMemoryBindInfo<'a> { pub image: Image, pub bind_count: u32, pub p_binds: *const SparseMemoryBind, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { +impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo<'_> { fn default() -> Self { Self { image: Image::default(), bind_count: u32::default(), p_binds: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SparseImageOpaqueMemoryBindInfo { - pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { - SparseImageOpaqueMemoryBindInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> { - inner: SparseImageOpaqueMemoryBindInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> { - type Target = SparseImageOpaqueMemoryBindInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> { +impl<'a> SparseImageOpaqueMemoryBindInfo<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self { - self.inner.bind_count = binds.len() as _; - self.inner.p_binds = binds.as_ptr(); + self.bind_count = binds.len() as _; + self.p_binds = binds.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageOpaqueMemoryBindInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SparseImageMemoryBindInfo { +pub struct SparseImageMemoryBindInfo<'a> { pub image: Image, pub bind_count: u32, pub p_binds: *const SparseImageMemoryBind, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SparseImageMemoryBindInfo { +impl ::std::default::Default for SparseImageMemoryBindInfo<'_> { fn default() -> Self { Self { image: Image::default(), bind_count: u32::default(), p_binds: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SparseImageMemoryBindInfo { - pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> { - SparseImageMemoryBindInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageMemoryBindInfoBuilder<'a> { - inner: SparseImageMemoryBindInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> { - type Target = SparseImageMemoryBindInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageMemoryBindInfoBuilder<'a> { +impl<'a> SparseImageMemoryBindInfo<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self { - self.inner.bind_count = binds.len() as _; - self.inner.p_binds = binds.as_ptr(); + self.bind_count = binds.len() as _; + self.p_binds = binds.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageMemoryBindInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindSparseInfo { +pub struct BindSparseInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub wait_semaphore_count: u32, pub p_wait_semaphores: *const Semaphore, pub buffer_bind_count: u32, - pub p_buffer_binds: *const SparseBufferMemoryBindInfo, + pub p_buffer_binds: *const SparseBufferMemoryBindInfo<'a>, pub image_opaque_bind_count: u32, - pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo, + pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo<'a>, pub image_bind_count: u32, - pub p_image_binds: *const SparseImageMemoryBindInfo, + pub p_image_binds: *const SparseImageMemoryBindInfo<'a>, pub signal_semaphore_count: u32, pub p_signal_semaphores: *const Semaphore, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindSparseInfo { +impl ::std::default::Default for BindSparseInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_SPARSE_INFO, @@ -3945,83 +2750,59 @@ impl ::std::default::Default for BindSparseInfo { p_image_binds: ::std::ptr::null(), signal_semaphore_count: u32::default(), p_signal_semaphores: ::std::ptr::null(), + _marker: PhantomData, } } } -impl BindSparseInfo { - pub fn builder<'a>() -> BindSparseInfoBuilder<'a> { - BindSparseInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindSparseInfoBuilder<'a> { - inner: BindSparseInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsBindSparseInfo {} -impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { - type Target = BindSparseInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindSparseInfoBuilder<'a> { +impl<'a> BindSparseInfo<'a> { + #[inline] pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { - self.inner.wait_semaphore_count = wait_semaphores.len() as _; - self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self.wait_semaphore_count = wait_semaphores.len() as _; + self.p_wait_semaphores = wait_semaphores.as_ptr(); self } + #[inline] pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self { - self.inner.buffer_bind_count = buffer_binds.len() as _; - self.inner.p_buffer_binds = buffer_binds.as_ptr(); + self.buffer_bind_count = buffer_binds.len() as _; + self.p_buffer_binds = buffer_binds.as_ptr(); self } + #[inline] pub fn image_opaque_binds( mut self, image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], ) -> Self { - self.inner.image_opaque_bind_count = image_opaque_binds.len() as _; - self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr(); + self.image_opaque_bind_count = image_opaque_binds.len() as _; + self.p_image_opaque_binds = image_opaque_binds.as_ptr(); self } + #[inline] pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self { - self.inner.image_bind_count = image_binds.len() as _; - self.inner.p_image_binds = image_binds.as_ptr(); + self.image_bind_count = image_binds.len() as _; + self.p_image_binds = image_binds.as_ptr(); self } + #[inline] pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self { - self.inner.signal_semaphore_count = signal_semaphores.len() as _; - self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self.signal_semaphore_count = signal_semaphores.len() as _; + self.p_signal_semaphores = signal_semaphores.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindSparseInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -4035,56 +2816,31 @@ pub struct ImageCopy { pub extent: Extent3D, } impl ImageCopy { - pub fn builder<'a>() -> ImageCopyBuilder<'a> { - ImageCopyBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageCopyBuilder<'a> { - inner: ImageCopy, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> { - type Target = ImageCopy; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageCopyBuilder<'a> { + #[inline] pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { - self.inner.src_subresource = src_subresource; + self.src_subresource = src_subresource; self } + #[inline] pub fn src_offset(mut self, src_offset: Offset3D) -> Self { - self.inner.src_offset = src_offset; + self.src_offset = src_offset; self } + #[inline] pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { - self.inner.dst_subresource = dst_subresource; + self.dst_subresource = dst_subresource; self } + #[inline] pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { - self.inner.dst_offset = dst_offset; + self.dst_offset = dst_offset; self } + #[inline] pub fn extent(mut self, extent: Extent3D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageCopy { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -4107,52 +2863,26 @@ impl ::std::default::Default for ImageBlit { } } impl ImageBlit { - pub fn builder<'a>() -> ImageBlitBuilder<'a> { - ImageBlitBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageBlitBuilder<'a> { - inner: ImageBlit, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> { - type Target = ImageBlit; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageBlitBuilder<'a> { + #[inline] pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { - self.inner.src_subresource = src_subresource; + self.src_subresource = src_subresource; self } + #[inline] pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self { - self.inner.src_offsets = src_offsets; + self.src_offsets = src_offsets; self } + #[inline] pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { - self.inner.dst_subresource = dst_subresource; + self.dst_subresource = dst_subresource; self } + #[inline] pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self { - self.inner.dst_offsets = dst_offsets; + self.dst_offsets = dst_offsets; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageBlit { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -4167,60 +2897,36 @@ pub struct BufferImageCopy { pub image_extent: Extent3D, } impl BufferImageCopy { - pub fn builder<'a>() -> BufferImageCopyBuilder<'a> { - BufferImageCopyBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferImageCopyBuilder<'a> { - inner: BufferImageCopy, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> { - type Target = BufferImageCopy; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferImageCopyBuilder<'a> { + #[inline] pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self { - self.inner.buffer_offset = buffer_offset; + self.buffer_offset = buffer_offset; self } + #[inline] pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { - self.inner.buffer_row_length = buffer_row_length; + self.buffer_row_length = buffer_row_length; self } + #[inline] pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { - self.inner.buffer_image_height = buffer_image_height; + self.buffer_image_height = buffer_image_height; self } + #[inline] pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { - self.inner.image_subresource = image_subresource; + self.image_subresource = image_subresource; self } + #[inline] pub fn image_offset(mut self, image_offset: Offset3D) -> Self { - self.inner.image_offset = image_offset; + self.image_offset = image_offset; self } + #[inline] pub fn image_extent(mut self, image_extent: Extent3D) -> Self { - self.inner.image_extent = image_extent; + self.image_extent = image_extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferImageCopy { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -4234,69 +2940,45 @@ pub struct ImageResolve { pub extent: Extent3D, } impl ImageResolve { - pub fn builder<'a>() -> ImageResolveBuilder<'a> { - ImageResolveBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageResolveBuilder<'a> { - inner: ImageResolve, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> { - type Target = ImageResolve; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageResolveBuilder<'a> { + #[inline] pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { - self.inner.src_subresource = src_subresource; + self.src_subresource = src_subresource; self } + #[inline] pub fn src_offset(mut self, src_offset: Offset3D) -> Self { - self.inner.src_offset = src_offset; + self.src_offset = src_offset; self } + #[inline] pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { - self.inner.dst_subresource = dst_subresource; + self.dst_subresource = dst_subresource; self } + #[inline] pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { - self.inner.dst_offset = dst_offset; + self.dst_offset = dst_offset; self } + #[inline] pub fn extent(mut self, extent: Extent3D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageResolve { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ShaderModuleCreateInfo { +pub struct ShaderModuleCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ShaderModuleCreateFlags, pub code_size: usize, pub p_code: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ShaderModuleCreateInfo { +impl ::std::default::Default for ShaderModuleCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SHADER_MODULE_CREATE_INFO, @@ -4304,77 +2986,51 @@ impl ::std::default::Default for ShaderModuleCreateInfo { flags: ShaderModuleCreateFlags::default(), code_size: usize::default(), p_code: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ShaderModuleCreateInfo { - pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> { - ShaderModuleCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ShaderModuleCreateInfoBuilder<'a> { - inner: ShaderModuleCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsShaderModuleCreateInfo {} -impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> { - type Target = ShaderModuleCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ShaderModuleCreateInfoBuilder<'a> { +impl<'a> ShaderModuleCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn code(mut self, code: &'a [u32]) -> Self { - self.inner.code_size = code.len() * 4; - self.inner.p_code = code.as_ptr(); + self.code_size = code.len() * 4; + self.p_code = code.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ShaderModuleCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetLayoutBinding { +pub struct DescriptorSetLayoutBinding<'a> { pub binding: u32, pub descriptor_type: DescriptorType, pub descriptor_count: u32, pub stage_flags: ShaderStageFlags, pub p_immutable_samplers: *const Sampler, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetLayoutBinding { +impl ::std::default::Default for DescriptorSetLayoutBinding<'_> { fn default() -> Self { Self { binding: u32::default(), @@ -4382,74 +3038,51 @@ impl ::std::default::Default for DescriptorSetLayoutBinding { descriptor_count: u32::default(), stage_flags: ShaderStageFlags::default(), p_immutable_samplers: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DescriptorSetLayoutBinding { - pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> { - DescriptorSetLayoutBindingBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetLayoutBindingBuilder<'a> { - inner: DescriptorSetLayoutBinding, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> { - type Target = DescriptorSetLayoutBinding; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetLayoutBindingBuilder<'a> { +impl<'a> DescriptorSetLayoutBinding<'a> { + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } + #[inline] pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { - self.inner.descriptor_type = descriptor_type; + self.descriptor_type = descriptor_type; self } + #[inline] pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { - self.inner.descriptor_count = descriptor_count; + self.descriptor_count = descriptor_count; self } + #[inline] pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self { - self.inner.stage_flags = stage_flags; + self.stage_flags = stage_flags; self } + #[inline] pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self { - self.inner.descriptor_count = immutable_samplers.len() as _; - self.inner.p_immutable_samplers = immutable_samplers.as_ptr(); + self.descriptor_count = immutable_samplers.len() as _; + self.p_immutable_samplers = immutable_samplers.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetLayoutBinding { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetLayoutCreateInfo { +pub struct DescriptorSetLayoutCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DescriptorSetLayoutCreateFlags, pub binding_count: u32, - pub p_bindings: *const DescriptorSetLayoutBinding, + pub p_bindings: *const DescriptorSetLayoutBinding<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetLayoutCreateInfo { +impl ::std::default::Default for DescriptorSetLayoutCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO, @@ -4457,64 +3090,37 @@ impl ::std::default::Default for DescriptorSetLayoutCreateInfo { flags: DescriptorSetLayoutCreateFlags::default(), binding_count: u32::default(), p_bindings: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DescriptorSetLayoutCreateInfo { - pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> { - DescriptorSetLayoutCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetLayoutCreateInfoBuilder<'a> { - inner: DescriptorSetLayoutCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {} -impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> { - type Target = DescriptorSetLayoutCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { +impl<'a> DescriptorSetLayoutCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self { - self.inner.binding_count = bindings.len() as _; - self.inner.p_bindings = bindings.as_ptr(); + self.binding_count = bindings.len() as _; + self.p_bindings = bindings.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetLayoutCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -4525,58 +3131,31 @@ pub struct DescriptorPoolSize { pub descriptor_count: u32, } impl DescriptorPoolSize { - pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> { - DescriptorPoolSizeBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorPoolSizeBuilder<'a> { - inner: DescriptorPoolSize, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> { - type Target = DescriptorPoolSize; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorPoolSizeBuilder<'a> { + #[inline] pub fn ty(mut self, ty: DescriptorType) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { - self.inner.descriptor_count = descriptor_count; + self.descriptor_count = descriptor_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorPoolSize { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorPoolCreateInfo { +pub struct DescriptorPoolCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DescriptorPoolCreateFlags, pub max_sets: u32, pub pool_size_count: u32, pub p_pool_sizes: *const DescriptorPoolSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorPoolCreateInfo { +impl ::std::default::Default for DescriptorPoolCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO, @@ -4585,81 +3164,56 @@ impl ::std::default::Default for DescriptorPoolCreateInfo { max_sets: u32::default(), pool_size_count: u32::default(), p_pool_sizes: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DescriptorPoolCreateInfo { - pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> { - DescriptorPoolCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorPoolCreateInfoBuilder<'a> { - inner: DescriptorPoolCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsDescriptorPoolCreateInfo {} -impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> { - type Target = DescriptorPoolCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorPoolCreateInfoBuilder<'a> { +impl<'a> DescriptorPoolCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn max_sets(mut self, max_sets: u32) -> Self { - self.inner.max_sets = max_sets; + self.max_sets = max_sets; self } + #[inline] pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self { - self.inner.pool_size_count = pool_sizes.len() as _; - self.inner.p_pool_sizes = pool_sizes.as_ptr(); + self.pool_size_count = pool_sizes.len() as _; + self.p_pool_sizes = pool_sizes.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorPoolCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetAllocateInfo { +pub struct DescriptorSetAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub descriptor_pool: DescriptorPool, pub descriptor_set_count: u32, pub p_set_layouts: *const DescriptorSetLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetAllocateInfo { +impl ::std::default::Default for DescriptorSetAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO, @@ -4667,64 +3221,37 @@ impl ::std::default::Default for DescriptorSetAllocateInfo { descriptor_pool: DescriptorPool::default(), descriptor_set_count: u32::default(), p_set_layouts: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DescriptorSetAllocateInfo { - pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> { - DescriptorSetAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetAllocateInfoBuilder<'a> { - inner: DescriptorSetAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsDescriptorSetAllocateInfo {} -impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> { - type Target = DescriptorSetAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetAllocateInfoBuilder<'a> { +impl<'a> DescriptorSetAllocateInfo<'a> { + #[inline] pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self { - self.inner.descriptor_pool = descriptor_pool; + self.descriptor_pool = descriptor_pool; self } + #[inline] pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { - self.inner.descriptor_set_count = set_layouts.len() as _; - self.inner.p_set_layouts = set_layouts.as_ptr(); + self.descriptor_set_count = set_layouts.len() as _; + self.p_set_layouts = set_layouts.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -4736,125 +3263,73 @@ pub struct SpecializationMapEntry { pub size: usize, } impl SpecializationMapEntry { - pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> { - SpecializationMapEntryBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SpecializationMapEntryBuilder<'a> { - inner: SpecializationMapEntry, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> { - type Target = SpecializationMapEntry; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SpecializationMapEntryBuilder<'a> { + #[inline] pub fn constant_id(mut self, constant_id: u32) -> Self { - self.inner.constant_id = constant_id; + self.constant_id = constant_id; self } + #[inline] pub fn offset(mut self, offset: u32) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: usize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SpecializationMapEntry { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SpecializationInfo { +pub struct SpecializationInfo<'a> { pub map_entry_count: u32, pub p_map_entries: *const SpecializationMapEntry, pub data_size: usize, pub p_data: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SpecializationInfo { +impl ::std::default::Default for SpecializationInfo<'_> { fn default() -> Self { Self { map_entry_count: u32::default(), p_map_entries: ::std::ptr::null(), data_size: usize::default(), p_data: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SpecializationInfo { - pub fn builder<'a>() -> SpecializationInfoBuilder<'a> { - SpecializationInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SpecializationInfoBuilder<'a> { - inner: SpecializationInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> { - type Target = SpecializationInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SpecializationInfoBuilder<'a> { +impl<'a> SpecializationInfo<'a> { + #[inline] pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self { - self.inner.map_entry_count = map_entries.len() as _; - self.inner.p_map_entries = map_entries.as_ptr(); + self.map_entry_count = map_entries.len() as _; + self.p_map_entries = map_entries.as_ptr(); self } + #[inline] pub fn data(mut self, data: &'a [u8]) -> Self { - self.inner.data_size = data.len(); - self.inner.p_data = data.as_ptr() as *const c_void; + self.data_size = data.len(); + self.p_data = data.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SpecializationInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineShaderStageCreateInfo { +pub struct PipelineShaderStageCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineShaderStageCreateFlags, pub stage: ShaderStageFlags, pub module: ShaderModule, pub p_name: *const c_char, - pub p_specialization_info: *const SpecializationInfo, + pub p_specialization_info: *const SpecializationInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineShaderStageCreateInfo { +impl ::std::default::Default for PipelineShaderStageCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO, @@ -4864,90 +3339,67 @@ impl ::std::default::Default for PipelineShaderStageCreateInfo { module: ShaderModule::default(), p_name: ::std::ptr::null(), p_specialization_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineShaderStageCreateInfo { - pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> { - PipelineShaderStageCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineShaderStageCreateInfoBuilder<'a> { - inner: PipelineShaderStageCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineShaderStageCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> { - type Target = PipelineShaderStageCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { +impl<'a> PipelineShaderStageCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn stage(mut self, stage: ShaderStageFlags) -> Self { - self.inner.stage = stage; + self.stage = stage; self } + #[inline] pub fn module(mut self, module: ShaderModule) -> Self { - self.inner.module = module; + self.module = module; self } + #[inline] pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_name = name.as_ptr(); + self.p_name = name.as_ptr(); self } - pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self { - self.inner.p_specialization_info = specialization_info; + #[inline] + pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo<'a>) -> Self { + self.p_specialization_info = specialization_info; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineShaderStageCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ComputePipelineCreateInfo { +pub struct ComputePipelineCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCreateFlags, - pub stage: PipelineShaderStageCreateInfo, + pub stage: PipelineShaderStageCreateInfo<'a>, pub layout: PipelineLayout, pub base_pipeline_handle: Pipeline, pub base_pipeline_index: i32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ComputePipelineCreateInfo { +impl ::std::default::Default for ComputePipelineCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO, @@ -4957,75 +3409,51 @@ impl ::std::default::Default for ComputePipelineCreateInfo { layout: PipelineLayout::default(), base_pipeline_handle: Pipeline::default(), base_pipeline_index: i32::default(), + _marker: PhantomData, } } } -impl ComputePipelineCreateInfo { - pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> { - ComputePipelineCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ComputePipelineCreateInfoBuilder<'a> { - inner: ComputePipelineCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsComputePipelineCreateInfo {} -impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> { - type Target = ComputePipelineCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ComputePipelineCreateInfoBuilder<'a> { +impl<'a> ComputePipelineCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self { - self.inner.stage = stage; + #[inline] + pub fn stage(mut self, stage: PipelineShaderStageCreateInfo<'a>) -> Self { + self.stage = stage; self } + #[inline] pub fn layout(mut self, layout: PipelineLayout) -> Self { - self.inner.layout = layout; + self.layout = layout; self } + #[inline] pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { - self.inner.base_pipeline_handle = base_pipeline_handle; + self.base_pipeline_handle = base_pipeline_handle; self } + #[inline] pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { - self.inner.base_pipeline_index = base_pipeline_index; + self.base_pipeline_index = base_pipeline_index; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ComputePipelineCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -5037,48 +3465,21 @@ pub struct VertexInputBindingDescription { pub input_rate: VertexInputRate, } impl VertexInputBindingDescription { - pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> { - VertexInputBindingDescriptionBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VertexInputBindingDescriptionBuilder<'a> { - inner: VertexInputBindingDescription, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> { - type Target = VertexInputBindingDescription; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VertexInputBindingDescriptionBuilder<'a> { + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } + #[inline] pub fn stride(mut self, stride: u32) -> Self { - self.inner.stride = stride; + self.stride = stride; self } + #[inline] pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self { - self.inner.input_rate = input_rate; + self.input_rate = input_rate; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VertexInputBindingDescription { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -5091,58 +3492,32 @@ pub struct VertexInputAttributeDescription { pub offset: u32, } impl VertexInputAttributeDescription { - pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> { - VertexInputAttributeDescriptionBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VertexInputAttributeDescriptionBuilder<'a> { - inner: VertexInputAttributeDescription, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> { - type Target = VertexInputAttributeDescription; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VertexInputAttributeDescriptionBuilder<'a> { + #[inline] pub fn location(mut self, location: u32) -> Self { - self.inner.location = location; + self.location = location; self } + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn offset(mut self, offset: u32) -> Self { - self.inner.offset = offset; + self.offset = offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VertexInputAttributeDescription { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineVertexInputStateCreateInfo { +pub struct PipelineVertexInputStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineVertexInputStateCreateFlags, @@ -5150,8 +3525,9 @@ pub struct PipelineVertexInputStateCreateInfo { pub p_vertex_binding_descriptions: *const VertexInputBindingDescription, pub vertex_attribute_description_count: u32, pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineVertexInputStateCreateInfo { +impl ::std::default::Default for PipelineVertexInputStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, @@ -5161,59 +3537,39 @@ impl ::std::default::Default for PipelineVertexInputStateCreateInfo { p_vertex_binding_descriptions: ::std::ptr::null(), vertex_attribute_description_count: u32::default(), p_vertex_attribute_descriptions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineVertexInputStateCreateInfo { - pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> { - PipelineVertexInputStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineVertexInputStateCreateInfoBuilder<'a> { - inner: PipelineVertexInputStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> { - type Target = PipelineVertexInputStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { +impl<'a> PipelineVertexInputStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn vertex_binding_descriptions( mut self, vertex_binding_descriptions: &'a [VertexInputBindingDescription], ) -> Self { - self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _; - self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr(); + self.vertex_binding_description_count = vertex_binding_descriptions.len() as _; + self.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr(); self } + #[inline] pub fn vertex_attribute_descriptions( mut self, vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], ) -> Self { - self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _; - self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr(); + self.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _; + self.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -5222,30 +3578,25 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineVertexInputStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineInputAssemblyStateCreateInfo { +pub struct PipelineInputAssemblyStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineInputAssemblyStateCreateFlags, pub topology: PrimitiveTopology, pub primitive_restart_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { +impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, @@ -5253,111 +3604,65 @@ impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { flags: PipelineInputAssemblyStateCreateFlags::default(), topology: PrimitiveTopology::default(), primitive_restart_enable: Bool32::default(), + _marker: PhantomData, } } } -impl PipelineInputAssemblyStateCreateInfo { - pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { - PipelineInputAssemblyStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { - inner: PipelineInputAssemblyStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { - type Target = PipelineInputAssemblyStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { +impl<'a> PipelineInputAssemblyStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn topology(mut self, topology: PrimitiveTopology) -> Self { - self.inner.topology = topology; + self.topology = topology; self } + #[inline] pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self { - self.inner.primitive_restart_enable = primitive_restart_enable.into(); + self.primitive_restart_enable = primitive_restart_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineInputAssemblyStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineTessellationStateCreateInfo { +pub struct PipelineTessellationStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineTessellationStateCreateFlags, pub patch_control_points: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineTessellationStateCreateInfo { +impl ::std::default::Default for PipelineTessellationStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO, p_next: ::std::ptr::null(), flags: PipelineTessellationStateCreateFlags::default(), patch_control_points: u32::default(), + _marker: PhantomData, } } } -impl PipelineTessellationStateCreateInfo { - pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> { - PipelineTessellationStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineTessellationStateCreateInfoBuilder<'a> { - inner: PipelineTessellationStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> { - type Target = PipelineTessellationStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { +impl<'a> PipelineTessellationStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn patch_control_points(mut self, patch_control_points: u32) -> Self { - self.inner.patch_control_points = patch_control_points; + self.patch_control_points = patch_control_points; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -5366,23 +3671,17 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineTessellationStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportStateCreateInfo { +pub struct PipelineViewportStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineViewportStateCreateFlags, @@ -5390,8 +3689,9 @@ pub struct PipelineViewportStateCreateInfo { pub p_viewports: *const Viewport, pub scissor_count: u32, pub p_scissors: *const Rect2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportStateCreateInfo { +impl ::std::default::Default for PipelineViewportStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO, @@ -5401,83 +3701,59 @@ impl ::std::default::Default for PipelineViewportStateCreateInfo { p_viewports: ::std::ptr::null(), scissor_count: u32::default(), p_scissors: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineViewportStateCreateInfo { - pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> { - PipelineViewportStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportStateCreateInfoBuilder<'a> { - inner: PipelineViewportStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineViewportStateCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> { - type Target = PipelineViewportStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { +impl<'a> PipelineViewportStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn viewport_count(mut self, viewport_count: u32) -> Self { - self.inner.viewport_count = viewport_count; + self.viewport_count = viewport_count; self } + #[inline] pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self { - self.inner.viewport_count = viewports.len() as _; - self.inner.p_viewports = viewports.as_ptr(); + self.viewport_count = viewports.len() as _; + self.p_viewports = viewports.as_ptr(); self } + #[inline] pub fn scissor_count(mut self, scissor_count: u32) -> Self { - self.inner.scissor_count = scissor_count; + self.scissor_count = scissor_count; self } + #[inline] pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self { - self.inner.scissor_count = scissors.len() as _; - self.inner.p_scissors = scissors.as_ptr(); + self.scissor_count = scissors.len() as _; + self.p_scissors = scissors.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationStateCreateInfo { +pub struct PipelineRasterizationStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineRasterizationStateCreateFlags, @@ -5491,8 +3767,9 @@ pub struct PipelineRasterizationStateCreateInfo { pub depth_bias_clamp: f32, pub depth_bias_slope_factor: f32, pub line_width: f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationStateCreateInfo { +impl ::std::default::Default for PipelineRasterizationStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO, @@ -5508,83 +3785,71 @@ impl ::std::default::Default for PipelineRasterizationStateCreateInfo { depth_bias_clamp: f32::default(), depth_bias_slope_factor: f32::default(), line_width: f32::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationStateCreateInfo { - pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> { - PipelineRasterizationStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationStateCreateInfoBuilder<'a> { - inner: PipelineRasterizationStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> { - type Target = PipelineRasterizationStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { +impl<'a> PipelineRasterizationStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self { - self.inner.depth_clamp_enable = depth_clamp_enable.into(); + self.depth_clamp_enable = depth_clamp_enable.into(); self } + #[inline] pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self { - self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into(); + self.rasterizer_discard_enable = rasterizer_discard_enable.into(); self } + #[inline] pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self { - self.inner.polygon_mode = polygon_mode; + self.polygon_mode = polygon_mode; self } + #[inline] pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self { - self.inner.cull_mode = cull_mode; + self.cull_mode = cull_mode; self } + #[inline] pub fn front_face(mut self, front_face: FrontFace) -> Self { - self.inner.front_face = front_face; + self.front_face = front_face; self } + #[inline] pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self { - self.inner.depth_bias_enable = depth_bias_enable.into(); + self.depth_bias_enable = depth_bias_enable.into(); self } + #[inline] pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self { - self.inner.depth_bias_constant_factor = depth_bias_constant_factor; + self.depth_bias_constant_factor = depth_bias_constant_factor; self } + #[inline] pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self { - self.inner.depth_bias_clamp = depth_bias_clamp; + self.depth_bias_clamp = depth_bias_clamp; self } + #[inline] pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self { - self.inner.depth_bias_slope_factor = depth_bias_slope_factor; + self.depth_bias_slope_factor = depth_bias_slope_factor; self } + #[inline] pub fn line_width(mut self, line_width: f32) -> Self { - self.inner.line_width = line_width; + self.line_width = line_width; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -5593,23 +3858,17 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineMultisampleStateCreateInfo { +pub struct PipelineMultisampleStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineMultisampleStateCreateFlags, @@ -5619,8 +3878,9 @@ pub struct PipelineMultisampleStateCreateInfo { pub p_sample_mask: *const SampleMask, pub alpha_to_coverage_enable: Bool32, pub alpha_to_one_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineMultisampleStateCreateInfo { +impl ::std::default::Default for PipelineMultisampleStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, @@ -5632,49 +3892,30 @@ impl ::std::default::Default for PipelineMultisampleStateCreateInfo { p_sample_mask: ::std::ptr::null(), alpha_to_coverage_enable: Bool32::default(), alpha_to_one_enable: Bool32::default(), + _marker: PhantomData, } } } -impl PipelineMultisampleStateCreateInfo { - pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> { - PipelineMultisampleStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineMultisampleStateCreateInfoBuilder<'a> { - inner: PipelineMultisampleStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> { - type Target = PipelineMultisampleStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { +impl<'a> PipelineMultisampleStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { - self.inner.rasterization_samples = rasterization_samples; + self.rasterization_samples = rasterization_samples; self } + #[inline] pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self { - self.inner.sample_shading_enable = sample_shading_enable.into(); + self.sample_shading_enable = sample_shading_enable.into(); self } + #[inline] pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self { - self.inner.min_sample_shading = min_sample_shading; + self.min_sample_shading = min_sample_shading; self } #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"] @@ -5682,26 +3923,29 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { #[doc = r""] #[doc = r" See "] #[doc = r" for more details."] + #[inline] pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self { - self.inner.p_sample_mask = if sample_mask.is_empty() { + self.p_sample_mask = if sample_mask.is_empty() { std::ptr::null() } else { sample_mask.as_ptr() }; self } + #[inline] pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self { - self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into(); + self.alpha_to_coverage_enable = alpha_to_coverage_enable.into(); self } + #[inline] pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self { - self.inner.alpha_to_one_enable = alpha_to_one_enable.into(); + self.alpha_to_one_enable = alpha_to_one_enable.into(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -5710,17 +3954,11 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineMultisampleStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -5737,74 +3975,52 @@ pub struct PipelineColorBlendAttachmentState { pub color_write_mask: ColorComponentFlags, } impl PipelineColorBlendAttachmentState { - pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> { - PipelineColorBlendAttachmentStateBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineColorBlendAttachmentStateBuilder<'a> { - inner: PipelineColorBlendAttachmentState, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> { - type Target = PipelineColorBlendAttachmentState; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> { + #[inline] pub fn blend_enable(mut self, blend_enable: bool) -> Self { - self.inner.blend_enable = blend_enable.into(); + self.blend_enable = blend_enable.into(); self } + #[inline] pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self { - self.inner.src_color_blend_factor = src_color_blend_factor; + self.src_color_blend_factor = src_color_blend_factor; self } + #[inline] pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self { - self.inner.dst_color_blend_factor = dst_color_blend_factor; + self.dst_color_blend_factor = dst_color_blend_factor; self } + #[inline] pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self { - self.inner.color_blend_op = color_blend_op; + self.color_blend_op = color_blend_op; self } + #[inline] pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self { - self.inner.src_alpha_blend_factor = src_alpha_blend_factor; + self.src_alpha_blend_factor = src_alpha_blend_factor; self } + #[inline] pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self { - self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor; + self.dst_alpha_blend_factor = dst_alpha_blend_factor; self } + #[inline] pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self { - self.inner.alpha_blend_op = alpha_blend_op; + self.alpha_blend_op = alpha_blend_op; self } + #[inline] pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self { - self.inner.color_write_mask = color_write_mask; + self.color_write_mask = color_write_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineColorBlendAttachmentState { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineColorBlendStateCreateInfo { +pub struct PipelineColorBlendStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineColorBlendStateCreateFlags, @@ -5813,8 +4029,9 @@ pub struct PipelineColorBlendStateCreateInfo { pub attachment_count: u32, pub p_attachments: *const PipelineColorBlendAttachmentState, pub blend_constants: [f32; 4], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineColorBlendStateCreateInfo { +impl ::std::default::Default for PipelineColorBlendStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, @@ -5825,60 +4042,42 @@ impl ::std::default::Default for PipelineColorBlendStateCreateInfo { attachment_count: u32::default(), p_attachments: ::std::ptr::null(), blend_constants: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PipelineColorBlendStateCreateInfo { - pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> { - PipelineColorBlendStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineColorBlendStateCreateInfoBuilder<'a> { - inner: PipelineColorBlendStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> { - type Target = PipelineColorBlendStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { +impl<'a> PipelineColorBlendStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self { - self.inner.logic_op_enable = logic_op_enable.into(); + self.logic_op_enable = logic_op_enable.into(); self } + #[inline] pub fn logic_op(mut self, logic_op: LogicOp) -> Self { - self.inner.logic_op = logic_op; + self.logic_op = logic_op; self } + #[inline] pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self { - self.inner.attachment_count = attachments.len() as _; - self.inner.p_attachments = attachments.as_ptr(); + self.attachment_count = attachments.len() as _; + self.p_attachments = attachments.as_ptr(); self } + #[inline] pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self { - self.inner.blend_constants = blend_constants; + self.blend_constants = blend_constants; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -5887,30 +4086,25 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineColorBlendStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineDynamicStateCreateInfo { +pub struct PipelineDynamicStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineDynamicStateCreateFlags, pub dynamic_state_count: u32, pub p_dynamic_states: *const DynamicState, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineDynamicStateCreateInfo { +impl ::std::default::Default for PipelineDynamicStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO, @@ -5918,49 +4112,22 @@ impl ::std::default::Default for PipelineDynamicStateCreateInfo { flags: PipelineDynamicStateCreateFlags::default(), dynamic_state_count: u32::default(), p_dynamic_states: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineDynamicStateCreateInfo { - pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> { - PipelineDynamicStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineDynamicStateCreateInfoBuilder<'a> { - inner: PipelineDynamicStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { - type Target = PipelineDynamicStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { +impl<'a> PipelineDynamicStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self { - self.inner.dynamic_state_count = dynamic_states.len() as _; - self.inner.p_dynamic_states = dynamic_states.as_ptr(); + self.dynamic_state_count = dynamic_states.len() as _; + self.p_dynamic_states = dynamic_states.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineDynamicStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -5976,70 +4143,47 @@ pub struct StencilOpState { pub reference: u32, } impl StencilOpState { - pub fn builder<'a>() -> StencilOpStateBuilder<'a> { - StencilOpStateBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct StencilOpStateBuilder<'a> { - inner: StencilOpState, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> { - type Target = StencilOpState; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> StencilOpStateBuilder<'a> { + #[inline] pub fn fail_op(mut self, fail_op: StencilOp) -> Self { - self.inner.fail_op = fail_op; + self.fail_op = fail_op; self } + #[inline] pub fn pass_op(mut self, pass_op: StencilOp) -> Self { - self.inner.pass_op = pass_op; + self.pass_op = pass_op; self } + #[inline] pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self { - self.inner.depth_fail_op = depth_fail_op; + self.depth_fail_op = depth_fail_op; self } + #[inline] pub fn compare_op(mut self, compare_op: CompareOp) -> Self { - self.inner.compare_op = compare_op; + self.compare_op = compare_op; self } + #[inline] pub fn compare_mask(mut self, compare_mask: u32) -> Self { - self.inner.compare_mask = compare_mask; + self.compare_mask = compare_mask; self } + #[inline] pub fn write_mask(mut self, write_mask: u32) -> Self { - self.inner.write_mask = write_mask; + self.write_mask = write_mask; self } + #[inline] pub fn reference(mut self, reference: u32) -> Self { - self.inner.reference = reference; + self.reference = reference; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> StencilOpState { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineDepthStencilStateCreateInfo { +pub struct PipelineDepthStencilStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineDepthStencilStateCreateFlags, @@ -6052,8 +4196,9 @@ pub struct PipelineDepthStencilStateCreateInfo { pub back: StencilOpState, pub min_depth_bounds: f32, pub max_depth_bounds: f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { +impl ::std::default::Default for PipelineDepthStencilStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, @@ -6068,107 +4213,89 @@ impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { back: StencilOpState::default(), min_depth_bounds: f32::default(), max_depth_bounds: f32::default(), + _marker: PhantomData, } } } -impl PipelineDepthStencilStateCreateInfo { - pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> { - PipelineDepthStencilStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { - inner: PipelineDepthStencilStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { - type Target = PipelineDepthStencilStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { +impl<'a> PipelineDepthStencilStateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self { - self.inner.depth_test_enable = depth_test_enable.into(); + self.depth_test_enable = depth_test_enable.into(); self } + #[inline] pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self { - self.inner.depth_write_enable = depth_write_enable.into(); + self.depth_write_enable = depth_write_enable.into(); self } + #[inline] pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self { - self.inner.depth_compare_op = depth_compare_op; + self.depth_compare_op = depth_compare_op; self } + #[inline] pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self { - self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into(); + self.depth_bounds_test_enable = depth_bounds_test_enable.into(); self } + #[inline] pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self { - self.inner.stencil_test_enable = stencil_test_enable.into(); + self.stencil_test_enable = stencil_test_enable.into(); self } + #[inline] pub fn front(mut self, front: StencilOpState) -> Self { - self.inner.front = front; + self.front = front; self } + #[inline] pub fn back(mut self, back: StencilOpState) -> Self { - self.inner.back = back; + self.back = back; self } + #[inline] pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self { - self.inner.min_depth_bounds = min_depth_bounds; + self.min_depth_bounds = min_depth_bounds; self } + #[inline] pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self { - self.inner.max_depth_bounds = max_depth_bounds; + self.max_depth_bounds = max_depth_bounds; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineDepthStencilStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GraphicsPipelineCreateInfo { +pub struct GraphicsPipelineCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCreateFlags, pub stage_count: u32, - pub p_stages: *const PipelineShaderStageCreateInfo, - pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, - pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo, - pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, - pub p_viewport_state: *const PipelineViewportStateCreateInfo, - pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo, - pub p_multisample_state: *const PipelineMultisampleStateCreateInfo, - pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo, - pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo, - pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub p_stages: *const PipelineShaderStageCreateInfo<'a>, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo<'a>, + pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo<'a>, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo<'a>, + pub p_viewport_state: *const PipelineViewportStateCreateInfo<'a>, + pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo<'a>, + pub p_multisample_state: *const PipelineMultisampleStateCreateInfo<'a>, + pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo<'a>, + pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo<'a>, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo<'a>, pub layout: PipelineLayout, pub render_pass: RenderPass, pub subpass: u32, pub base_pipeline_handle: Pipeline, pub base_pipeline_index: i32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GraphicsPipelineCreateInfo { +impl ::std::default::Default for GraphicsPipelineCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO, @@ -6190,154 +4317,145 @@ impl ::std::default::Default for GraphicsPipelineCreateInfo { subpass: u32::default(), base_pipeline_handle: Pipeline::default(), base_pipeline_index: i32::default(), + _marker: PhantomData, } } } -impl GraphicsPipelineCreateInfo { - pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> { - GraphicsPipelineCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GraphicsPipelineCreateInfoBuilder<'a> { - inner: GraphicsPipelineCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsGraphicsPipelineCreateInfo {} -impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> { - type Target = GraphicsPipelineCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { +impl<'a> GraphicsPipelineCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { - self.inner.stage_count = stages.len() as _; - self.inner.p_stages = stages.as_ptr(); + self.stage_count = stages.len() as _; + self.p_stages = stages.as_ptr(); self } + #[inline] pub fn vertex_input_state( mut self, - vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo<'a>, ) -> Self { - self.inner.p_vertex_input_state = vertex_input_state; + self.p_vertex_input_state = vertex_input_state; self } + #[inline] pub fn input_assembly_state( mut self, - input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo, + input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo<'a>, ) -> Self { - self.inner.p_input_assembly_state = input_assembly_state; + self.p_input_assembly_state = input_assembly_state; self } + #[inline] pub fn tessellation_state( mut self, - tessellation_state: &'a PipelineTessellationStateCreateInfo, + tessellation_state: &'a PipelineTessellationStateCreateInfo<'a>, ) -> Self { - self.inner.p_tessellation_state = tessellation_state; + self.p_tessellation_state = tessellation_state; self } - pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self { - self.inner.p_viewport_state = viewport_state; + #[inline] + pub fn viewport_state( + mut self, + viewport_state: &'a PipelineViewportStateCreateInfo<'a>, + ) -> Self { + self.p_viewport_state = viewport_state; self } + #[inline] pub fn rasterization_state( mut self, - rasterization_state: &'a PipelineRasterizationStateCreateInfo, + rasterization_state: &'a PipelineRasterizationStateCreateInfo<'a>, ) -> Self { - self.inner.p_rasterization_state = rasterization_state; + self.p_rasterization_state = rasterization_state; self } + #[inline] pub fn multisample_state( mut self, - multisample_state: &'a PipelineMultisampleStateCreateInfo, + multisample_state: &'a PipelineMultisampleStateCreateInfo<'a>, ) -> Self { - self.inner.p_multisample_state = multisample_state; + self.p_multisample_state = multisample_state; self } + #[inline] pub fn depth_stencil_state( mut self, - depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo, + depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo<'a>, ) -> Self { - self.inner.p_depth_stencil_state = depth_stencil_state; + self.p_depth_stencil_state = depth_stencil_state; self } + #[inline] pub fn color_blend_state( mut self, - color_blend_state: &'a PipelineColorBlendStateCreateInfo, + color_blend_state: &'a PipelineColorBlendStateCreateInfo<'a>, ) -> Self { - self.inner.p_color_blend_state = color_blend_state; + self.p_color_blend_state = color_blend_state; self } - pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self { - self.inner.p_dynamic_state = dynamic_state; + #[inline] + pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo<'a>) -> Self { + self.p_dynamic_state = dynamic_state; self } + #[inline] pub fn layout(mut self, layout: PipelineLayout) -> Self { - self.inner.layout = layout; + self.layout = layout; self } + #[inline] pub fn render_pass(mut self, render_pass: RenderPass) -> Self { - self.inner.render_pass = render_pass; + self.render_pass = render_pass; self } + #[inline] pub fn subpass(mut self, subpass: u32) -> Self { - self.inner.subpass = subpass; + self.subpass = subpass; self } + #[inline] pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { - self.inner.base_pipeline_handle = base_pipeline_handle; + self.base_pipeline_handle = base_pipeline_handle; self } + #[inline] pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { - self.inner.base_pipeline_index = base_pipeline_index; + self.base_pipeline_index = base_pipeline_index; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GraphicsPipelineCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineCacheCreateInfo { +pub struct PipelineCacheCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCacheCreateFlags, pub initial_data_size: usize, pub p_initial_data: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineCacheCreateInfo { +impl ::std::default::Default for PipelineCacheCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_CACHE_CREATE_INFO, @@ -6345,49 +4463,22 @@ impl ::std::default::Default for PipelineCacheCreateInfo { flags: PipelineCacheCreateFlags::default(), initial_data_size: usize::default(), p_initial_data: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineCacheCreateInfo { - pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> { - PipelineCacheCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCacheCreateInfoBuilder<'a> { - inner: PipelineCacheCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { - type Target = PipelineCacheCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCacheCreateInfoBuilder<'a> { +impl<'a> PipelineCacheCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self { - self.inner.initial_data_size = initial_data.len(); - self.inner.p_initial_data = initial_data.as_ptr() as *const c_void; + self.initial_data_size = initial_data.len(); + self.p_initial_data = initial_data.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCacheCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -6412,56 +4503,31 @@ impl ::std::default::Default for PipelineCacheHeaderVersionOne { } } impl PipelineCacheHeaderVersionOne { - pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> { - PipelineCacheHeaderVersionOneBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCacheHeaderVersionOneBuilder<'a> { - inner: PipelineCacheHeaderVersionOne, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> { - type Target = PipelineCacheHeaderVersionOne; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> { + #[inline] pub fn header_size(mut self, header_size: u32) -> Self { - self.inner.header_size = header_size; + self.header_size = header_size; self } + #[inline] pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self { - self.inner.header_version = header_version; + self.header_version = header_version; self } + #[inline] pub fn vendor_id(mut self, vendor_id: u32) -> Self { - self.inner.vendor_id = vendor_id; + self.vendor_id = vendor_id; self } + #[inline] pub fn device_id(mut self, device_id: u32) -> Self { - self.inner.device_id = device_id; + self.device_id = device_id; self } + #[inline] pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { - self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self.pipeline_cache_uuid = pipeline_cache_uuid; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCacheHeaderVersionOne { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -6473,54 +4539,27 @@ pub struct PushConstantRange { pub size: u32, } impl PushConstantRange { - pub fn builder<'a>() -> PushConstantRangeBuilder<'a> { - PushConstantRangeBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PushConstantRangeBuilder<'a> { - inner: PushConstantRange, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> { - type Target = PushConstantRange; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PushConstantRangeBuilder<'a> { + #[inline] pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self { - self.inner.stage_flags = stage_flags; + self.stage_flags = stage_flags; self } + #[inline] pub fn offset(mut self, offset: u32) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: u32) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PushConstantRange { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineLayoutCreateInfo { +pub struct PipelineLayoutCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineLayoutCreateFlags, @@ -6528,8 +4567,9 @@ pub struct PipelineLayoutCreateInfo { pub p_set_layouts: *const DescriptorSetLayout, pub push_constant_range_count: u32, pub p_push_constant_ranges: *const PushConstantRange, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineLayoutCreateInfo { +impl ::std::default::Default for PipelineLayoutCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO, @@ -6539,60 +4579,34 @@ impl ::std::default::Default for PipelineLayoutCreateInfo { p_set_layouts: ::std::ptr::null(), push_constant_range_count: u32::default(), p_push_constant_ranges: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineLayoutCreateInfo { - pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> { - PipelineLayoutCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineLayoutCreateInfoBuilder<'a> { - inner: PipelineLayoutCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { - type Target = PipelineLayoutCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineLayoutCreateInfoBuilder<'a> { +impl<'a> PipelineLayoutCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { - self.inner.set_layout_count = set_layouts.len() as _; - self.inner.p_set_layouts = set_layouts.as_ptr(); + self.set_layout_count = set_layouts.len() as _; + self.p_set_layouts = set_layouts.as_ptr(); self } + #[inline] pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self { - self.inner.push_constant_range_count = push_constant_ranges.len() as _; - self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); + self.push_constant_range_count = push_constant_ranges.len() as _; + self.p_push_constant_ranges = push_constant_ranges.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineLayoutCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerCreateInfo { +pub struct SamplerCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SamplerCreateFlags, @@ -6611,8 +4625,9 @@ pub struct SamplerCreateInfo { pub max_lod: f32, pub border_color: BorderColor, pub unnormalized_coordinates: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SamplerCreateInfo { +impl ::std::default::Default for SamplerCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_CREATE_INFO, @@ -6633,192 +4648,154 @@ impl ::std::default::Default for SamplerCreateInfo { max_lod: f32::default(), border_color: BorderColor::default(), unnormalized_coordinates: Bool32::default(), + _marker: PhantomData, } } } -impl SamplerCreateInfo { - pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> { - SamplerCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerCreateInfoBuilder<'a> { - inner: SamplerCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSamplerCreateInfo {} -impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> { - type Target = SamplerCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerCreateInfoBuilder<'a> { +impl<'a> SamplerCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: SamplerCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn mag_filter(mut self, mag_filter: Filter) -> Self { - self.inner.mag_filter = mag_filter; + self.mag_filter = mag_filter; self } + #[inline] pub fn min_filter(mut self, min_filter: Filter) -> Self { - self.inner.min_filter = min_filter; + self.min_filter = min_filter; self } + #[inline] pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self { - self.inner.mipmap_mode = mipmap_mode; + self.mipmap_mode = mipmap_mode; self } + #[inline] pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self { - self.inner.address_mode_u = address_mode_u; + self.address_mode_u = address_mode_u; self } + #[inline] pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self { - self.inner.address_mode_v = address_mode_v; + self.address_mode_v = address_mode_v; self } + #[inline] pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self { - self.inner.address_mode_w = address_mode_w; + self.address_mode_w = address_mode_w; self } + #[inline] pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self { - self.inner.mip_lod_bias = mip_lod_bias; + self.mip_lod_bias = mip_lod_bias; self } + #[inline] pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self { - self.inner.anisotropy_enable = anisotropy_enable.into(); + self.anisotropy_enable = anisotropy_enable.into(); self } + #[inline] pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self { - self.inner.max_anisotropy = max_anisotropy; + self.max_anisotropy = max_anisotropy; self } + #[inline] pub fn compare_enable(mut self, compare_enable: bool) -> Self { - self.inner.compare_enable = compare_enable.into(); + self.compare_enable = compare_enable.into(); self } + #[inline] pub fn compare_op(mut self, compare_op: CompareOp) -> Self { - self.inner.compare_op = compare_op; + self.compare_op = compare_op; self } + #[inline] pub fn min_lod(mut self, min_lod: f32) -> Self { - self.inner.min_lod = min_lod; + self.min_lod = min_lod; self } + #[inline] pub fn max_lod(mut self, max_lod: f32) -> Self { - self.inner.max_lod = max_lod; + self.max_lod = max_lod; self } + #[inline] pub fn border_color(mut self, border_color: BorderColor) -> Self { - self.inner.border_color = border_color; + self.border_color = border_color; self } + #[inline] pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self { - self.inner.unnormalized_coordinates = unnormalized_coordinates.into(); + self.unnormalized_coordinates = unnormalized_coordinates.into(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandPoolCreateInfo { +pub struct CommandPoolCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: CommandPoolCreateFlags, pub queue_family_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandPoolCreateInfo { +impl ::std::default::Default for CommandPoolCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_POOL_CREATE_INFO, p_next: ::std::ptr::null(), flags: CommandPoolCreateFlags::default(), queue_family_index: u32::default(), + _marker: PhantomData, } } } -impl CommandPoolCreateInfo { - pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> { - CommandPoolCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandPoolCreateInfoBuilder<'a> { - inner: CommandPoolCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { - type Target = CommandPoolCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandPoolCreateInfoBuilder<'a> { +impl<'a> CommandPoolCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { - self.inner.queue_family_index = queue_family_index; + self.queue_family_index = queue_family_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandPoolCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferAllocateInfo { +pub struct CommandBufferAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub command_pool: CommandPool, pub level: CommandBufferLevel, pub command_buffer_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferAllocateInfo { +impl ::std::default::Default for CommandBufferAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO, @@ -6826,58 +4803,32 @@ impl ::std::default::Default for CommandBufferAllocateInfo { command_pool: CommandPool::default(), level: CommandBufferLevel::default(), command_buffer_count: u32::default(), + _marker: PhantomData, } } } -impl CommandBufferAllocateInfo { - pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> { - CommandBufferAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferAllocateInfoBuilder<'a> { - inner: CommandBufferAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { - type Target = CommandBufferAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferAllocateInfoBuilder<'a> { +impl<'a> CommandBufferAllocateInfo<'a> { + #[inline] pub fn command_pool(mut self, command_pool: CommandPool) -> Self { - self.inner.command_pool = command_pool; + self.command_pool = command_pool; self } + #[inline] pub fn level(mut self, level: CommandBufferLevel) -> Self { - self.inner.level = level; + self.level = level; self } + #[inline] pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self { - self.inner.command_buffer_count = command_buffer_count; + self.command_buffer_count = command_buffer_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferInheritanceInfo { +pub struct CommandBufferInheritanceInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub render_pass: RenderPass, @@ -6886,8 +4837,9 @@ pub struct CommandBufferInheritanceInfo { pub occlusion_query_enable: Bool32, pub query_flags: QueryControlFlags, pub pipeline_statistics: QueryPipelineStatisticFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferInheritanceInfo { +impl ::std::default::Default for CommandBufferInheritanceInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO, @@ -6898,159 +4850,113 @@ impl ::std::default::Default for CommandBufferInheritanceInfo { occlusion_query_enable: Bool32::default(), query_flags: QueryControlFlags::default(), pipeline_statistics: QueryPipelineStatisticFlags::default(), + _marker: PhantomData, } } } -impl CommandBufferInheritanceInfo { - pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> { - CommandBufferInheritanceInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferInheritanceInfoBuilder<'a> { - inner: CommandBufferInheritanceInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsCommandBufferInheritanceInfo {} -impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> { - type Target = CommandBufferInheritanceInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferInheritanceInfoBuilder<'a> { +impl<'a> CommandBufferInheritanceInfo<'a> { + #[inline] pub fn render_pass(mut self, render_pass: RenderPass) -> Self { - self.inner.render_pass = render_pass; + self.render_pass = render_pass; self } + #[inline] pub fn subpass(mut self, subpass: u32) -> Self { - self.inner.subpass = subpass; + self.subpass = subpass; self } + #[inline] pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self { - self.inner.framebuffer = framebuffer; + self.framebuffer = framebuffer; self } + #[inline] pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self { - self.inner.occlusion_query_enable = occlusion_query_enable.into(); + self.occlusion_query_enable = occlusion_query_enable.into(); self } + #[inline] pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self { - self.inner.query_flags = query_flags; + self.query_flags = query_flags; self } + #[inline] pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self { - self.inner.pipeline_statistics = pipeline_statistics; + self.pipeline_statistics = pipeline_statistics; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferInheritanceInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferBeginInfo { +pub struct CommandBufferBeginInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: CommandBufferUsageFlags, - pub p_inheritance_info: *const CommandBufferInheritanceInfo, + pub p_inheritance_info: *const CommandBufferInheritanceInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferBeginInfo { +impl ::std::default::Default for CommandBufferBeginInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO, p_next: ::std::ptr::null(), flags: CommandBufferUsageFlags::default(), p_inheritance_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CommandBufferBeginInfo { - pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> { - CommandBufferBeginInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferBeginInfoBuilder<'a> { - inner: CommandBufferBeginInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsCommandBufferBeginInfo {} -impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> { - type Target = CommandBufferBeginInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferBeginInfoBuilder<'a> { +impl<'a> CommandBufferBeginInfo<'a> { + #[inline] pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self { - self.inner.p_inheritance_info = inheritance_info; + #[inline] + pub fn inheritance_info( + mut self, + inheritance_info: &'a CommandBufferInheritanceInfo<'a>, + ) -> Self { + self.p_inheritance_info = inheritance_info; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferBeginInfo { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassBeginInfo { +pub struct RenderPassBeginInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub render_pass: RenderPass, @@ -7058,9 +4964,10 @@ pub struct RenderPassBeginInfo { pub render_area: Rect2D, pub clear_value_count: u32, pub p_clear_values: *const ClearValue, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for RenderPassBeginInfo { +impl fmt::Debug for RenderPassBeginInfo<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("RenderPassBeginInfo") .field("s_type", &self.s_type) @@ -7073,7 +4980,7 @@ impl fmt::Debug for RenderPassBeginInfo { .finish() } } -impl ::std::default::Default for RenderPassBeginInfo { +impl ::std::default::Default for RenderPassBeginInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_BEGIN_INFO, @@ -7083,72 +4990,47 @@ impl ::std::default::Default for RenderPassBeginInfo { render_area: Rect2D::default(), clear_value_count: u32::default(), p_clear_values: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassBeginInfo { - pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> { - RenderPassBeginInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassBeginInfoBuilder<'a> { - inner: RenderPassBeginInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsRenderPassBeginInfo {} -impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> { - type Target = RenderPassBeginInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassBeginInfoBuilder<'a> { +impl<'a> RenderPassBeginInfo<'a> { + #[inline] pub fn render_pass(mut self, render_pass: RenderPass) -> Self { - self.inner.render_pass = render_pass; + self.render_pass = render_pass; self } + #[inline] pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self { - self.inner.framebuffer = framebuffer; + self.framebuffer = framebuffer; self } + #[inline] pub fn render_area(mut self, render_area: Rect2D) -> Self { - self.inner.render_area = render_area; + self.render_area = render_area; self } + #[inline] pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self { - self.inner.clear_value_count = clear_values.len() as _; - self.inner.p_clear_values = clear_values.as_ptr(); + self.clear_value_count = clear_values.len() as _; + self.p_clear_values = clear_values.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassBeginInfo { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -7172,44 +5054,16 @@ pub struct ClearDepthStencilValue { pub stencil: u32, } impl ClearDepthStencilValue { - pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> { - ClearDepthStencilValueBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ClearDepthStencilValueBuilder<'a> { - inner: ClearDepthStencilValue, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> { - type Target = ClearDepthStencilValue; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ClearDepthStencilValueBuilder<'a> { + #[inline] pub fn depth(mut self, depth: f32) -> Self { - self.inner.depth = depth; + self.depth = depth; self } + #[inline] pub fn stencil(mut self, stencil: u32) -> Self { - self.inner.stencil = stencil; + self.stencil = stencil; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ClearDepthStencilValue { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -7242,48 +5096,21 @@ impl fmt::Debug for ClearAttachment { } } impl ClearAttachment { - pub fn builder<'a>() -> ClearAttachmentBuilder<'a> { - ClearAttachmentBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ClearAttachmentBuilder<'a> { - inner: ClearAttachment, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> { - type Target = ClearAttachment; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ClearAttachmentBuilder<'a> { + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } + #[inline] pub fn color_attachment(mut self, color_attachment: u32) -> Self { - self.inner.color_attachment = color_attachment; + self.color_attachment = color_attachment; self } + #[inline] pub fn clear_value(mut self, clear_value: ClearValue) -> Self { - self.inner.clear_value = clear_value; + self.clear_value = clear_value; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ClearAttachment { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -7301,72 +5128,51 @@ pub struct AttachmentDescription { pub final_layout: ImageLayout, } impl AttachmentDescription { - pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> { - AttachmentDescriptionBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentDescriptionBuilder<'a> { - inner: AttachmentDescription, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> { - type Target = AttachmentDescription; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentDescriptionBuilder<'a> { + #[inline] pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn samples(mut self, samples: SampleCountFlags) -> Self { - self.inner.samples = samples; + self.samples = samples; self } + #[inline] pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { - self.inner.load_op = load_op; + self.load_op = load_op; self } + #[inline] pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { - self.inner.store_op = store_op; + self.store_op = store_op; self } + #[inline] pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self { - self.inner.stencil_load_op = stencil_load_op; + self.stencil_load_op = stencil_load_op; self } + #[inline] pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self { - self.inner.stencil_store_op = stencil_store_op; + self.stencil_store_op = stencil_store_op; self } + #[inline] pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { - self.inner.initial_layout = initial_layout; + self.initial_layout = initial_layout; self } + #[inline] pub fn final_layout(mut self, final_layout: ImageLayout) -> Self { - self.inner.final_layout = final_layout; + self.final_layout = final_layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentDescription { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -7377,50 +5183,22 @@ pub struct AttachmentReference { pub layout: ImageLayout, } impl AttachmentReference { - pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> { - AttachmentReferenceBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentReferenceBuilder<'a> { - inner: AttachmentReference, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> { - type Target = AttachmentReference; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentReferenceBuilder<'a> { + #[inline] pub fn attachment(mut self, attachment: u32) -> Self { - self.inner.attachment = attachment; + self.attachment = attachment; self } + #[inline] pub fn layout(mut self, layout: ImageLayout) -> Self { - self.inner.layout = layout; + self.layout = layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentReference { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassDescription { +pub struct SubpassDescription<'a> { pub flags: SubpassDescriptionFlags, pub pipeline_bind_point: PipelineBindPoint, pub input_attachment_count: u32, @@ -7431,8 +5209,9 @@ pub struct SubpassDescription { pub p_depth_stencil_attachment: *const AttachmentReference, pub preserve_attachment_count: u32, pub p_preserve_attachments: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassDescription { +impl ::std::default::Default for SubpassDescription<'_> { fn default() -> Self { Self { flags: SubpassDescriptionFlags::default(), @@ -7445,75 +5224,53 @@ impl ::std::default::Default for SubpassDescription { p_depth_stencil_attachment: ::std::ptr::null(), preserve_attachment_count: u32::default(), p_preserve_attachments: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubpassDescription { - pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> { - SubpassDescriptionBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassDescriptionBuilder<'a> { - inner: SubpassDescription, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> { - type Target = SubpassDescription; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassDescriptionBuilder<'a> { +impl<'a> SubpassDescription<'a> { + #[inline] pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { - self.inner.pipeline_bind_point = pipeline_bind_point; + self.pipeline_bind_point = pipeline_bind_point; self } + #[inline] pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self { - self.inner.input_attachment_count = input_attachments.len() as _; - self.inner.p_input_attachments = input_attachments.as_ptr(); + self.input_attachment_count = input_attachments.len() as _; + self.p_input_attachments = input_attachments.as_ptr(); self } + #[inline] pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self { - self.inner.color_attachment_count = color_attachments.len() as _; - self.inner.p_color_attachments = color_attachments.as_ptr(); + self.color_attachment_count = color_attachments.len() as _; + self.p_color_attachments = color_attachments.as_ptr(); self } + #[inline] pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self { - self.inner.color_attachment_count = resolve_attachments.len() as _; - self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self.color_attachment_count = resolve_attachments.len() as _; + self.p_resolve_attachments = resolve_attachments.as_ptr(); self } + #[inline] pub fn depth_stencil_attachment( mut self, depth_stencil_attachment: &'a AttachmentReference, ) -> Self { - self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self.p_depth_stencil_attachment = depth_stencil_attachment; self } + #[inline] pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self { - self.inner.preserve_attachment_count = preserve_attachments.len() as _; - self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self.preserve_attachment_count = preserve_attachments.len() as _; + self.p_preserve_attachments = preserve_attachments.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassDescription { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -7529,81 +5286,59 @@ pub struct SubpassDependency { pub dependency_flags: DependencyFlags, } impl SubpassDependency { - pub fn builder<'a>() -> SubpassDependencyBuilder<'a> { - SubpassDependencyBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassDependencyBuilder<'a> { - inner: SubpassDependency, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> { - type Target = SubpassDependency; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassDependencyBuilder<'a> { + #[inline] pub fn src_subpass(mut self, src_subpass: u32) -> Self { - self.inner.src_subpass = src_subpass; + self.src_subpass = src_subpass; self } + #[inline] pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { - self.inner.dst_subpass = dst_subpass; + self.dst_subpass = dst_subpass; self } + #[inline] pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self { - self.inner.src_stage_mask = src_stage_mask; + self.src_stage_mask = src_stage_mask; self } + #[inline] pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self { - self.inner.dst_stage_mask = dst_stage_mask; + self.dst_stage_mask = dst_stage_mask; self } + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } + #[inline] pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { - self.inner.dependency_flags = dependency_flags; + self.dependency_flags = dependency_flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassDependency { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassCreateInfo { +pub struct RenderPassCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: RenderPassCreateFlags, pub attachment_count: u32, pub p_attachments: *const AttachmentDescription, pub subpass_count: u32, - pub p_subpasses: *const SubpassDescription, + pub p_subpasses: *const SubpassDescription<'a>, pub dependency_count: u32, pub p_dependencies: *const SubpassDependency, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassCreateInfo { +impl ::std::default::Default for RenderPassCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_CREATE_INFO, @@ -7615,197 +5350,118 @@ impl ::std::default::Default for RenderPassCreateInfo { p_subpasses: ::std::ptr::null(), dependency_count: u32::default(), p_dependencies: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassCreateInfo { - pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> { - RenderPassCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassCreateInfoBuilder<'a> { - inner: RenderPassCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsRenderPassCreateInfo {} -impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> { - type Target = RenderPassCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassCreateInfoBuilder<'a> { +impl<'a> RenderPassCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self { - self.inner.attachment_count = attachments.len() as _; - self.inner.p_attachments = attachments.as_ptr(); + self.attachment_count = attachments.len() as _; + self.p_attachments = attachments.as_ptr(); self } + #[inline] pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self { - self.inner.subpass_count = subpasses.len() as _; - self.inner.p_subpasses = subpasses.as_ptr(); + self.subpass_count = subpasses.len() as _; + self.p_subpasses = subpasses.as_ptr(); self } + #[inline] pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self { - self.inner.dependency_count = dependencies.len() as _; - self.inner.p_dependencies = dependencies.as_ptr(); + self.dependency_count = dependencies.len() as _; + self.p_dependencies = dependencies.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct EventCreateInfo { +pub struct EventCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: EventCreateFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for EventCreateInfo { +impl ::std::default::Default for EventCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::EVENT_CREATE_INFO, p_next: ::std::ptr::null(), flags: EventCreateFlags::default(), + _marker: PhantomData, } } } -impl EventCreateInfo { - pub fn builder<'a>() -> EventCreateInfoBuilder<'a> { - EventCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct EventCreateInfoBuilder<'a> { - inner: EventCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { - type Target = EventCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> EventCreateInfoBuilder<'a> { +impl<'a> EventCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: EventCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> EventCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FenceCreateInfo { +pub struct FenceCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: FenceCreateFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FenceCreateInfo { +impl ::std::default::Default for FenceCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::FENCE_CREATE_INFO, p_next: ::std::ptr::null(), flags: FenceCreateFlags::default(), + _marker: PhantomData, } } } -impl FenceCreateInfo { - pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> { - FenceCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FenceCreateInfoBuilder<'a> { - inner: FenceCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsFenceCreateInfo {} -impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> { - type Target = FenceCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FenceCreateInfoBuilder<'a> { +impl<'a> FenceCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: FenceCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FenceCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -7869,294 +5525,318 @@ pub struct PhysicalDeviceFeatures { pub inherited_queries: Bool32, } impl PhysicalDeviceFeatures { - pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> { - PhysicalDeviceFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFeaturesBuilder<'a> { - inner: PhysicalDeviceFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> { - type Target = PhysicalDeviceFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFeaturesBuilder<'a> { + #[inline] pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self { - self.inner.robust_buffer_access = robust_buffer_access.into(); + self.robust_buffer_access = robust_buffer_access.into(); self } + #[inline] pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self { - self.inner.full_draw_index_uint32 = full_draw_index_uint32.into(); + self.full_draw_index_uint32 = full_draw_index_uint32.into(); self } + #[inline] pub fn image_cube_array(mut self, image_cube_array: bool) -> Self { - self.inner.image_cube_array = image_cube_array.into(); + self.image_cube_array = image_cube_array.into(); self } + #[inline] pub fn independent_blend(mut self, independent_blend: bool) -> Self { - self.inner.independent_blend = independent_blend.into(); + self.independent_blend = independent_blend.into(); self } + #[inline] pub fn geometry_shader(mut self, geometry_shader: bool) -> Self { - self.inner.geometry_shader = geometry_shader.into(); + self.geometry_shader = geometry_shader.into(); self } + #[inline] pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self { - self.inner.tessellation_shader = tessellation_shader.into(); + self.tessellation_shader = tessellation_shader.into(); self } + #[inline] pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self { - self.inner.sample_rate_shading = sample_rate_shading.into(); + self.sample_rate_shading = sample_rate_shading.into(); self } + #[inline] pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self { - self.inner.dual_src_blend = dual_src_blend.into(); + self.dual_src_blend = dual_src_blend.into(); self } + #[inline] pub fn logic_op(mut self, logic_op: bool) -> Self { - self.inner.logic_op = logic_op.into(); + self.logic_op = logic_op.into(); self } + #[inline] pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self { - self.inner.multi_draw_indirect = multi_draw_indirect.into(); + self.multi_draw_indirect = multi_draw_indirect.into(); self } + #[inline] pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self { - self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into(); + self.draw_indirect_first_instance = draw_indirect_first_instance.into(); self } + #[inline] pub fn depth_clamp(mut self, depth_clamp: bool) -> Self { - self.inner.depth_clamp = depth_clamp.into(); + self.depth_clamp = depth_clamp.into(); self } + #[inline] pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self { - self.inner.depth_bias_clamp = depth_bias_clamp.into(); + self.depth_bias_clamp = depth_bias_clamp.into(); self } + #[inline] pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self { - self.inner.fill_mode_non_solid = fill_mode_non_solid.into(); + self.fill_mode_non_solid = fill_mode_non_solid.into(); self } + #[inline] pub fn depth_bounds(mut self, depth_bounds: bool) -> Self { - self.inner.depth_bounds = depth_bounds.into(); + self.depth_bounds = depth_bounds.into(); self } + #[inline] pub fn wide_lines(mut self, wide_lines: bool) -> Self { - self.inner.wide_lines = wide_lines.into(); + self.wide_lines = wide_lines.into(); self } + #[inline] pub fn large_points(mut self, large_points: bool) -> Self { - self.inner.large_points = large_points.into(); + self.large_points = large_points.into(); self } + #[inline] pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self { - self.inner.alpha_to_one = alpha_to_one.into(); + self.alpha_to_one = alpha_to_one.into(); self } + #[inline] pub fn multi_viewport(mut self, multi_viewport: bool) -> Self { - self.inner.multi_viewport = multi_viewport.into(); + self.multi_viewport = multi_viewport.into(); self } + #[inline] pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self { - self.inner.sampler_anisotropy = sampler_anisotropy.into(); + self.sampler_anisotropy = sampler_anisotropy.into(); self } + #[inline] pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self { - self.inner.texture_compression_etc2 = texture_compression_etc2.into(); + self.texture_compression_etc2 = texture_compression_etc2.into(); self } + #[inline] pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self { - self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into(); + self.texture_compression_astc_ldr = texture_compression_astc_ldr.into(); self } + #[inline] pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self { - self.inner.texture_compression_bc = texture_compression_bc.into(); + self.texture_compression_bc = texture_compression_bc.into(); self } + #[inline] pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self { - self.inner.occlusion_query_precise = occlusion_query_precise.into(); + self.occlusion_query_precise = occlusion_query_precise.into(); self } + #[inline] pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self { - self.inner.pipeline_statistics_query = pipeline_statistics_query.into(); + self.pipeline_statistics_query = pipeline_statistics_query.into(); self } + #[inline] pub fn vertex_pipeline_stores_and_atomics( mut self, vertex_pipeline_stores_and_atomics: bool, ) -> Self { - self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into(); + self.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into(); self } + #[inline] pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self { - self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into(); + self.fragment_stores_and_atomics = fragment_stores_and_atomics.into(); self } + #[inline] pub fn shader_tessellation_and_geometry_point_size( mut self, shader_tessellation_and_geometry_point_size: bool, ) -> Self { - self.inner.shader_tessellation_and_geometry_point_size = + self.shader_tessellation_and_geometry_point_size = shader_tessellation_and_geometry_point_size.into(); self } + #[inline] pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self { - self.inner.shader_image_gather_extended = shader_image_gather_extended.into(); + self.shader_image_gather_extended = shader_image_gather_extended.into(); self } + #[inline] pub fn shader_storage_image_extended_formats( mut self, shader_storage_image_extended_formats: bool, ) -> Self { - self.inner.shader_storage_image_extended_formats = - shader_storage_image_extended_formats.into(); + self.shader_storage_image_extended_formats = shader_storage_image_extended_formats.into(); self } + #[inline] pub fn shader_storage_image_multisample( mut self, shader_storage_image_multisample: bool, ) -> Self { - self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into(); + self.shader_storage_image_multisample = shader_storage_image_multisample.into(); self } + #[inline] pub fn shader_storage_image_read_without_format( mut self, shader_storage_image_read_without_format: bool, ) -> Self { - self.inner.shader_storage_image_read_without_format = + self.shader_storage_image_read_without_format = shader_storage_image_read_without_format.into(); self } + #[inline] pub fn shader_storage_image_write_without_format( mut self, shader_storage_image_write_without_format: bool, ) -> Self { - self.inner.shader_storage_image_write_without_format = + self.shader_storage_image_write_without_format = shader_storage_image_write_without_format.into(); self } + #[inline] pub fn shader_uniform_buffer_array_dynamic_indexing( mut self, shader_uniform_buffer_array_dynamic_indexing: bool, ) -> Self { - self.inner.shader_uniform_buffer_array_dynamic_indexing = + self.shader_uniform_buffer_array_dynamic_indexing = shader_uniform_buffer_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_sampled_image_array_dynamic_indexing( mut self, shader_sampled_image_array_dynamic_indexing: bool, ) -> Self { - self.inner.shader_sampled_image_array_dynamic_indexing = + self.shader_sampled_image_array_dynamic_indexing = shader_sampled_image_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_storage_buffer_array_dynamic_indexing( mut self, shader_storage_buffer_array_dynamic_indexing: bool, ) -> Self { - self.inner.shader_storage_buffer_array_dynamic_indexing = + self.shader_storage_buffer_array_dynamic_indexing = shader_storage_buffer_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_storage_image_array_dynamic_indexing( mut self, shader_storage_image_array_dynamic_indexing: bool, ) -> Self { - self.inner.shader_storage_image_array_dynamic_indexing = + self.shader_storage_image_array_dynamic_indexing = shader_storage_image_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self { - self.inner.shader_clip_distance = shader_clip_distance.into(); + self.shader_clip_distance = shader_clip_distance.into(); self } + #[inline] pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self { - self.inner.shader_cull_distance = shader_cull_distance.into(); + self.shader_cull_distance = shader_cull_distance.into(); self } + #[inline] pub fn shader_float64(mut self, shader_float64: bool) -> Self { - self.inner.shader_float64 = shader_float64.into(); + self.shader_float64 = shader_float64.into(); self } + #[inline] pub fn shader_int64(mut self, shader_int64: bool) -> Self { - self.inner.shader_int64 = shader_int64.into(); + self.shader_int64 = shader_int64.into(); self } + #[inline] pub fn shader_int16(mut self, shader_int16: bool) -> Self { - self.inner.shader_int16 = shader_int16.into(); + self.shader_int16 = shader_int16.into(); self } + #[inline] pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self { - self.inner.shader_resource_residency = shader_resource_residency.into(); + self.shader_resource_residency = shader_resource_residency.into(); self } + #[inline] pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self { - self.inner.shader_resource_min_lod = shader_resource_min_lod.into(); + self.shader_resource_min_lod = shader_resource_min_lod.into(); self } + #[inline] pub fn sparse_binding(mut self, sparse_binding: bool) -> Self { - self.inner.sparse_binding = sparse_binding.into(); + self.sparse_binding = sparse_binding.into(); self } + #[inline] pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self { - self.inner.sparse_residency_buffer = sparse_residency_buffer.into(); + self.sparse_residency_buffer = sparse_residency_buffer.into(); self } + #[inline] pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self { - self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into(); + self.sparse_residency_image2_d = sparse_residency_image2_d.into(); self } + #[inline] pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self { - self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into(); + self.sparse_residency_image3_d = sparse_residency_image3_d.into(); self } + #[inline] pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self { - self.inner.sparse_residency2_samples = sparse_residency2_samples.into(); + self.sparse_residency2_samples = sparse_residency2_samples.into(); self } + #[inline] pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self { - self.inner.sparse_residency4_samples = sparse_residency4_samples.into(); + self.sparse_residency4_samples = sparse_residency4_samples.into(); self } + #[inline] pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self { - self.inner.sparse_residency8_samples = sparse_residency8_samples.into(); + self.sparse_residency8_samples = sparse_residency8_samples.into(); self } + #[inline] pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self { - self.inner.sparse_residency16_samples = sparse_residency16_samples.into(); + self.sparse_residency16_samples = sparse_residency16_samples.into(); self } + #[inline] pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self { - self.inner.sparse_residency_aliased = sparse_residency_aliased.into(); + self.sparse_residency_aliased = sparse_residency_aliased.into(); self } + #[inline] pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self { - self.inner.variable_multisample_rate = variable_multisample_rate.into(); + self.variable_multisample_rate = variable_multisample_rate.into(); self } + #[inline] pub fn inherited_queries(mut self, inherited_queries: bool) -> Self { - self.inner.inherited_queries = inherited_queries.into(); + self.inherited_queries = inherited_queries.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -8170,66 +5850,41 @@ pub struct PhysicalDeviceSparseProperties { pub residency_non_resident_strict: Bool32, } impl PhysicalDeviceSparseProperties { - pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> { - PhysicalDeviceSparsePropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSparsePropertiesBuilder<'a> { - inner: PhysicalDeviceSparseProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> { - type Target = PhysicalDeviceSparseProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> { + #[inline] pub fn residency_standard2_d_block_shape( mut self, residency_standard2_d_block_shape: bool, ) -> Self { - self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into(); + self.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into(); self } + #[inline] pub fn residency_standard2_d_multisample_block_shape( mut self, residency_standard2_d_multisample_block_shape: bool, ) -> Self { - self.inner.residency_standard2_d_multisample_block_shape = + self.residency_standard2_d_multisample_block_shape = residency_standard2_d_multisample_block_shape.into(); self } + #[inline] pub fn residency_standard3_d_block_shape( mut self, residency_standard3_d_block_shape: bool, ) -> Self { - self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into(); + self.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into(); self } + #[inline] pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self { - self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into(); + self.residency_aligned_mip_size = residency_aligned_mip_size.into(); self } + #[inline] pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self { - self.inner.residency_non_resident_strict = residency_non_resident_strict.into(); + self.residency_non_resident_strict = residency_non_resident_strict.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSparseProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -8456,684 +6111,725 @@ impl ::std::default::Default for PhysicalDeviceLimits { } } impl PhysicalDeviceLimits { - pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> { - PhysicalDeviceLimitsBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceLimitsBuilder<'a> { - inner: PhysicalDeviceLimits, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> { - type Target = PhysicalDeviceLimits; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceLimitsBuilder<'a> { + #[inline] pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self { - self.inner.max_image_dimension1_d = max_image_dimension1_d; + self.max_image_dimension1_d = max_image_dimension1_d; self } + #[inline] pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self { - self.inner.max_image_dimension2_d = max_image_dimension2_d; + self.max_image_dimension2_d = max_image_dimension2_d; self } + #[inline] pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self { - self.inner.max_image_dimension3_d = max_image_dimension3_d; + self.max_image_dimension3_d = max_image_dimension3_d; self } + #[inline] pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self { - self.inner.max_image_dimension_cube = max_image_dimension_cube; + self.max_image_dimension_cube = max_image_dimension_cube; self } + #[inline] pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { - self.inner.max_image_array_layers = max_image_array_layers; + self.max_image_array_layers = max_image_array_layers; self } + #[inline] pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self { - self.inner.max_texel_buffer_elements = max_texel_buffer_elements; + self.max_texel_buffer_elements = max_texel_buffer_elements; self } + #[inline] pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self { - self.inner.max_uniform_buffer_range = max_uniform_buffer_range; + self.max_uniform_buffer_range = max_uniform_buffer_range; self } + #[inline] pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self { - self.inner.max_storage_buffer_range = max_storage_buffer_range; + self.max_storage_buffer_range = max_storage_buffer_range; self } + #[inline] pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self { - self.inner.max_push_constants_size = max_push_constants_size; + self.max_push_constants_size = max_push_constants_size; self } + #[inline] pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self { - self.inner.max_memory_allocation_count = max_memory_allocation_count; + self.max_memory_allocation_count = max_memory_allocation_count; self } + #[inline] pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self { - self.inner.max_sampler_allocation_count = max_sampler_allocation_count; + self.max_sampler_allocation_count = max_sampler_allocation_count; self } + #[inline] pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self { - self.inner.buffer_image_granularity = buffer_image_granularity; + self.buffer_image_granularity = buffer_image_granularity; self } + #[inline] pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self { - self.inner.sparse_address_space_size = sparse_address_space_size; + self.sparse_address_space_size = sparse_address_space_size; self } + #[inline] pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self { - self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets; + self.max_bound_descriptor_sets = max_bound_descriptor_sets; self } + #[inline] pub fn max_per_stage_descriptor_samplers( mut self, max_per_stage_descriptor_samplers: u32, ) -> Self { - self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers; + self.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers; self } + #[inline] pub fn max_per_stage_descriptor_uniform_buffers( mut self, max_per_stage_descriptor_uniform_buffers: u32, ) -> Self { - self.inner.max_per_stage_descriptor_uniform_buffers = - max_per_stage_descriptor_uniform_buffers; + self.max_per_stage_descriptor_uniform_buffers = max_per_stage_descriptor_uniform_buffers; self } + #[inline] pub fn max_per_stage_descriptor_storage_buffers( mut self, max_per_stage_descriptor_storage_buffers: u32, ) -> Self { - self.inner.max_per_stage_descriptor_storage_buffers = - max_per_stage_descriptor_storage_buffers; + self.max_per_stage_descriptor_storage_buffers = max_per_stage_descriptor_storage_buffers; self } + #[inline] pub fn max_per_stage_descriptor_sampled_images( mut self, max_per_stage_descriptor_sampled_images: u32, ) -> Self { - self.inner.max_per_stage_descriptor_sampled_images = - max_per_stage_descriptor_sampled_images; + self.max_per_stage_descriptor_sampled_images = max_per_stage_descriptor_sampled_images; self } + #[inline] pub fn max_per_stage_descriptor_storage_images( mut self, max_per_stage_descriptor_storage_images: u32, ) -> Self { - self.inner.max_per_stage_descriptor_storage_images = - max_per_stage_descriptor_storage_images; + self.max_per_stage_descriptor_storage_images = max_per_stage_descriptor_storage_images; self } + #[inline] pub fn max_per_stage_descriptor_input_attachments( mut self, max_per_stage_descriptor_input_attachments: u32, ) -> Self { - self.inner.max_per_stage_descriptor_input_attachments = + self.max_per_stage_descriptor_input_attachments = max_per_stage_descriptor_input_attachments; self } + #[inline] pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self { - self.inner.max_per_stage_resources = max_per_stage_resources; + self.max_per_stage_resources = max_per_stage_resources; self } + #[inline] pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self { - self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers; + self.max_descriptor_set_samplers = max_descriptor_set_samplers; self } + #[inline] pub fn max_descriptor_set_uniform_buffers( mut self, max_descriptor_set_uniform_buffers: u32, ) -> Self { - self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers; + self.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers; self } + #[inline] pub fn max_descriptor_set_uniform_buffers_dynamic( mut self, max_descriptor_set_uniform_buffers_dynamic: u32, ) -> Self { - self.inner.max_descriptor_set_uniform_buffers_dynamic = + self.max_descriptor_set_uniform_buffers_dynamic = max_descriptor_set_uniform_buffers_dynamic; self } + #[inline] pub fn max_descriptor_set_storage_buffers( mut self, max_descriptor_set_storage_buffers: u32, ) -> Self { - self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers; + self.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers; self } + #[inline] pub fn max_descriptor_set_storage_buffers_dynamic( mut self, max_descriptor_set_storage_buffers_dynamic: u32, ) -> Self { - self.inner.max_descriptor_set_storage_buffers_dynamic = + self.max_descriptor_set_storage_buffers_dynamic = max_descriptor_set_storage_buffers_dynamic; self } + #[inline] pub fn max_descriptor_set_sampled_images( mut self, max_descriptor_set_sampled_images: u32, ) -> Self { - self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images; + self.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images; self } + #[inline] pub fn max_descriptor_set_storage_images( mut self, max_descriptor_set_storage_images: u32, ) -> Self { - self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images; + self.max_descriptor_set_storage_images = max_descriptor_set_storage_images; self } + #[inline] pub fn max_descriptor_set_input_attachments( mut self, max_descriptor_set_input_attachments: u32, ) -> Self { - self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments; + self.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments; self } + #[inline] pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self { - self.inner.max_vertex_input_attributes = max_vertex_input_attributes; + self.max_vertex_input_attributes = max_vertex_input_attributes; self } + #[inline] pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self { - self.inner.max_vertex_input_bindings = max_vertex_input_bindings; + self.max_vertex_input_bindings = max_vertex_input_bindings; self } + #[inline] pub fn max_vertex_input_attribute_offset( mut self, max_vertex_input_attribute_offset: u32, ) -> Self { - self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset; + self.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset; self } + #[inline] pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self { - self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride; + self.max_vertex_input_binding_stride = max_vertex_input_binding_stride; self } + #[inline] pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self { - self.inner.max_vertex_output_components = max_vertex_output_components; + self.max_vertex_output_components = max_vertex_output_components; self } + #[inline] pub fn max_tessellation_generation_level( mut self, max_tessellation_generation_level: u32, ) -> Self { - self.inner.max_tessellation_generation_level = max_tessellation_generation_level; + self.max_tessellation_generation_level = max_tessellation_generation_level; self } + #[inline] pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self { - self.inner.max_tessellation_patch_size = max_tessellation_patch_size; + self.max_tessellation_patch_size = max_tessellation_patch_size; self } + #[inline] pub fn max_tessellation_control_per_vertex_input_components( mut self, max_tessellation_control_per_vertex_input_components: u32, ) -> Self { - self.inner - .max_tessellation_control_per_vertex_input_components = + self.max_tessellation_control_per_vertex_input_components = max_tessellation_control_per_vertex_input_components; self } + #[inline] pub fn max_tessellation_control_per_vertex_output_components( mut self, max_tessellation_control_per_vertex_output_components: u32, ) -> Self { - self.inner - .max_tessellation_control_per_vertex_output_components = + self.max_tessellation_control_per_vertex_output_components = max_tessellation_control_per_vertex_output_components; self } + #[inline] pub fn max_tessellation_control_per_patch_output_components( mut self, max_tessellation_control_per_patch_output_components: u32, ) -> Self { - self.inner - .max_tessellation_control_per_patch_output_components = + self.max_tessellation_control_per_patch_output_components = max_tessellation_control_per_patch_output_components; self } + #[inline] pub fn max_tessellation_control_total_output_components( mut self, max_tessellation_control_total_output_components: u32, ) -> Self { - self.inner.max_tessellation_control_total_output_components = + self.max_tessellation_control_total_output_components = max_tessellation_control_total_output_components; self } + #[inline] pub fn max_tessellation_evaluation_input_components( mut self, max_tessellation_evaluation_input_components: u32, ) -> Self { - self.inner.max_tessellation_evaluation_input_components = + self.max_tessellation_evaluation_input_components = max_tessellation_evaluation_input_components; self } + #[inline] pub fn max_tessellation_evaluation_output_components( mut self, max_tessellation_evaluation_output_components: u32, ) -> Self { - self.inner.max_tessellation_evaluation_output_components = + self.max_tessellation_evaluation_output_components = max_tessellation_evaluation_output_components; self } + #[inline] pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self { - self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations; + self.max_geometry_shader_invocations = max_geometry_shader_invocations; self } + #[inline] pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self { - self.inner.max_geometry_input_components = max_geometry_input_components; + self.max_geometry_input_components = max_geometry_input_components; self } + #[inline] pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self { - self.inner.max_geometry_output_components = max_geometry_output_components; + self.max_geometry_output_components = max_geometry_output_components; self } + #[inline] pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self { - self.inner.max_geometry_output_vertices = max_geometry_output_vertices; + self.max_geometry_output_vertices = max_geometry_output_vertices; self } + #[inline] pub fn max_geometry_total_output_components( mut self, max_geometry_total_output_components: u32, ) -> Self { - self.inner.max_geometry_total_output_components = max_geometry_total_output_components; + self.max_geometry_total_output_components = max_geometry_total_output_components; self } + #[inline] pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self { - self.inner.max_fragment_input_components = max_fragment_input_components; + self.max_fragment_input_components = max_fragment_input_components; self } + #[inline] pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self { - self.inner.max_fragment_output_attachments = max_fragment_output_attachments; + self.max_fragment_output_attachments = max_fragment_output_attachments; self } + #[inline] pub fn max_fragment_dual_src_attachments( mut self, max_fragment_dual_src_attachments: u32, ) -> Self { - self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments; + self.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments; self } + #[inline] pub fn max_fragment_combined_output_resources( mut self, max_fragment_combined_output_resources: u32, ) -> Self { - self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources; + self.max_fragment_combined_output_resources = max_fragment_combined_output_resources; self } + #[inline] pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self { - self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size; + self.max_compute_shared_memory_size = max_compute_shared_memory_size; self } + #[inline] pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self { - self.inner.max_compute_work_group_count = max_compute_work_group_count; + self.max_compute_work_group_count = max_compute_work_group_count; self } + #[inline] pub fn max_compute_work_group_invocations( mut self, max_compute_work_group_invocations: u32, ) -> Self { - self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations; + self.max_compute_work_group_invocations = max_compute_work_group_invocations; self } + #[inline] pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self { - self.inner.max_compute_work_group_size = max_compute_work_group_size; + self.max_compute_work_group_size = max_compute_work_group_size; self } + #[inline] pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self { - self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits; + self.sub_pixel_precision_bits = sub_pixel_precision_bits; self } + #[inline] pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self { - self.inner.sub_texel_precision_bits = sub_texel_precision_bits; + self.sub_texel_precision_bits = sub_texel_precision_bits; self } + #[inline] pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self { - self.inner.mipmap_precision_bits = mipmap_precision_bits; + self.mipmap_precision_bits = mipmap_precision_bits; self } + #[inline] pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self { - self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value; + self.max_draw_indexed_index_value = max_draw_indexed_index_value; self } + #[inline] pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self { - self.inner.max_draw_indirect_count = max_draw_indirect_count; + self.max_draw_indirect_count = max_draw_indirect_count; self } + #[inline] pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self { - self.inner.max_sampler_lod_bias = max_sampler_lod_bias; + self.max_sampler_lod_bias = max_sampler_lod_bias; self } + #[inline] pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self { - self.inner.max_sampler_anisotropy = max_sampler_anisotropy; + self.max_sampler_anisotropy = max_sampler_anisotropy; self } + #[inline] pub fn max_viewports(mut self, max_viewports: u32) -> Self { - self.inner.max_viewports = max_viewports; + self.max_viewports = max_viewports; self } + #[inline] pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self { - self.inner.max_viewport_dimensions = max_viewport_dimensions; + self.max_viewport_dimensions = max_viewport_dimensions; self } + #[inline] pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self { - self.inner.viewport_bounds_range = viewport_bounds_range; + self.viewport_bounds_range = viewport_bounds_range; self } + #[inline] pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self { - self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits; + self.viewport_sub_pixel_bits = viewport_sub_pixel_bits; self } + #[inline] pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self { - self.inner.min_memory_map_alignment = min_memory_map_alignment; + self.min_memory_map_alignment = min_memory_map_alignment; self } + #[inline] pub fn min_texel_buffer_offset_alignment( mut self, min_texel_buffer_offset_alignment: DeviceSize, ) -> Self { - self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment; + self.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment; self } + #[inline] pub fn min_uniform_buffer_offset_alignment( mut self, min_uniform_buffer_offset_alignment: DeviceSize, ) -> Self { - self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment; + self.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment; self } + #[inline] pub fn min_storage_buffer_offset_alignment( mut self, min_storage_buffer_offset_alignment: DeviceSize, ) -> Self { - self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment; + self.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment; self } + #[inline] pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self { - self.inner.min_texel_offset = min_texel_offset; + self.min_texel_offset = min_texel_offset; self } + #[inline] pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self { - self.inner.max_texel_offset = max_texel_offset; + self.max_texel_offset = max_texel_offset; self } + #[inline] pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self { - self.inner.min_texel_gather_offset = min_texel_gather_offset; + self.min_texel_gather_offset = min_texel_gather_offset; self } + #[inline] pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self { - self.inner.max_texel_gather_offset = max_texel_gather_offset; + self.max_texel_gather_offset = max_texel_gather_offset; self } + #[inline] pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self { - self.inner.min_interpolation_offset = min_interpolation_offset; + self.min_interpolation_offset = min_interpolation_offset; self } + #[inline] pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self { - self.inner.max_interpolation_offset = max_interpolation_offset; + self.max_interpolation_offset = max_interpolation_offset; self } + #[inline] pub fn sub_pixel_interpolation_offset_bits( mut self, sub_pixel_interpolation_offset_bits: u32, ) -> Self { - self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits; + self.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits; self } + #[inline] pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self { - self.inner.max_framebuffer_width = max_framebuffer_width; + self.max_framebuffer_width = max_framebuffer_width; self } + #[inline] pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self { - self.inner.max_framebuffer_height = max_framebuffer_height; + self.max_framebuffer_height = max_framebuffer_height; self } + #[inline] pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self { - self.inner.max_framebuffer_layers = max_framebuffer_layers; + self.max_framebuffer_layers = max_framebuffer_layers; self } + #[inline] pub fn framebuffer_color_sample_counts( mut self, framebuffer_color_sample_counts: SampleCountFlags, ) -> Self { - self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts; + self.framebuffer_color_sample_counts = framebuffer_color_sample_counts; self } + #[inline] pub fn framebuffer_depth_sample_counts( mut self, framebuffer_depth_sample_counts: SampleCountFlags, ) -> Self { - self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts; + self.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts; self } + #[inline] pub fn framebuffer_stencil_sample_counts( mut self, framebuffer_stencil_sample_counts: SampleCountFlags, ) -> Self { - self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts; + self.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts; self } + #[inline] pub fn framebuffer_no_attachments_sample_counts( mut self, framebuffer_no_attachments_sample_counts: SampleCountFlags, ) -> Self { - self.inner.framebuffer_no_attachments_sample_counts = - framebuffer_no_attachments_sample_counts; + self.framebuffer_no_attachments_sample_counts = framebuffer_no_attachments_sample_counts; self } + #[inline] pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self { - self.inner.max_color_attachments = max_color_attachments; + self.max_color_attachments = max_color_attachments; self } + #[inline] pub fn sampled_image_color_sample_counts( mut self, sampled_image_color_sample_counts: SampleCountFlags, ) -> Self { - self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts; + self.sampled_image_color_sample_counts = sampled_image_color_sample_counts; self } + #[inline] pub fn sampled_image_integer_sample_counts( mut self, sampled_image_integer_sample_counts: SampleCountFlags, ) -> Self { - self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts; + self.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts; self } + #[inline] pub fn sampled_image_depth_sample_counts( mut self, sampled_image_depth_sample_counts: SampleCountFlags, ) -> Self { - self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts; + self.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts; self } + #[inline] pub fn sampled_image_stencil_sample_counts( mut self, sampled_image_stencil_sample_counts: SampleCountFlags, ) -> Self { - self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts; + self.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts; self } + #[inline] pub fn storage_image_sample_counts( mut self, storage_image_sample_counts: SampleCountFlags, ) -> Self { - self.inner.storage_image_sample_counts = storage_image_sample_counts; + self.storage_image_sample_counts = storage_image_sample_counts; self } + #[inline] pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self { - self.inner.max_sample_mask_words = max_sample_mask_words; + self.max_sample_mask_words = max_sample_mask_words; self } + #[inline] pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self { - self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into(); + self.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into(); self } + #[inline] pub fn timestamp_period(mut self, timestamp_period: f32) -> Self { - self.inner.timestamp_period = timestamp_period; + self.timestamp_period = timestamp_period; self } + #[inline] pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self { - self.inner.max_clip_distances = max_clip_distances; + self.max_clip_distances = max_clip_distances; self } + #[inline] pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self { - self.inner.max_cull_distances = max_cull_distances; + self.max_cull_distances = max_cull_distances; self } + #[inline] pub fn max_combined_clip_and_cull_distances( mut self, max_combined_clip_and_cull_distances: u32, ) -> Self { - self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances; + self.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances; self } + #[inline] pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self { - self.inner.discrete_queue_priorities = discrete_queue_priorities; + self.discrete_queue_priorities = discrete_queue_priorities; self } + #[inline] pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self { - self.inner.point_size_range = point_size_range; + self.point_size_range = point_size_range; self } + #[inline] pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self { - self.inner.line_width_range = line_width_range; + self.line_width_range = line_width_range; self } + #[inline] pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self { - self.inner.point_size_granularity = point_size_granularity; + self.point_size_granularity = point_size_granularity; self } + #[inline] pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self { - self.inner.line_width_granularity = line_width_granularity; + self.line_width_granularity = line_width_granularity; self } + #[inline] pub fn strict_lines(mut self, strict_lines: bool) -> Self { - self.inner.strict_lines = strict_lines.into(); + self.strict_lines = strict_lines.into(); self } + #[inline] pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self { - self.inner.standard_sample_locations = standard_sample_locations.into(); + self.standard_sample_locations = standard_sample_locations.into(); self } + #[inline] pub fn optimal_buffer_copy_offset_alignment( mut self, optimal_buffer_copy_offset_alignment: DeviceSize, ) -> Self { - self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment; + self.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment; self } + #[inline] pub fn optimal_buffer_copy_row_pitch_alignment( mut self, optimal_buffer_copy_row_pitch_alignment: DeviceSize, ) -> Self { - self.inner.optimal_buffer_copy_row_pitch_alignment = - optimal_buffer_copy_row_pitch_alignment; + self.optimal_buffer_copy_row_pitch_alignment = optimal_buffer_copy_row_pitch_alignment; self } + #[inline] pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self { - self.inner.non_coherent_atom_size = non_coherent_atom_size; + self.non_coherent_atom_size = non_coherent_atom_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceLimits { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreCreateInfo { +pub struct SemaphoreCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SemaphoreCreateFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreCreateInfo { +impl ::std::default::Default for SemaphoreCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_CREATE_INFO, p_next: ::std::ptr::null(), flags: SemaphoreCreateFlags::default(), + _marker: PhantomData, } } } -impl SemaphoreCreateInfo { - pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> { - SemaphoreCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreCreateInfoBuilder<'a> { - inner: SemaphoreCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSemaphoreCreateInfo {} -impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> { - type Target = SemaphoreCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreCreateInfoBuilder<'a> { +impl<'a> SemaphoreCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueryPoolCreateInfo { +pub struct QueryPoolCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: QueryPoolCreateFlags, pub query_type: QueryType, pub query_count: u32, pub pipeline_statistics: QueryPipelineStatisticFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueryPoolCreateInfo { +impl ::std::default::Default for QueryPoolCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::QUERY_POOL_CREATE_INFO, @@ -9142,77 +6838,52 @@ impl ::std::default::Default for QueryPoolCreateInfo { query_type: QueryType::default(), query_count: u32::default(), pipeline_statistics: QueryPipelineStatisticFlags::default(), + _marker: PhantomData, } } } -impl QueryPoolCreateInfo { - pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> { - QueryPoolCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueryPoolCreateInfoBuilder<'a> { - inner: QueryPoolCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsQueryPoolCreateInfo {} -impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> { - type Target = QueryPoolCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueryPoolCreateInfoBuilder<'a> { +impl<'a> QueryPoolCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn query_type(mut self, query_type: QueryType) -> Self { - self.inner.query_type = query_type; + self.query_type = query_type; self } + #[inline] pub fn query_count(mut self, query_count: u32) -> Self { - self.inner.query_count = query_count; + self.query_count = query_count; self } + #[inline] pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self { - self.inner.pipeline_statistics = pipeline_statistics; + self.pipeline_statistics = pipeline_statistics; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueryPoolCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FramebufferCreateInfo { +pub struct FramebufferCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: FramebufferCreateFlags, @@ -9222,8 +6893,9 @@ pub struct FramebufferCreateInfo { pub width: u32, pub height: u32, pub layers: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FramebufferCreateInfo { +impl ::std::default::Default for FramebufferCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::FRAMEBUFFER_CREATE_INFO, @@ -9235,80 +6907,57 @@ impl ::std::default::Default for FramebufferCreateInfo { width: u32::default(), height: u32::default(), layers: u32::default(), + _marker: PhantomData, } } } -impl FramebufferCreateInfo { - pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> { - FramebufferCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FramebufferCreateInfoBuilder<'a> { - inner: FramebufferCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsFramebufferCreateInfo {} -impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> { - type Target = FramebufferCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FramebufferCreateInfoBuilder<'a> { +impl<'a> FramebufferCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn render_pass(mut self, render_pass: RenderPass) -> Self { - self.inner.render_pass = render_pass; + self.render_pass = render_pass; self } + #[inline] pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self { - self.inner.attachment_count = attachments.len() as _; - self.inner.p_attachments = attachments.as_ptr(); + self.attachment_count = attachments.len() as _; + self.p_attachments = attachments.as_ptr(); self } + #[inline] pub fn width(mut self, width: u32) -> Self { - self.inner.width = width; + self.width = width; self } + #[inline] pub fn height(mut self, height: u32) -> Self { - self.inner.height = height; + self.height = height; self } + #[inline] pub fn layers(mut self, layers: u32) -> Self { - self.inner.layers = layers; + self.layers = layers; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FramebufferCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9321,52 +6970,26 @@ pub struct DrawIndirectCommand { pub first_instance: u32, } impl DrawIndirectCommand { - pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> { - DrawIndirectCommandBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrawIndirectCommandBuilder<'a> { - inner: DrawIndirectCommand, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> { - type Target = DrawIndirectCommand; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrawIndirectCommandBuilder<'a> { + #[inline] pub fn vertex_count(mut self, vertex_count: u32) -> Self { - self.inner.vertex_count = vertex_count; + self.vertex_count = vertex_count; self } + #[inline] pub fn instance_count(mut self, instance_count: u32) -> Self { - self.inner.instance_count = instance_count; + self.instance_count = instance_count; self } + #[inline] pub fn first_vertex(mut self, first_vertex: u32) -> Self { - self.inner.first_vertex = first_vertex; + self.first_vertex = first_vertex; self } + #[inline] pub fn first_instance(mut self, first_instance: u32) -> Self { - self.inner.first_instance = first_instance; + self.first_instance = first_instance; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrawIndirectCommand { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9380,56 +7003,31 @@ pub struct DrawIndexedIndirectCommand { pub first_instance: u32, } impl DrawIndexedIndirectCommand { - pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> { - DrawIndexedIndirectCommandBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrawIndexedIndirectCommandBuilder<'a> { - inner: DrawIndexedIndirectCommand, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> { - type Target = DrawIndexedIndirectCommand; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrawIndexedIndirectCommandBuilder<'a> { + #[inline] pub fn index_count(mut self, index_count: u32) -> Self { - self.inner.index_count = index_count; + self.index_count = index_count; self } + #[inline] pub fn instance_count(mut self, instance_count: u32) -> Self { - self.inner.instance_count = instance_count; + self.instance_count = instance_count; self } + #[inline] pub fn first_index(mut self, first_index: u32) -> Self { - self.inner.first_index = first_index; + self.first_index = first_index; self } + #[inline] pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { - self.inner.vertex_offset = vertex_offset; + self.vertex_offset = vertex_offset; self } + #[inline] pub fn first_instance(mut self, first_instance: u32) -> Self { - self.inner.first_instance = first_instance; + self.first_instance = first_instance; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrawIndexedIndirectCommand { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9441,48 +7039,21 @@ pub struct DispatchIndirectCommand { pub z: u32, } impl DispatchIndirectCommand { - pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> { - DispatchIndirectCommandBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DispatchIndirectCommandBuilder<'a> { - inner: DispatchIndirectCommand, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> { - type Target = DispatchIndirectCommand; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DispatchIndirectCommandBuilder<'a> { + #[inline] pub fn x(mut self, x: u32) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: u32) -> Self { - self.inner.y = y; + self.y = y; self } + #[inline] pub fn z(mut self, z: u32) -> Self { - self.inner.z = z; + self.z = z; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DispatchIndirectCommand { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9493,44 +7064,16 @@ pub struct MultiDrawInfoEXT { pub vertex_count: u32, } impl MultiDrawInfoEXT { - pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> { - MultiDrawInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MultiDrawInfoEXTBuilder<'a> { - inner: MultiDrawInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MultiDrawInfoEXTBuilder<'a> { - type Target = MultiDrawInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MultiDrawInfoEXTBuilder<'a> { + #[inline] pub fn first_vertex(mut self, first_vertex: u32) -> Self { - self.inner.first_vertex = first_vertex; + self.first_vertex = first_vertex; self } + #[inline] pub fn vertex_count(mut self, vertex_count: u32) -> Self { - self.inner.vertex_count = vertex_count; + self.vertex_count = vertex_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MultiDrawInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9542,54 +7085,27 @@ pub struct MultiDrawIndexedInfoEXT { pub vertex_offset: i32, } impl MultiDrawIndexedInfoEXT { - pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> { - MultiDrawIndexedInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MultiDrawIndexedInfoEXTBuilder<'a> { - inner: MultiDrawIndexedInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MultiDrawIndexedInfoEXTBuilder<'a> { - type Target = MultiDrawIndexedInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> { + #[inline] pub fn first_index(mut self, first_index: u32) -> Self { - self.inner.first_index = first_index; + self.first_index = first_index; self } + #[inline] pub fn index_count(mut self, index_count: u32) -> Self { - self.inner.index_count = index_count; + self.index_count = index_count; self } + #[inline] pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { - self.inner.vertex_offset = vertex_offset; + self.vertex_offset = vertex_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MultiDrawIndexedInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubmitInfo { +pub struct SubmitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub wait_semaphore_count: u32, @@ -9599,8 +7115,9 @@ pub struct SubmitInfo { pub p_command_buffers: *const CommandBuffer, pub signal_semaphore_count: u32, pub p_signal_semaphores: *const Semaphore, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubmitInfo { +impl ::std::default::Default for SubmitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SUBMIT_INFO, @@ -9612,81 +7129,56 @@ impl ::std::default::Default for SubmitInfo { p_command_buffers: ::std::ptr::null(), signal_semaphore_count: u32::default(), p_signal_semaphores: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubmitInfo { - pub fn builder<'a>() -> SubmitInfoBuilder<'a> { - SubmitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubmitInfoBuilder<'a> { - inner: SubmitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSubmitInfo {} -impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { - type Target = SubmitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubmitInfoBuilder<'a> { +impl<'a> SubmitInfo<'a> { + #[inline] pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { - self.inner.wait_semaphore_count = wait_semaphores.len() as _; - self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self.wait_semaphore_count = wait_semaphores.len() as _; + self.p_wait_semaphores = wait_semaphores.as_ptr(); self } + #[inline] pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self { - self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _; - self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr(); + self.wait_semaphore_count = wait_dst_stage_mask.len() as _; + self.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr(); self } + #[inline] pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self { - self.inner.command_buffer_count = command_buffers.len() as _; - self.inner.p_command_buffers = command_buffers.as_ptr(); + self.command_buffer_count = command_buffers.len() as _; + self.p_command_buffers = command_buffers.as_ptr(); self } + #[inline] pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self { - self.inner.signal_semaphore_count = signal_semaphores.len() as _; - self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self.signal_semaphore_count = signal_semaphores.len() as _; + self.p_signal_semaphores = signal_semaphores.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubmitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayPropertiesKHR { +pub struct DisplayPropertiesKHR<'a> { pub display: DisplayKHR, pub display_name: *const c_char, pub physical_dimensions: Extent2D, @@ -9694,8 +7186,9 @@ pub struct DisplayPropertiesKHR { pub supported_transforms: SurfaceTransformFlagsKHR, pub plane_reorder_possible: Bool32, pub persistent_content: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayPropertiesKHR { +impl ::std::default::Default for DisplayPropertiesKHR<'_> { fn default() -> Self { Self { display: DisplayKHR::default(), @@ -9705,68 +7198,46 @@ impl ::std::default::Default for DisplayPropertiesKHR { supported_transforms: SurfaceTransformFlagsKHR::default(), plane_reorder_possible: Bool32::default(), persistent_content: Bool32::default(), + _marker: PhantomData, } } } -impl DisplayPropertiesKHR { - pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> { - DisplayPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPropertiesKHRBuilder<'a> { - inner: DisplayPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> { - type Target = DisplayPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPropertiesKHRBuilder<'a> { +impl<'a> DisplayPropertiesKHR<'a> { + #[inline] pub fn display(mut self, display: DisplayKHR) -> Self { - self.inner.display = display; + self.display = display; self } + #[inline] pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self { - self.inner.display_name = display_name.as_ptr(); + self.display_name = display_name.as_ptr(); self } + #[inline] pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self { - self.inner.physical_dimensions = physical_dimensions; + self.physical_dimensions = physical_dimensions; self } + #[inline] pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self { - self.inner.physical_resolution = physical_resolution; + self.physical_resolution = physical_resolution; self } + #[inline] pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { - self.inner.supported_transforms = supported_transforms; + self.supported_transforms = supported_transforms; self } + #[inline] pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self { - self.inner.plane_reorder_possible = plane_reorder_possible.into(); + self.plane_reorder_possible = plane_reorder_possible.into(); self } + #[inline] pub fn persistent_content(mut self, persistent_content: bool) -> Self { - self.inner.persistent_content = persistent_content.into(); + self.persistent_content = persistent_content.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9777,44 +7248,16 @@ pub struct DisplayPlanePropertiesKHR { pub current_stack_index: u32, } impl DisplayPlanePropertiesKHR { - pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> { - DisplayPlanePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPlanePropertiesKHRBuilder<'a> { - inner: DisplayPlanePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> { - type Target = DisplayPlanePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPlanePropertiesKHRBuilder<'a> { + #[inline] pub fn current_display(mut self, current_display: DisplayKHR) -> Self { - self.inner.current_display = current_display; + self.current_display = current_display; self } + #[inline] pub fn current_stack_index(mut self, current_stack_index: u32) -> Self { - self.inner.current_stack_index = current_stack_index; + self.current_stack_index = current_stack_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPlanePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9825,44 +7268,16 @@ pub struct DisplayModeParametersKHR { pub refresh_rate: u32, } impl DisplayModeParametersKHR { - pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> { - DisplayModeParametersKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayModeParametersKHRBuilder<'a> { - inner: DisplayModeParametersKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> { - type Target = DisplayModeParametersKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayModeParametersKHRBuilder<'a> { + #[inline] pub fn visible_region(mut self, visible_region: Extent2D) -> Self { - self.inner.visible_region = visible_region; + self.visible_region = visible_region; self } + #[inline] pub fn refresh_rate(mut self, refresh_rate: u32) -> Self { - self.inner.refresh_rate = refresh_rate; + self.refresh_rate = refresh_rate; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayModeParametersKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9873,104 +7288,50 @@ pub struct DisplayModePropertiesKHR { pub parameters: DisplayModeParametersKHR, } impl DisplayModePropertiesKHR { - pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> { - DisplayModePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayModePropertiesKHRBuilder<'a> { - inner: DisplayModePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> { - type Target = DisplayModePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayModePropertiesKHRBuilder<'a> { + #[inline] pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self { - self.inner.display_mode = display_mode; + self.display_mode = display_mode; self } + #[inline] pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self { - self.inner.parameters = parameters; + self.parameters = parameters; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayModePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayModeCreateInfoKHR { +pub struct DisplayModeCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DisplayModeCreateFlagsKHR, pub parameters: DisplayModeParametersKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayModeCreateInfoKHR { +impl ::std::default::Default for DisplayModeCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR, p_next: ::std::ptr::null(), flags: DisplayModeCreateFlagsKHR::default(), parameters: DisplayModeParametersKHR::default(), + _marker: PhantomData, } } } -impl DisplayModeCreateInfoKHR { - pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> { - DisplayModeCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayModeCreateInfoKHRBuilder<'a> { - inner: DisplayModeCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { - type Target = DisplayModeCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { +impl<'a> DisplayModeCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self { - self.inner.parameters = parameters; + self.parameters = parameters; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayModeCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -9988,78 +7349,57 @@ pub struct DisplayPlaneCapabilitiesKHR { pub max_dst_extent: Extent2D, } impl DisplayPlaneCapabilitiesKHR { - pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> { - DisplayPlaneCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> { - inner: DisplayPlaneCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> { - type Target = DisplayPlaneCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> { + #[inline] pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self { - self.inner.supported_alpha = supported_alpha; + self.supported_alpha = supported_alpha; self } + #[inline] pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self { - self.inner.min_src_position = min_src_position; + self.min_src_position = min_src_position; self } + #[inline] pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self { - self.inner.max_src_position = max_src_position; + self.max_src_position = max_src_position; self } + #[inline] pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self { - self.inner.min_src_extent = min_src_extent; + self.min_src_extent = min_src_extent; self } + #[inline] pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self { - self.inner.max_src_extent = max_src_extent; + self.max_src_extent = max_src_extent; self } + #[inline] pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self { - self.inner.min_dst_position = min_dst_position; + self.min_dst_position = min_dst_position; self } + #[inline] pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self { - self.inner.max_dst_position = max_dst_position; + self.max_dst_position = max_dst_position; self } + #[inline] pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self { - self.inner.min_dst_extent = min_dst_extent; + self.min_dst_extent = min_dst_extent; self } + #[inline] pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self { - self.inner.max_dst_extent = max_dst_extent; + self.max_dst_extent = max_dst_extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPlaneCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplaySurfaceCreateInfoKHR { +pub struct DisplaySurfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DisplaySurfaceCreateFlagsKHR, @@ -10070,8 +7410,9 @@ pub struct DisplaySurfaceCreateInfoKHR { pub global_alpha: f32, pub alpha_mode: DisplayPlaneAlphaFlagsKHR, pub image_extent: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { +impl ::std::default::Default for DisplaySurfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR, @@ -10084,85 +7425,65 @@ impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { global_alpha: f32::default(), alpha_mode: DisplayPlaneAlphaFlagsKHR::default(), image_extent: Extent2D::default(), + _marker: PhantomData, } } } -impl DisplaySurfaceCreateInfoKHR { - pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> { - DisplaySurfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { - inner: DisplaySurfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { - type Target = DisplaySurfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { +impl<'a> DisplaySurfaceCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self { - self.inner.display_mode = display_mode; + self.display_mode = display_mode; self } + #[inline] pub fn plane_index(mut self, plane_index: u32) -> Self { - self.inner.plane_index = plane_index; + self.plane_index = plane_index; self } + #[inline] pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self { - self.inner.plane_stack_index = plane_stack_index; + self.plane_stack_index = plane_stack_index; self } + #[inline] pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.transform = transform; + self.transform = transform; self } + #[inline] pub fn global_alpha(mut self, global_alpha: f32) -> Self { - self.inner.global_alpha = global_alpha; + self.global_alpha = global_alpha; self } + #[inline] pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self { - self.inner.alpha_mode = alpha_mode; + self.alpha_mode = alpha_mode; self } + #[inline] pub fn image_extent(mut self, image_extent: Extent2D) -> Self { - self.inner.image_extent = image_extent; + self.image_extent = image_extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplaySurfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayPresentInfoKHR { +pub struct DisplayPresentInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_rect: Rect2D, pub dst_rect: Rect2D, pub persistent: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayPresentInfoKHR { +impl ::std::default::Default for DisplayPresentInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_PRESENT_INFO_KHR, @@ -10170,54 +7491,27 @@ impl ::std::default::Default for DisplayPresentInfoKHR { src_rect: Rect2D::default(), dst_rect: Rect2D::default(), persistent: Bool32::default(), + _marker: PhantomData, } } } -impl DisplayPresentInfoKHR { - pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> { - DisplayPresentInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPresentInfoKHRBuilder<'a> { - inner: DisplayPresentInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {} -unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {} -impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> { - type Target = DisplayPresentInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPresentInfoKHRBuilder<'a> { +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR<'_> {} +impl<'a> DisplayPresentInfoKHR<'a> { + #[inline] pub fn src_rect(mut self, src_rect: Rect2D) -> Self { - self.inner.src_rect = src_rect; + self.src_rect = src_rect; self } + #[inline] pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self { - self.inner.dst_rect = dst_rect; + self.dst_rect = dst_rect; self } + #[inline] pub fn persistent(mut self, persistent: bool) -> Self { - self.inner.persistent = persistent.into(); + self.persistent = persistent.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPresentInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -10236,212 +7530,141 @@ pub struct SurfaceCapabilitiesKHR { pub supported_usage_flags: ImageUsageFlags, } impl SurfaceCapabilitiesKHR { - pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> { - SurfaceCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceCapabilitiesKHRBuilder<'a> { - inner: SurfaceCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> { - type Target = SurfaceCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceCapabilitiesKHRBuilder<'a> { + #[inline] pub fn min_image_count(mut self, min_image_count: u32) -> Self { - self.inner.min_image_count = min_image_count; + self.min_image_count = min_image_count; self } + #[inline] pub fn max_image_count(mut self, max_image_count: u32) -> Self { - self.inner.max_image_count = max_image_count; + self.max_image_count = max_image_count; self } + #[inline] pub fn current_extent(mut self, current_extent: Extent2D) -> Self { - self.inner.current_extent = current_extent; + self.current_extent = current_extent; self } + #[inline] pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self { - self.inner.min_image_extent = min_image_extent; + self.min_image_extent = min_image_extent; self } + #[inline] pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self { - self.inner.max_image_extent = max_image_extent; + self.max_image_extent = max_image_extent; self } + #[inline] pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { - self.inner.max_image_array_layers = max_image_array_layers; + self.max_image_array_layers = max_image_array_layers; self } + #[inline] pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { - self.inner.supported_transforms = supported_transforms; + self.supported_transforms = supported_transforms; self } + #[inline] pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.current_transform = current_transform; + self.current_transform = current_transform; self } + #[inline] pub fn supported_composite_alpha( mut self, supported_composite_alpha: CompositeAlphaFlagsKHR, ) -> Self { - self.inner.supported_composite_alpha = supported_composite_alpha; + self.supported_composite_alpha = supported_composite_alpha; self } + #[inline] pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self { - self.inner.supported_usage_flags = supported_usage_flags; + self.supported_usage_flags = supported_usage_flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AndroidSurfaceCreateInfoKHR { +pub struct AndroidSurfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: AndroidSurfaceCreateFlagsKHR, pub window: *mut ANativeWindow, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { +impl ::std::default::Default for AndroidSurfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR, p_next: ::std::ptr::null(), flags: AndroidSurfaceCreateFlagsKHR::default(), window: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl AndroidSurfaceCreateInfoKHR { - pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> { - AndroidSurfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { - inner: AndroidSurfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { - type Target = AndroidSurfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { +impl<'a> AndroidSurfaceCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn window(mut self, window: *mut ANativeWindow) -> Self { - self.inner.window = window; + self.window = window; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AndroidSurfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ViSurfaceCreateInfoNN { +pub struct ViSurfaceCreateInfoNN<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ViSurfaceCreateFlagsNN, pub window: *mut c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ViSurfaceCreateInfoNN { +impl ::std::default::Default for ViSurfaceCreateInfoNN<'_> { fn default() -> Self { Self { s_type: StructureType::VI_SURFACE_CREATE_INFO_NN, p_next: ::std::ptr::null(), flags: ViSurfaceCreateFlagsNN::default(), window: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl ViSurfaceCreateInfoNN { - pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> { - ViSurfaceCreateInfoNNBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ViSurfaceCreateInfoNNBuilder<'a> { - inner: ViSurfaceCreateInfoNN, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { - type Target = ViSurfaceCreateInfoNN; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { +impl<'a> ViSurfaceCreateInfoNN<'a> { + #[inline] pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn window(mut self, window: *mut c_void) -> Self { - self.inner.window = window; + self.window = window; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ViSurfaceCreateInfoNN { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct WaylandSurfaceCreateInfoKHR { +pub struct WaylandSurfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: WaylandSurfaceCreateFlagsKHR, pub display: *mut wl_display, pub surface: *mut wl_surface, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { +impl ::std::default::Default for WaylandSurfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR, @@ -10449,65 +7672,40 @@ impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { flags: WaylandSurfaceCreateFlagsKHR::default(), display: ::std::ptr::null_mut(), surface: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl WaylandSurfaceCreateInfoKHR { - pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> { - WaylandSurfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { - inner: WaylandSurfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { - type Target = WaylandSurfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { +impl<'a> WaylandSurfaceCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn display(mut self, display: *mut wl_display) -> Self { - self.inner.display = display; + self.display = display; self } + #[inline] pub fn surface(mut self, surface: *mut wl_surface) -> Self { - self.inner.surface = surface; + self.surface = surface; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> WaylandSurfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct Win32SurfaceCreateInfoKHR { +pub struct Win32SurfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: Win32SurfaceCreateFlagsKHR, pub hinstance: HINSTANCE, pub hwnd: HWND, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for Win32SurfaceCreateInfoKHR { +impl ::std::default::Default for Win32SurfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR, @@ -10515,65 +7713,40 @@ impl ::std::default::Default for Win32SurfaceCreateInfoKHR { flags: Win32SurfaceCreateFlagsKHR::default(), hinstance: unsafe { ::std::mem::zeroed() }, hwnd: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl Win32SurfaceCreateInfoKHR { - pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> { - Win32SurfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { - inner: Win32SurfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { - type Target = Win32SurfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { +impl<'a> Win32SurfaceCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self { - self.inner.hinstance = hinstance; + self.hinstance = hinstance; self } + #[inline] pub fn hwnd(mut self, hwnd: HWND) -> Self { - self.inner.hwnd = hwnd; + self.hwnd = hwnd; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Win32SurfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct XlibSurfaceCreateInfoKHR { +pub struct XlibSurfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: XlibSurfaceCreateFlagsKHR, pub dpy: *mut Display, pub window: Window, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for XlibSurfaceCreateInfoKHR { +impl ::std::default::Default for XlibSurfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR, @@ -10581,65 +7754,40 @@ impl ::std::default::Default for XlibSurfaceCreateInfoKHR { flags: XlibSurfaceCreateFlagsKHR::default(), dpy: ::std::ptr::null_mut(), window: Window::default(), + _marker: PhantomData, } } } -impl XlibSurfaceCreateInfoKHR { - pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> { - XlibSurfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { - inner: XlibSurfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { - type Target = XlibSurfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { +impl<'a> XlibSurfaceCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn dpy(mut self, dpy: *mut Display) -> Self { - self.inner.dpy = dpy; + self.dpy = dpy; self } + #[inline] pub fn window(mut self, window: Window) -> Self { - self.inner.window = window; + self.window = window; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> XlibSurfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct XcbSurfaceCreateInfoKHR { +pub struct XcbSurfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: XcbSurfaceCreateFlagsKHR, pub connection: *mut xcb_connection_t, pub window: xcb_window_t, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for XcbSurfaceCreateInfoKHR { +impl ::std::default::Default for XcbSurfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR, @@ -10647,65 +7795,40 @@ impl ::std::default::Default for XcbSurfaceCreateInfoKHR { flags: XcbSurfaceCreateFlagsKHR::default(), connection: ::std::ptr::null_mut(), window: xcb_window_t::default(), + _marker: PhantomData, } } } -impl XcbSurfaceCreateInfoKHR { - pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> { - XcbSurfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { - inner: XcbSurfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { - type Target = XcbSurfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { +impl<'a> XcbSurfaceCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self { - self.inner.connection = connection; + self.connection = connection; self } + #[inline] pub fn window(mut self, window: xcb_window_t) -> Self { - self.inner.window = window; + self.window = window; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> XcbSurfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DirectFBSurfaceCreateInfoEXT { +pub struct DirectFBSurfaceCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DirectFBSurfaceCreateFlagsEXT, pub dfb: *mut IDirectFB, pub surface: *mut IDirectFBSurface, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT { +impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT, @@ -10713,185 +7836,108 @@ impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT { flags: DirectFBSurfaceCreateFlagsEXT::default(), dfb: ::std::ptr::null_mut(), surface: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl DirectFBSurfaceCreateInfoEXT { - pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { - DirectFBSurfaceCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> { - inner: DirectFBSurfaceCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> { - type Target = DirectFBSurfaceCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> { +impl<'a> DirectFBSurfaceCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self { - self.inner.dfb = dfb; + self.dfb = dfb; self } + #[inline] pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self { - self.inner.surface = surface; + self.surface = surface; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DirectFBSurfaceCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImagePipeSurfaceCreateInfoFUCHSIA { +pub struct ImagePipeSurfaceCreateInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA, pub image_pipe_handle: zx_handle_t, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA { +impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, p_next: ::std::ptr::null(), flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(), image_pipe_handle: zx_handle_t::default(), + _marker: PhantomData, } } } -impl ImagePipeSurfaceCreateInfoFUCHSIA { - pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { - ImagePipeSurfaceCreateInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { - inner: ImagePipeSurfaceCreateInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { - type Target = ImagePipeSurfaceCreateInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { +impl<'a> ImagePipeSurfaceCreateInfoFUCHSIA<'a> { + #[inline] pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self { - self.inner.image_pipe_handle = image_pipe_handle; + self.image_pipe_handle = image_pipe_handle; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct StreamDescriptorSurfaceCreateInfoGGP { +pub struct StreamDescriptorSurfaceCreateInfoGGP<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: StreamDescriptorSurfaceCreateFlagsGGP, pub stream_descriptor: GgpStreamDescriptor, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP { +impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP<'_> { fn default() -> Self { Self { s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP, p_next: ::std::ptr::null(), flags: StreamDescriptorSurfaceCreateFlagsGGP::default(), stream_descriptor: GgpStreamDescriptor::default(), + _marker: PhantomData, } } } -impl StreamDescriptorSurfaceCreateInfoGGP { - pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { - StreamDescriptorSurfaceCreateInfoGGPBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { - inner: StreamDescriptorSurfaceCreateInfoGGP, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { - type Target = StreamDescriptorSurfaceCreateInfoGGP; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { +impl<'a> StreamDescriptorSurfaceCreateInfoGGP<'a> { + #[inline] pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self { - self.inner.stream_descriptor = stream_descriptor; + self.stream_descriptor = stream_descriptor; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ScreenSurfaceCreateInfoQNX { +pub struct ScreenSurfaceCreateInfoQNX<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ScreenSurfaceCreateFlagsQNX, pub context: *mut _screen_context, pub window: *mut _screen_window, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ScreenSurfaceCreateInfoQNX { +impl ::std::default::Default for ScreenSurfaceCreateInfoQNX<'_> { fn default() -> Self { Self { s_type: StructureType::SCREEN_SURFACE_CREATE_INFO_QNX, @@ -10899,52 +7945,26 @@ impl ::std::default::Default for ScreenSurfaceCreateInfoQNX { flags: ScreenSurfaceCreateFlagsQNX::default(), context: ::std::ptr::null_mut(), window: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl ScreenSurfaceCreateInfoQNX { - pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> { - ScreenSurfaceCreateInfoQNXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> { - inner: ScreenSurfaceCreateInfoQNX, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> { - type Target = ScreenSurfaceCreateInfoQNX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> { +impl<'a> ScreenSurfaceCreateInfoQNX<'a> { + #[inline] pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn context(mut self, context: &'a mut _screen_context) -> Self { - self.inner.context = context; + self.context = context; self } + #[inline] pub fn window(mut self, window: &'a mut _screen_window) -> Self { - self.inner.window = window; + self.window = window; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ScreenSurfaceCreateInfoQNX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -10955,50 +7975,22 @@ pub struct SurfaceFormatKHR { pub color_space: ColorSpaceKHR, } impl SurfaceFormatKHR { - pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> { - SurfaceFormatKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceFormatKHRBuilder<'a> { - inner: SurfaceFormatKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> { - type Target = SurfaceFormatKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceFormatKHRBuilder<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self { - self.inner.color_space = color_space; + self.color_space = color_space; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceFormatKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SwapchainCreateInfoKHR { +pub struct SwapchainCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SwapchainCreateFlagsKHR, @@ -11017,8 +8009,9 @@ pub struct SwapchainCreateInfoKHR { pub present_mode: PresentModeKHR, pub clipped: Bool32, pub old_swapchain: SwapchainKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SwapchainCreateInfoKHR { +impl ::std::default::Default for SwapchainCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR, @@ -11039,122 +8032,108 @@ impl ::std::default::Default for SwapchainCreateInfoKHR { present_mode: PresentModeKHR::default(), clipped: Bool32::default(), old_swapchain: SwapchainKHR::default(), + _marker: PhantomData, } } } -impl SwapchainCreateInfoKHR { - pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> { - SwapchainCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SwapchainCreateInfoKHRBuilder<'a> { - inner: SwapchainCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSwapchainCreateInfoKHR {} -impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> { - type Target = SwapchainCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SwapchainCreateInfoKHRBuilder<'a> { +impl<'a> SwapchainCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn surface(mut self, surface: SurfaceKHR) -> Self { - self.inner.surface = surface; + self.surface = surface; self } + #[inline] pub fn min_image_count(mut self, min_image_count: u32) -> Self { - self.inner.min_image_count = min_image_count; + self.min_image_count = min_image_count; self } + #[inline] pub fn image_format(mut self, image_format: Format) -> Self { - self.inner.image_format = image_format; + self.image_format = image_format; self } + #[inline] pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self { - self.inner.image_color_space = image_color_space; + self.image_color_space = image_color_space; self } + #[inline] pub fn image_extent(mut self, image_extent: Extent2D) -> Self { - self.inner.image_extent = image_extent; + self.image_extent = image_extent; self } + #[inline] pub fn image_array_layers(mut self, image_array_layers: u32) -> Self { - self.inner.image_array_layers = image_array_layers; + self.image_array_layers = image_array_layers; self } + #[inline] pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self { - self.inner.image_usage = image_usage; + self.image_usage = image_usage; self } + #[inline] pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self { - self.inner.image_sharing_mode = image_sharing_mode; + self.image_sharing_mode = image_sharing_mode; self } + #[inline] pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { - self.inner.queue_family_index_count = queue_family_indices.len() as _; - self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self.queue_family_index_count = queue_family_indices.len() as _; + self.p_queue_family_indices = queue_family_indices.as_ptr(); self } + #[inline] pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.pre_transform = pre_transform; + self.pre_transform = pre_transform; self } + #[inline] pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self { - self.inner.composite_alpha = composite_alpha; + self.composite_alpha = composite_alpha; self } + #[inline] pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self { - self.inner.present_mode = present_mode; + self.present_mode = present_mode; self } + #[inline] pub fn clipped(mut self, clipped: bool) -> Self { - self.inner.clipped = clipped.into(); + self.clipped = clipped.into(); self } + #[inline] pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self { - self.inner.old_swapchain = old_swapchain; + self.old_swapchain = old_swapchain; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SwapchainCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PresentInfoKHR { +pub struct PresentInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub wait_semaphore_count: u32, @@ -11163,8 +8142,9 @@ pub struct PresentInfoKHR { pub p_swapchains: *const SwapchainKHR, pub p_image_indices: *const u32, pub p_results: *mut Result, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PresentInfoKHR { +impl ::std::default::Default for PresentInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PRESENT_INFO_KHR, @@ -11175,88 +8155,64 @@ impl ::std::default::Default for PresentInfoKHR { p_swapchains: ::std::ptr::null(), p_image_indices: ::std::ptr::null(), p_results: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl PresentInfoKHR { - pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> { - PresentInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentInfoKHRBuilder<'a> { - inner: PresentInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPresentInfoKHR {} -impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { - type Target = PresentInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentInfoKHRBuilder<'a> { +impl<'a> PresentInfoKHR<'a> { + #[inline] pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { - self.inner.wait_semaphore_count = wait_semaphores.len() as _; - self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self.wait_semaphore_count = wait_semaphores.len() as _; + self.p_wait_semaphores = wait_semaphores.as_ptr(); self } + #[inline] pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self { - self.inner.swapchain_count = swapchains.len() as _; - self.inner.p_swapchains = swapchains.as_ptr(); + self.swapchain_count = swapchains.len() as _; + self.p_swapchains = swapchains.as_ptr(); self } + #[inline] pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self { - self.inner.swapchain_count = image_indices.len() as _; - self.inner.p_image_indices = image_indices.as_ptr(); + self.swapchain_count = image_indices.len() as _; + self.p_image_indices = image_indices.as_ptr(); self } + #[inline] pub fn results(mut self, results: &'a mut [Result]) -> Self { - self.inner.swapchain_count = results.len() as _; - self.inner.p_results = results.as_mut_ptr(); + self.swapchain_count = results.len() as _; + self.p_results = results.as_mut_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentInfoKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugReportCallbackCreateInfoEXT { +pub struct DebugReportCallbackCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DebugReportFlagsEXT, pub pfn_callback: PFN_vkDebugReportCallbackEXT, pub p_user_data: *mut c_void, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for DebugReportCallbackCreateInfoEXT { +impl fmt::Debug for DebugReportCallbackCreateInfoEXT<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DebugReportCallbackCreateInfoEXT") .field("s_type", &self.s_type) @@ -11267,7 +8223,7 @@ impl fmt::Debug for DebugReportCallbackCreateInfoEXT { .finish() } } -impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { +impl ::std::default::Default for DebugReportCallbackCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, @@ -11275,130 +8231,76 @@ impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { flags: DebugReportFlagsEXT::default(), pfn_callback: PFN_vkDebugReportCallbackEXT::default(), p_user_data: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl DebugReportCallbackCreateInfoEXT { - pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> { - DebugReportCallbackCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> { - inner: DebugReportCallbackCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {} -impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> { - type Target = DebugReportCallbackCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT<'_> {} +impl<'a> DebugReportCallbackCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self { - self.inner.pfn_callback = pfn_callback; + self.pfn_callback = pfn_callback; self } + #[inline] pub fn user_data(mut self, user_data: *mut c_void) -> Self { - self.inner.p_user_data = user_data; + self.p_user_data = user_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugReportCallbackCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ValidationFlagsEXT { +pub struct ValidationFlagsEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub disabled_validation_check_count: u32, pub p_disabled_validation_checks: *const ValidationCheckEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ValidationFlagsEXT { +impl ::std::default::Default for ValidationFlagsEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VALIDATION_FLAGS_EXT, p_next: ::std::ptr::null(), disabled_validation_check_count: u32::default(), p_disabled_validation_checks: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ValidationFlagsEXT { - pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> { - ValidationFlagsEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ValidationFlagsEXTBuilder<'a> { - inner: ValidationFlagsEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {} -unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {} -impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { - type Target = ValidationFlagsEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ValidationFlagsEXTBuilder<'a> { +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT<'_> {} +impl<'a> ValidationFlagsEXT<'a> { + #[inline] pub fn disabled_validation_checks( mut self, disabled_validation_checks: &'a [ValidationCheckEXT], ) -> Self { - self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _; - self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr(); + self.disabled_validation_check_count = disabled_validation_checks.len() as _; + self.p_disabled_validation_checks = disabled_validation_checks.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ValidationFlagsEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ValidationFeaturesEXT { +pub struct ValidationFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub enabled_validation_feature_count: u32, pub p_enabled_validation_features: *const ValidationFeatureEnableEXT, pub disabled_validation_feature_count: u32, pub p_disabled_validation_features: *const ValidationFeatureDisableEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ValidationFeaturesEXT { +impl ::std::default::Default for ValidationFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VALIDATION_FEATURES_EXT, @@ -11407,133 +8309,75 @@ impl ::std::default::Default for ValidationFeaturesEXT { p_enabled_validation_features: ::std::ptr::null(), disabled_validation_feature_count: u32::default(), p_disabled_validation_features: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ValidationFeaturesEXT { - pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> { - ValidationFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ValidationFeaturesEXTBuilder<'a> { - inner: ValidationFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {} -impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> { - type Target = ValidationFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ValidationFeaturesEXTBuilder<'a> { +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT<'_> {} +impl<'a> ValidationFeaturesEXT<'a> { + #[inline] pub fn enabled_validation_features( mut self, enabled_validation_features: &'a [ValidationFeatureEnableEXT], ) -> Self { - self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _; - self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr(); + self.enabled_validation_feature_count = enabled_validation_features.len() as _; + self.p_enabled_validation_features = enabled_validation_features.as_ptr(); self } + #[inline] pub fn disabled_validation_features( mut self, disabled_validation_features: &'a [ValidationFeatureDisableEXT], ) -> Self { - self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _; - self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr(); + self.disabled_validation_feature_count = disabled_validation_features.len() as _; + self.p_disabled_validation_features = disabled_validation_features.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ValidationFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationStateRasterizationOrderAMD { +pub struct PipelineRasterizationStateRasterizationOrderAMD<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub rasterization_order: RasterizationOrderAMD, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD { +impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, p_next: ::std::ptr::null(), rasterization_order: RasterizationOrderAMD::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationStateRasterizationOrderAMD { - pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { - PipelineRasterizationStateRasterizationOrderAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { - inner: PipelineRasterizationStateRasterizationOrderAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_> + for PipelineRasterizationStateRasterizationOrderAMD<'_> { } -unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationStateRasterizationOrderAMD -{ -} -impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { - type Target = PipelineRasterizationStateRasterizationOrderAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { +impl<'a> PipelineRasterizationStateRasterizationOrderAMD<'a> { + #[inline] pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self { - self.inner.rasterization_order = rasterization_order; + self.rasterization_order = rasterization_order; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugMarkerObjectNameInfoEXT { +pub struct DebugMarkerObjectNameInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: DebugReportObjectTypeEXT, pub object: u64, pub p_object_name: *const c_char, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { +impl ::std::default::Default for DebugMarkerObjectNameInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT, @@ -11541,58 +8385,32 @@ impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { object_type: DebugReportObjectTypeEXT::default(), object: u64::default(), p_object_name: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DebugMarkerObjectNameInfoEXT { - pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> { - DebugMarkerObjectNameInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { - inner: DebugMarkerObjectNameInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { - type Target = DebugMarkerObjectNameInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { +impl<'a> DebugMarkerObjectNameInfoEXT<'a> { + #[inline] pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self { - self.inner.object_type = object_type; + self.object_type = object_type; self } + #[inline] pub fn object(mut self, object: u64) -> Self { - self.inner.object = object; + self.object = object; self } + #[inline] pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_object_name = object_name.as_ptr(); + self.p_object_name = object_name.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugMarkerObjectNameInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugMarkerObjectTagInfoEXT { +pub struct DebugMarkerObjectTagInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: DebugReportObjectTypeEXT, @@ -11600,8 +8418,9 @@ pub struct DebugMarkerObjectTagInfoEXT { pub tag_name: u64, pub tag_size: usize, pub p_tag: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { +impl ::std::default::Default for DebugMarkerObjectTagInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT, @@ -11611,291 +8430,157 @@ impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { tag_name: u64::default(), tag_size: usize::default(), p_tag: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DebugMarkerObjectTagInfoEXT { - pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> { - DebugMarkerObjectTagInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { - inner: DebugMarkerObjectTagInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { - type Target = DebugMarkerObjectTagInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { +impl<'a> DebugMarkerObjectTagInfoEXT<'a> { + #[inline] pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self { - self.inner.object_type = object_type; + self.object_type = object_type; self } + #[inline] pub fn object(mut self, object: u64) -> Self { - self.inner.object = object; + self.object = object; self } + #[inline] pub fn tag_name(mut self, tag_name: u64) -> Self { - self.inner.tag_name = tag_name; + self.tag_name = tag_name; self } + #[inline] pub fn tag(mut self, tag: &'a [u8]) -> Self { - self.inner.tag_size = tag.len(); - self.inner.p_tag = tag.as_ptr() as *const c_void; + self.tag_size = tag.len(); + self.p_tag = tag.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugMarkerObjectTagInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugMarkerMarkerInfoEXT { +pub struct DebugMarkerMarkerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_marker_name: *const c_char, pub color: [f32; 4], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugMarkerMarkerInfoEXT { +impl ::std::default::Default for DebugMarkerMarkerInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT, p_next: ::std::ptr::null(), p_marker_name: ::std::ptr::null(), color: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl DebugMarkerMarkerInfoEXT { - pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> { - DebugMarkerMarkerInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { - inner: DebugMarkerMarkerInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { - type Target = DebugMarkerMarkerInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { +impl<'a> DebugMarkerMarkerInfoEXT<'a> { + #[inline] pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_marker_name = marker_name.as_ptr(); + self.p_marker_name = marker_name.as_ptr(); self } + #[inline] pub fn color(mut self, color: [f32; 4]) -> Self { - self.inner.color = color; + self.color = color; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugMarkerMarkerInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DedicatedAllocationImageCreateInfoNV { +pub struct DedicatedAllocationImageCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub dedicated_allocation: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV { +impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, p_next: ::std::ptr::null(), dedicated_allocation: Bool32::default(), + _marker: PhantomData, } } } -impl DedicatedAllocationImageCreateInfoNV { - pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> { - DedicatedAllocationImageCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> { - inner: DedicatedAllocationImageCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {} -impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> { - type Target = DedicatedAllocationImageCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV<'_> {} +impl<'a> DedicatedAllocationImageCreateInfoNV<'a> { + #[inline] pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { - self.inner.dedicated_allocation = dedicated_allocation.into(); + self.dedicated_allocation = dedicated_allocation.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DedicatedAllocationImageCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DedicatedAllocationBufferCreateInfoNV { +pub struct DedicatedAllocationBufferCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub dedicated_allocation: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV { +impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, p_next: ::std::ptr::null(), dedicated_allocation: Bool32::default(), + _marker: PhantomData, } } } -impl DedicatedAllocationBufferCreateInfoNV { - pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { - DedicatedAllocationBufferCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> { - inner: DedicatedAllocationBufferCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {} -impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { - type Target = DedicatedAllocationBufferCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV<'_> {} +impl<'a> DedicatedAllocationBufferCreateInfoNV<'a> { + #[inline] pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { - self.inner.dedicated_allocation = dedicated_allocation.into(); + self.dedicated_allocation = dedicated_allocation.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DedicatedAllocationMemoryAllocateInfoNV { +pub struct DedicatedAllocationMemoryAllocateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV { +impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, p_next: ::std::ptr::null(), image: Image::default(), buffer: Buffer::default(), + _marker: PhantomData, } } } -impl DedicatedAllocationMemoryAllocateInfoNV { - pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { - DedicatedAllocationMemoryAllocateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { - inner: DedicatedAllocationMemoryAllocateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {} -impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { - type Target = DedicatedAllocationMemoryAllocateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV<'_> {} +impl<'a> DedicatedAllocationMemoryAllocateInfoNV<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -11908,306 +8593,170 @@ pub struct ExternalImageFormatPropertiesNV { pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, } impl ExternalImageFormatPropertiesNV { - pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> { - ExternalImageFormatPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalImageFormatPropertiesNVBuilder<'a> { - inner: ExternalImageFormatPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> { - type Target = ExternalImageFormatPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> { + #[inline] pub fn image_format_properties( mut self, image_format_properties: ImageFormatProperties, ) -> Self { - self.inner.image_format_properties = image_format_properties; + self.image_format_properties = image_format_properties; self } + #[inline] pub fn external_memory_features( mut self, external_memory_features: ExternalMemoryFeatureFlagsNV, ) -> Self { - self.inner.external_memory_features = external_memory_features; + self.external_memory_features = external_memory_features; self } + #[inline] pub fn export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> Self { - self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self.export_from_imported_handle_types = export_from_imported_handle_types; self } + #[inline] pub fn compatible_handle_types( mut self, compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, ) -> Self { - self.inner.compatible_handle_types = compatible_handle_types; + self.compatible_handle_types = compatible_handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalImageFormatPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalMemoryImageCreateInfoNV { +pub struct ExternalMemoryImageCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlagsNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalMemoryImageCreateInfoNV { +impl ::std::default::Default for ExternalMemoryImageCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + _marker: PhantomData, } } } -impl ExternalMemoryImageCreateInfoNV { - pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> { - ExternalMemoryImageCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> { - inner: ExternalMemoryImageCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {} -impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> { - type Target = ExternalMemoryImageCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV<'_> {} +impl<'a> ExternalMemoryImageCreateInfoNV<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalMemoryImageCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportMemoryAllocateInfoNV { +pub struct ExportMemoryAllocateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlagsNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMemoryAllocateInfoNV { +impl ::std::default::Default for ExportMemoryAllocateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV, p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + _marker: PhantomData, } } } -impl ExportMemoryAllocateInfoNV { - pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> { - ExportMemoryAllocateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportMemoryAllocateInfoNVBuilder<'a> { - inner: ExportMemoryAllocateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {} -impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> { - type Target = ExportMemoryAllocateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV<'_> {} +impl<'a> ExportMemoryAllocateInfoNV<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportMemoryAllocateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportMemoryWin32HandleInfoNV { +pub struct ImportMemoryWin32HandleInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlagsNV, pub handle: HANDLE, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryWin32HandleInfoNV { +impl ::std::default::Default for ImportMemoryWin32HandleInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlagsNV::default(), handle: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ImportMemoryWin32HandleInfoNV { - pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> { - ImportMemoryWin32HandleInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> { - inner: ImportMemoryWin32HandleInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {} -impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> { - type Target = ImportMemoryWin32HandleInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV<'_> {} +impl<'a> ImportMemoryWin32HandleInfoNV<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn handle(mut self, handle: HANDLE) -> Self { - self.inner.handle = handle; + self.handle = handle; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportMemoryWin32HandleInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportMemoryWin32HandleInfoNV { +pub struct ExportMemoryWin32HandleInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_attributes: *const SECURITY_ATTRIBUTES, pub dw_access: DWORD, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { +impl ::std::default::Default for ExportMemoryWin32HandleInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, p_next: ::std::ptr::null(), p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), + _marker: PhantomData, } } } -impl ExportMemoryWin32HandleInfoNV { - pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> { - ExportMemoryWin32HandleInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> { - inner: ExportMemoryWin32HandleInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {} -impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { - type Target = ExportMemoryWin32HandleInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV<'_> {} +impl<'a> ExportMemoryWin32HandleInfoNV<'a> { + #[inline] pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { - self.inner.p_attributes = attributes; + self.p_attributes = attributes; self } + #[inline] pub fn dw_access(mut self, dw_access: DWORD) -> Self { - self.inner.dw_access = dw_access; + self.dw_access = dw_access; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportMemoryWin32HandleInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct Win32KeyedMutexAcquireReleaseInfoNV { +pub struct Win32KeyedMutexAcquireReleaseInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acquire_count: u32, @@ -12217,8 +8766,9 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNV { pub release_count: u32, pub p_release_syncs: *const DeviceMemory, pub p_release_keys: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, @@ -12230,304 +8780,162 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { release_count: u32::default(), p_release_syncs: ::std::ptr::null(), p_release_keys: ::std::ptr::null(), + _marker: PhantomData, } } } -impl Win32KeyedMutexAcquireReleaseInfoNV { - pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - Win32KeyedMutexAcquireReleaseInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - inner: Win32KeyedMutexAcquireReleaseInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {} -unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} -unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {} -impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - type Target = Win32KeyedMutexAcquireReleaseInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV<'_> {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV<'_> {} +impl<'a> Win32KeyedMutexAcquireReleaseInfoNV<'a> { + #[inline] pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self { - self.inner.acquire_count = acquire_syncs.len() as _; - self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self.acquire_count = acquire_syncs.len() as _; + self.p_acquire_syncs = acquire_syncs.as_ptr(); self } + #[inline] pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self { - self.inner.acquire_count = acquire_keys.len() as _; - self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self.acquire_count = acquire_keys.len() as _; + self.p_acquire_keys = acquire_keys.as_ptr(); self } + #[inline] pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self { - self.inner.acquire_count = acquire_timeout_milliseconds.len() as _; - self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr(); + self.acquire_count = acquire_timeout_milliseconds.len() as _; + self.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr(); self } + #[inline] pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self { - self.inner.release_count = release_syncs.len() as _; - self.inner.p_release_syncs = release_syncs.as_ptr(); + self.release_count = release_syncs.len() as _; + self.p_release_syncs = release_syncs.as_ptr(); self } + #[inline] pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self { - self.inner.release_count = release_keys.len() as _; - self.inner.p_release_keys = release_keys.as_ptr(); + self.release_count = release_keys.len() as _; + self.p_release_keys = release_keys.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { +pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub device_generated_commands: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, p_next: ::std::ptr::null_mut(), device_generated_commands: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { - PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { - inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'_> {} +impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> { + #[inline] pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self { - self.inner.device_generated_commands = device_generated_commands.into(); + self.device_generated_commands = device_generated_commands.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DevicePrivateDataCreateInfo { +pub struct DevicePrivateDataCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub private_data_slot_request_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DevicePrivateDataCreateInfo { +impl ::std::default::Default for DevicePrivateDataCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO, p_next: ::std::ptr::null(), private_data_slot_request_count: u32::default(), + _marker: PhantomData, } } } -impl DevicePrivateDataCreateInfo { - pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> { - DevicePrivateDataCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DevicePrivateDataCreateInfoBuilder<'a> { - inner: DevicePrivateDataCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {} -impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> { - type Target = DevicePrivateDataCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DevicePrivateDataCreateInfoBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo<'_> {} +impl<'a> DevicePrivateDataCreateInfo<'a> { + #[inline] pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self { - self.inner.private_data_slot_request_count = private_data_slot_request_count; + self.private_data_slot_request_count = private_data_slot_request_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DevicePrivateDataCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PrivateDataSlotCreateInfo { +pub struct PrivateDataSlotCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PrivateDataSlotCreateFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PrivateDataSlotCreateInfo { +impl ::std::default::Default for PrivateDataSlotCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO, p_next: ::std::ptr::null(), flags: PrivateDataSlotCreateFlags::default(), + _marker: PhantomData, } } } -impl PrivateDataSlotCreateInfo { - pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> { - PrivateDataSlotCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PrivateDataSlotCreateInfoBuilder<'a> { - inner: PrivateDataSlotCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> { - type Target = PrivateDataSlotCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PrivateDataSlotCreateInfoBuilder<'a> { +impl<'a> PrivateDataSlotCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PrivateDataSlotCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePrivateDataFeatures { +pub struct PhysicalDevicePrivateDataFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub private_data: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePrivateDataFeatures { +impl ::std::default::Default for PhysicalDevicePrivateDataFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, p_next: ::std::ptr::null_mut(), private_data: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePrivateDataFeatures { - pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> { - PhysicalDevicePrivateDataFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> { - inner: PhysicalDevicePrivateDataFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> { - type Target = PhysicalDevicePrivateDataFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures<'_> {} +impl<'a> PhysicalDevicePrivateDataFeatures<'a> { + #[inline] pub fn private_data(mut self, private_data: bool) -> Self { - self.inner.private_data = private_data.into(); + self.private_data = private_data.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePrivateDataFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { +pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_graphics_shader_group_count: u32, @@ -12539,8 +8947,9 @@ pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { pub min_sequences_count_buffer_offset_alignment: u32, pub min_sequences_index_buffer_offset_alignment: u32, pub min_indirect_commands_buffer_offset_alignment: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, @@ -12554,175 +8963,127 @@ impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsProperties min_sequences_count_buffer_offset_alignment: u32::default(), min_sequences_index_buffer_offset_alignment: u32::default(), min_indirect_commands_buffer_offset_alignment: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { - PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { - inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_> + for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { - type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { +impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> { + #[inline] pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self { - self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count; + self.max_graphics_shader_group_count = max_graphics_shader_group_count; self } + #[inline] pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self { - self.inner.max_indirect_sequence_count = max_indirect_sequence_count; + self.max_indirect_sequence_count = max_indirect_sequence_count; self } + #[inline] pub fn max_indirect_commands_token_count( mut self, max_indirect_commands_token_count: u32, ) -> Self { - self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count; + self.max_indirect_commands_token_count = max_indirect_commands_token_count; self } + #[inline] pub fn max_indirect_commands_stream_count( mut self, max_indirect_commands_stream_count: u32, ) -> Self { - self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count; + self.max_indirect_commands_stream_count = max_indirect_commands_stream_count; self } + #[inline] pub fn max_indirect_commands_token_offset( mut self, max_indirect_commands_token_offset: u32, ) -> Self { - self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset; + self.max_indirect_commands_token_offset = max_indirect_commands_token_offset; self } + #[inline] pub fn max_indirect_commands_stream_stride( mut self, max_indirect_commands_stream_stride: u32, ) -> Self { - self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride; + self.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride; self } + #[inline] pub fn min_sequences_count_buffer_offset_alignment( mut self, min_sequences_count_buffer_offset_alignment: u32, ) -> Self { - self.inner.min_sequences_count_buffer_offset_alignment = + self.min_sequences_count_buffer_offset_alignment = min_sequences_count_buffer_offset_alignment; self } + #[inline] pub fn min_sequences_index_buffer_offset_alignment( mut self, min_sequences_index_buffer_offset_alignment: u32, ) -> Self { - self.inner.min_sequences_index_buffer_offset_alignment = + self.min_sequences_index_buffer_offset_alignment = min_sequences_index_buffer_offset_alignment; self } + #[inline] pub fn min_indirect_commands_buffer_offset_alignment( mut self, min_indirect_commands_buffer_offset_alignment: u32, ) -> Self { - self.inner.min_indirect_commands_buffer_offset_alignment = + self.min_indirect_commands_buffer_offset_alignment = min_indirect_commands_buffer_offset_alignment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMultiDrawPropertiesEXT { +pub struct PhysicalDeviceMultiDrawPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_multi_draw_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), max_multi_draw_count: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMultiDrawPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { - PhysicalDeviceMultiDrawPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceMultiDrawPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceMultiDrawPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceMultiDrawPropertiesEXT<'a> { + #[inline] pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self { - self.inner.max_multi_draw_count = max_multi_draw_count; + self.max_multi_draw_count = max_multi_draw_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMultiDrawPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GraphicsShaderGroupCreateInfoNV { +pub struct GraphicsShaderGroupCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub stage_count: u32, - pub p_stages: *const PipelineShaderStageCreateInfo, - pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, - pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, + pub p_stages: *const PipelineShaderStageCreateInfo<'a>, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo<'a>, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV { +impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV, @@ -12731,73 +9092,48 @@ impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV { p_stages: ::std::ptr::null(), p_vertex_input_state: ::std::ptr::null(), p_tessellation_state: ::std::ptr::null(), + _marker: PhantomData, } } } -impl GraphicsShaderGroupCreateInfoNV { - pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> { - GraphicsShaderGroupCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> { - inner: GraphicsShaderGroupCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> { - type Target = GraphicsShaderGroupCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> { +impl<'a> GraphicsShaderGroupCreateInfoNV<'a> { + #[inline] pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { - self.inner.stage_count = stages.len() as _; - self.inner.p_stages = stages.as_ptr(); + self.stage_count = stages.len() as _; + self.p_stages = stages.as_ptr(); self } + #[inline] pub fn vertex_input_state( mut self, - vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo<'a>, ) -> Self { - self.inner.p_vertex_input_state = vertex_input_state; + self.p_vertex_input_state = vertex_input_state; self } + #[inline] pub fn tessellation_state( mut self, - tessellation_state: &'a PipelineTessellationStateCreateInfo, + tessellation_state: &'a PipelineTessellationStateCreateInfo<'a>, ) -> Self { - self.inner.p_tessellation_state = tessellation_state; + self.p_tessellation_state = tessellation_state; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GraphicsShaderGroupCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GraphicsPipelineShaderGroupsCreateInfoNV { +pub struct GraphicsPipelineShaderGroupsCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub group_count: u32, - pub p_groups: *const GraphicsShaderGroupCreateInfoNV, + pub p_groups: *const GraphicsShaderGroupCreateInfoNV<'a>, pub pipeline_count: u32, pub p_pipelines: *const Pipeline, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV { +impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV, @@ -12806,55 +9142,24 @@ impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV { p_groups: ::std::ptr::null(), pipeline_count: u32::default(), p_pipelines: ::std::ptr::null(), + _marker: PhantomData, } } } -impl GraphicsPipelineShaderGroupsCreateInfoNV { - pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { - GraphicsPipelineShaderGroupsCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { - inner: GraphicsPipelineShaderGroupsCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsGraphicsPipelineCreateInfo - for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_> -{ -} -unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {} -impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { - type Target = GraphicsPipelineShaderGroupsCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV<'_> {} +impl<'a> GraphicsPipelineShaderGroupsCreateInfoNV<'a> { + #[inline] pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self { - self.inner.group_count = groups.len() as _; - self.inner.p_groups = groups.as_ptr(); + self.group_count = groups.len() as _; + self.p_groups = groups.as_ptr(); self } + #[inline] pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self { - self.inner.pipeline_count = pipelines.len() as _; - self.inner.p_pipelines = pipelines.as_ptr(); + self.pipeline_count = pipelines.len() as _; + self.p_pipelines = pipelines.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -12864,40 +9169,11 @@ pub struct BindShaderGroupIndirectCommandNV { pub group_index: u32, } impl BindShaderGroupIndirectCommandNV { - pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> { - BindShaderGroupIndirectCommandNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindShaderGroupIndirectCommandNVBuilder<'a> { - inner: BindShaderGroupIndirectCommandNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> { - type Target = BindShaderGroupIndirectCommandNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> { + #[inline] pub fn group_index(mut self, group_index: u32) -> Self { - self.inner.group_index = group_index; + self.group_index = group_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindShaderGroupIndirectCommandNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -12909,48 +9185,21 @@ pub struct BindIndexBufferIndirectCommandNV { pub index_type: IndexType, } impl BindIndexBufferIndirectCommandNV { - pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> { - BindIndexBufferIndirectCommandNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindIndexBufferIndirectCommandNVBuilder<'a> { - inner: BindIndexBufferIndirectCommandNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> { - type Target = BindIndexBufferIndirectCommandNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> { + #[inline] pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self { - self.inner.buffer_address = buffer_address; + self.buffer_address = buffer_address; self } + #[inline] pub fn size(mut self, size: u32) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn index_type(mut self, index_type: IndexType) -> Self { - self.inner.index_type = index_type; + self.index_type = index_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindIndexBufferIndirectCommandNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -12962,48 +9211,21 @@ pub struct BindVertexBufferIndirectCommandNV { pub stride: u32, } impl BindVertexBufferIndirectCommandNV { - pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> { - BindVertexBufferIndirectCommandNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindVertexBufferIndirectCommandNVBuilder<'a> { - inner: BindVertexBufferIndirectCommandNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> { - type Target = BindVertexBufferIndirectCommandNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> { + #[inline] pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self { - self.inner.buffer_address = buffer_address; + self.buffer_address = buffer_address; self } + #[inline] pub fn size(mut self, size: u32) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn stride(mut self, stride: u32) -> Self { - self.inner.stride = stride; + self.stride = stride; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindVertexBufferIndirectCommandNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -13013,40 +9235,11 @@ pub struct SetStateFlagsIndirectCommandNV { pub data: u32, } impl SetStateFlagsIndirectCommandNV { - pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> { - SetStateFlagsIndirectCommandNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SetStateFlagsIndirectCommandNVBuilder<'a> { - inner: SetStateFlagsIndirectCommandNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> { - type Target = SetStateFlagsIndirectCommandNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> { + #[inline] pub fn data(mut self, data: u32) -> Self { - self.inner.data = data; + self.data = data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SetStateFlagsIndirectCommandNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -13057,50 +9250,22 @@ pub struct IndirectCommandsStreamNV { pub offset: DeviceSize, } impl IndirectCommandsStreamNV { - pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> { - IndirectCommandsStreamNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct IndirectCommandsStreamNVBuilder<'a> { - inner: IndirectCommandsStreamNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> { - type Target = IndirectCommandsStreamNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> IndirectCommandsStreamNVBuilder<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> IndirectCommandsStreamNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct IndirectCommandsLayoutTokenNV { +pub struct IndirectCommandsLayoutTokenNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub token_type: IndirectCommandsTokenTypeNV, @@ -13116,8 +9281,9 @@ pub struct IndirectCommandsLayoutTokenNV { pub index_type_count: u32, pub p_index_types: *const IndexType, pub p_index_type_values: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for IndirectCommandsLayoutTokenNV { +impl ::std::default::Default for IndirectCommandsLayoutTokenNV<'_> { fn default() -> Self { Self { s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV, @@ -13135,112 +9301,96 @@ impl ::std::default::Default for IndirectCommandsLayoutTokenNV { index_type_count: u32::default(), p_index_types: ::std::ptr::null(), p_index_type_values: ::std::ptr::null(), + _marker: PhantomData, } } } -impl IndirectCommandsLayoutTokenNV { - pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> { - IndirectCommandsLayoutTokenNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct IndirectCommandsLayoutTokenNVBuilder<'a> { - inner: IndirectCommandsLayoutTokenNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> { - type Target = IndirectCommandsLayoutTokenNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> { +impl<'a> IndirectCommandsLayoutTokenNV<'a> { + #[inline] pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self { - self.inner.token_type = token_type; + self.token_type = token_type; self } + #[inline] pub fn stream(mut self, stream: u32) -> Self { - self.inner.stream = stream; + self.stream = stream; self } + #[inline] pub fn offset(mut self, offset: u32) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self { - self.inner.vertex_binding_unit = vertex_binding_unit; + self.vertex_binding_unit = vertex_binding_unit; self } + #[inline] pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self { - self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into(); + self.vertex_dynamic_stride = vertex_dynamic_stride.into(); self } + #[inline] pub fn pushconstant_pipeline_layout( mut self, pushconstant_pipeline_layout: PipelineLayout, ) -> Self { - self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout; + self.pushconstant_pipeline_layout = pushconstant_pipeline_layout; self } + #[inline] pub fn pushconstant_shader_stage_flags( mut self, pushconstant_shader_stage_flags: ShaderStageFlags, ) -> Self { - self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags; + self.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags; self } + #[inline] pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self { - self.inner.pushconstant_offset = pushconstant_offset; + self.pushconstant_offset = pushconstant_offset; self } + #[inline] pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self { - self.inner.pushconstant_size = pushconstant_size; + self.pushconstant_size = pushconstant_size; self } + #[inline] pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self { - self.inner.indirect_state_flags = indirect_state_flags; + self.indirect_state_flags = indirect_state_flags; self } + #[inline] pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self { - self.inner.index_type_count = index_types.len() as _; - self.inner.p_index_types = index_types.as_ptr(); + self.index_type_count = index_types.len() as _; + self.p_index_types = index_types.as_ptr(); self } + #[inline] pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self { - self.inner.index_type_count = index_type_values.len() as _; - self.inner.p_index_type_values = index_type_values.as_ptr(); + self.index_type_count = index_type_values.len() as _; + self.p_index_type_values = index_type_values.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> IndirectCommandsLayoutTokenNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct IndirectCommandsLayoutCreateInfoNV { +pub struct IndirectCommandsLayoutCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: IndirectCommandsLayoutUsageFlagsNV, pub pipeline_bind_point: PipelineBindPoint, pub token_count: u32, - pub p_tokens: *const IndirectCommandsLayoutTokenNV, + pub p_tokens: *const IndirectCommandsLayoutTokenNV<'a>, pub stream_count: u32, pub p_stream_strides: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV { +impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV, @@ -13251,64 +9401,39 @@ impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV { p_tokens: ::std::ptr::null(), stream_count: u32::default(), p_stream_strides: ::std::ptr::null(), + _marker: PhantomData, } } } -impl IndirectCommandsLayoutCreateInfoNV { - pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { - IndirectCommandsLayoutCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> { - inner: IndirectCommandsLayoutCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { - type Target = IndirectCommandsLayoutCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { +impl<'a> IndirectCommandsLayoutCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { - self.inner.pipeline_bind_point = pipeline_bind_point; + self.pipeline_bind_point = pipeline_bind_point; self } + #[inline] pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self { - self.inner.token_count = tokens.len() as _; - self.inner.p_tokens = tokens.as_ptr(); + self.token_count = tokens.len() as _; + self.p_tokens = tokens.as_ptr(); self } + #[inline] pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self { - self.inner.stream_count = stream_strides.len() as _; - self.inner.p_stream_strides = stream_strides.as_ptr(); + self.stream_count = stream_strides.len() as _; + self.p_stream_strides = stream_strides.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GeneratedCommandsInfoNV { +pub struct GeneratedCommandsInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub pipeline_bind_point: PipelineBindPoint, @@ -13324,8 +9449,9 @@ pub struct GeneratedCommandsInfoNV { pub sequences_count_offset: DeviceSize, pub sequences_index_buffer: Buffer, pub sequences_index_offset: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GeneratedCommandsInfoNV { +impl ::std::default::Default for GeneratedCommandsInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::GENERATED_COMMANDS_INFO_NV, @@ -13343,106 +9469,90 @@ impl ::std::default::Default for GeneratedCommandsInfoNV { sequences_count_offset: DeviceSize::default(), sequences_index_buffer: Buffer::default(), sequences_index_offset: DeviceSize::default(), + _marker: PhantomData, } } } -impl GeneratedCommandsInfoNV { - pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> { - GeneratedCommandsInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GeneratedCommandsInfoNVBuilder<'a> { - inner: GeneratedCommandsInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> { - type Target = GeneratedCommandsInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GeneratedCommandsInfoNVBuilder<'a> { +impl<'a> GeneratedCommandsInfoNV<'a> { + #[inline] pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { - self.inner.pipeline_bind_point = pipeline_bind_point; + self.pipeline_bind_point = pipeline_bind_point; self } + #[inline] pub fn pipeline(mut self, pipeline: Pipeline) -> Self { - self.inner.pipeline = pipeline; + self.pipeline = pipeline; self } + #[inline] pub fn indirect_commands_layout( mut self, indirect_commands_layout: IndirectCommandsLayoutNV, ) -> Self { - self.inner.indirect_commands_layout = indirect_commands_layout; + self.indirect_commands_layout = indirect_commands_layout; self } + #[inline] pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self { - self.inner.stream_count = streams.len() as _; - self.inner.p_streams = streams.as_ptr(); + self.stream_count = streams.len() as _; + self.p_streams = streams.as_ptr(); self } + #[inline] pub fn sequences_count(mut self, sequences_count: u32) -> Self { - self.inner.sequences_count = sequences_count; + self.sequences_count = sequences_count; self } + #[inline] pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self { - self.inner.preprocess_buffer = preprocess_buffer; + self.preprocess_buffer = preprocess_buffer; self } + #[inline] pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self { - self.inner.preprocess_offset = preprocess_offset; + self.preprocess_offset = preprocess_offset; self } + #[inline] pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self { - self.inner.preprocess_size = preprocess_size; + self.preprocess_size = preprocess_size; self } + #[inline] pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self { - self.inner.sequences_count_buffer = sequences_count_buffer; + self.sequences_count_buffer = sequences_count_buffer; self } + #[inline] pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self { - self.inner.sequences_count_offset = sequences_count_offset; + self.sequences_count_offset = sequences_count_offset; self } + #[inline] pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self { - self.inner.sequences_index_buffer = sequences_index_buffer; + self.sequences_index_buffer = sequences_index_buffer; self } + #[inline] pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self { - self.inner.sequences_index_offset = sequences_index_offset; + self.sequences_index_offset = sequences_index_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GeneratedCommandsInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GeneratedCommandsMemoryRequirementsInfoNV { +pub struct GeneratedCommandsMemoryRequirementsInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub pipeline_bind_point: PipelineBindPoint, pub pipeline: Pipeline, pub indirect_commands_layout: IndirectCommandsLayoutNV, pub max_sequences_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV { +impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV, @@ -13451,346 +9561,212 @@ impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV { pipeline: Pipeline::default(), indirect_commands_layout: IndirectCommandsLayoutNV::default(), max_sequences_count: u32::default(), + _marker: PhantomData, } } } -impl GeneratedCommandsMemoryRequirementsInfoNV { - pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { - GeneratedCommandsMemoryRequirementsInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { - inner: GeneratedCommandsMemoryRequirementsInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { - type Target = GeneratedCommandsMemoryRequirementsInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { +impl<'a> GeneratedCommandsMemoryRequirementsInfoNV<'a> { + #[inline] pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { - self.inner.pipeline_bind_point = pipeline_bind_point; + self.pipeline_bind_point = pipeline_bind_point; self } + #[inline] pub fn pipeline(mut self, pipeline: Pipeline) -> Self { - self.inner.pipeline = pipeline; + self.pipeline = pipeline; self } + #[inline] pub fn indirect_commands_layout( mut self, indirect_commands_layout: IndirectCommandsLayoutNV, ) -> Self { - self.inner.indirect_commands_layout = indirect_commands_layout; + self.indirect_commands_layout = indirect_commands_layout; self } + #[inline] pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self { - self.inner.max_sequences_count = max_sequences_count; + self.max_sequences_count = max_sequences_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFeatures2 { +pub struct PhysicalDeviceFeatures2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub features: PhysicalDeviceFeatures, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFeatures2 { +impl ::std::default::Default for PhysicalDeviceFeatures2<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2, p_next: ::std::ptr::null_mut(), features: PhysicalDeviceFeatures::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFeatures2 { - pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> { - PhysicalDeviceFeatures2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFeatures2Builder<'a> { - inner: PhysicalDeviceFeatures2, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2<'_> {} pub unsafe trait ExtendsPhysicalDeviceFeatures2 {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { - type Target = PhysicalDeviceFeatures2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFeatures2Builder<'a> { +impl<'a> PhysicalDeviceFeatures2<'a> { + #[inline] pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self { - self.inner.features = features; + self.features = features; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFeatures2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceProperties2 { +pub struct PhysicalDeviceProperties2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub properties: PhysicalDeviceProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceProperties2 { +impl ::std::default::Default for PhysicalDeviceProperties2<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2, p_next: ::std::ptr::null_mut(), properties: PhysicalDeviceProperties::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceProperties2 { - pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> { - PhysicalDeviceProperties2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceProperties2Builder<'a> { - inner: PhysicalDeviceProperties2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPhysicalDeviceProperties2 {} -impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> { - type Target = PhysicalDeviceProperties2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceProperties2Builder<'a> { +impl<'a> PhysicalDeviceProperties2<'a> { + #[inline] pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self { - self.inner.properties = properties; + self.properties = properties; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceProperties2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FormatProperties2 { +pub struct FormatProperties2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub format_properties: FormatProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FormatProperties2 { +impl ::std::default::Default for FormatProperties2<'_> { fn default() -> Self { Self { s_type: StructureType::FORMAT_PROPERTIES_2, p_next: ::std::ptr::null_mut(), format_properties: FormatProperties::default(), + _marker: PhantomData, } } } -impl FormatProperties2 { - pub fn builder<'a>() -> FormatProperties2Builder<'a> { - FormatProperties2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FormatProperties2Builder<'a> { - inner: FormatProperties2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsFormatProperties2 {} -impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> { - type Target = FormatProperties2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FormatProperties2Builder<'a> { +impl<'a> FormatProperties2<'a> { + #[inline] pub fn format_properties(mut self, format_properties: FormatProperties) -> Self { - self.inner.format_properties = format_properties; + self.format_properties = format_properties; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FormatProperties2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageFormatProperties2 { +pub struct ImageFormatProperties2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub image_format_properties: ImageFormatProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageFormatProperties2 { +impl ::std::default::Default for ImageFormatProperties2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2, p_next: ::std::ptr::null_mut(), image_format_properties: ImageFormatProperties::default(), + _marker: PhantomData, } } } -impl ImageFormatProperties2 { - pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> { - ImageFormatProperties2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageFormatProperties2Builder<'a> { - inner: ImageFormatProperties2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageFormatProperties2 {} -impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> { - type Target = ImageFormatProperties2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageFormatProperties2Builder<'a> { +impl<'a> ImageFormatProperties2<'a> { + #[inline] pub fn image_format_properties( mut self, image_format_properties: ImageFormatProperties, ) -> Self { - self.inner.image_format_properties = image_format_properties; + self.image_format_properties = image_format_properties; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageFormatProperties2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceImageFormatInfo2 { +pub struct PhysicalDeviceImageFormatInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub format: Format, @@ -13798,8 +9774,9 @@ pub struct PhysicalDeviceImageFormatInfo2 { pub tiling: ImageTiling, pub usage: ImageUsageFlags, pub flags: ImageCreateFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { +impl ::std::default::Default for PhysicalDeviceImageFormatInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, @@ -13809,276 +9786,171 @@ impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { tiling: ImageTiling::default(), usage: ImageUsageFlags::default(), flags: ImageCreateFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceImageFormatInfo2 { - pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> { - PhysicalDeviceImageFormatInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceImageFormatInfo2Builder<'a> { - inner: PhysicalDeviceImageFormatInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {} -impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> { - type Target = PhysicalDeviceImageFormatInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { +impl<'a> PhysicalDeviceImageFormatInfo2<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn ty(mut self, ty: ImageType) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn tiling(mut self, tiling: ImageTiling) -> Self { - self.inner.tiling = tiling; + self.tiling = tiling; self } + #[inline] pub fn usage(mut self, usage: ImageUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn flags(mut self, flags: ImageCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceImageFormatInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueueFamilyProperties2 { +pub struct QueueFamilyProperties2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub queue_family_properties: QueueFamilyProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueueFamilyProperties2 { +impl ::std::default::Default for QueueFamilyProperties2<'_> { fn default() -> Self { Self { s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2, p_next: ::std::ptr::null_mut(), queue_family_properties: QueueFamilyProperties::default(), + _marker: PhantomData, } } } -impl QueueFamilyProperties2 { - pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> { - QueueFamilyProperties2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueueFamilyProperties2Builder<'a> { - inner: QueueFamilyProperties2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsQueueFamilyProperties2 {} -impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> { - type Target = QueueFamilyProperties2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueueFamilyProperties2Builder<'a> { +impl<'a> QueueFamilyProperties2<'a> { + #[inline] pub fn queue_family_properties( mut self, queue_family_properties: QueueFamilyProperties, ) -> Self { - self.inner.queue_family_properties = queue_family_properties; + self.queue_family_properties = queue_family_properties; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueueFamilyProperties2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMemoryProperties2 { +pub struct PhysicalDeviceMemoryProperties2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_properties: PhysicalDeviceMemoryProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { +impl ::std::default::Default for PhysicalDeviceMemoryProperties2<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, p_next: ::std::ptr::null_mut(), memory_properties: PhysicalDeviceMemoryProperties::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMemoryProperties2 { - pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> { - PhysicalDeviceMemoryProperties2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMemoryProperties2Builder<'a> { - inner: PhysicalDeviceMemoryProperties2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> { - type Target = PhysicalDeviceMemoryProperties2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { +impl<'a> PhysicalDeviceMemoryProperties2<'a> { + #[inline] pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self { - self.inner.memory_properties = memory_properties; + self.memory_properties = memory_properties; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMemoryProperties2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SparseImageFormatProperties2 { +pub struct SparseImageFormatProperties2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub properties: SparseImageFormatProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SparseImageFormatProperties2 { +impl ::std::default::Default for SparseImageFormatProperties2<'_> { fn default() -> Self { Self { s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2, p_next: ::std::ptr::null_mut(), properties: SparseImageFormatProperties::default(), + _marker: PhantomData, } } } -impl SparseImageFormatProperties2 { - pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> { - SparseImageFormatProperties2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageFormatProperties2Builder<'a> { - inner: SparseImageFormatProperties2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { - type Target = SparseImageFormatProperties2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageFormatProperties2Builder<'a> { +impl<'a> SparseImageFormatProperties2<'a> { + #[inline] pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self { - self.inner.properties = properties; + self.properties = properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageFormatProperties2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSparseImageFormatInfo2 { +pub struct PhysicalDeviceSparseImageFormatInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub format: Format, @@ -14086,8 +9958,9 @@ pub struct PhysicalDeviceSparseImageFormatInfo2 { pub samples: SampleCountFlags, pub usage: ImageUsageFlags, pub tiling: ImageTiling, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { +impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, @@ -14097,119 +9970,64 @@ impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { samples: SampleCountFlags::default(), usage: ImageUsageFlags::default(), tiling: ImageTiling::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSparseImageFormatInfo2 { - pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { - PhysicalDeviceSparseImageFormatInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { - inner: PhysicalDeviceSparseImageFormatInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { - type Target = PhysicalDeviceSparseImageFormatInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { +impl<'a> PhysicalDeviceSparseImageFormatInfo2<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn ty(mut self, ty: ImageType) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn samples(mut self, samples: SampleCountFlags) -> Self { - self.inner.samples = samples; + self.samples = samples; self } + #[inline] pub fn usage(mut self, usage: ImageUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn tiling(mut self, tiling: ImageTiling) -> Self { - self.inner.tiling = tiling; + self.tiling = tiling; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePushDescriptorPropertiesKHR { +pub struct PhysicalDevicePushDescriptorPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_push_descriptors: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { +impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), max_push_descriptors: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePushDescriptorPropertiesKHR { - pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { - PhysicalDevicePushDescriptorPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { - inner: PhysicalDevicePushDescriptorPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { - type Target = PhysicalDevicePushDescriptorPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR<'_> {} +impl<'a> PhysicalDevicePushDescriptorPropertiesKHR<'a> { + #[inline] pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self { - self.inner.max_push_descriptors = max_push_descriptors; + self.max_push_descriptors = max_push_descriptors; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -14222,66 +10040,41 @@ pub struct ConformanceVersion { pub patch: u8, } impl ConformanceVersion { - pub fn builder<'a>() -> ConformanceVersionBuilder<'a> { - ConformanceVersionBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ConformanceVersionBuilder<'a> { - inner: ConformanceVersion, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> { - type Target = ConformanceVersion; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ConformanceVersionBuilder<'a> { + #[inline] pub fn major(mut self, major: u8) -> Self { - self.inner.major = major; + self.major = major; self } + #[inline] pub fn minor(mut self, minor: u8) -> Self { - self.inner.minor = minor; + self.minor = minor; self } + #[inline] pub fn subminor(mut self, subminor: u8) -> Self { - self.inner.subminor = subminor; + self.subminor = subminor; self } + #[inline] pub fn patch(mut self, patch: u8) -> Self { - self.inner.patch = patch; + self.patch = patch; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ConformanceVersion { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDriverProperties { +pub struct PhysicalDeviceDriverProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub driver_id: DriverId, pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE], pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE], pub conformance_version: ConformanceVersion, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PhysicalDeviceDriverProperties { +impl fmt::Debug for PhysicalDeviceDriverProperties<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceDriverProperties") .field("s_type", &self.s_type) @@ -14297,7 +10090,7 @@ impl fmt::Debug for PhysicalDeviceDriverProperties { .finish() } } -impl ::std::default::Default for PhysicalDeviceDriverProperties { +impl ::std::default::Default for PhysicalDeviceDriverProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES, @@ -14306,170 +10099,89 @@ impl ::std::default::Default for PhysicalDeviceDriverProperties { driver_name: unsafe { ::std::mem::zeroed() }, driver_info: unsafe { ::std::mem::zeroed() }, conformance_version: ConformanceVersion::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDriverProperties { - pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> { - PhysicalDeviceDriverPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDriverPropertiesBuilder<'a> { - inner: PhysicalDeviceDriverProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> { - type Target = PhysicalDeviceDriverProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties<'_> {} +impl<'a> PhysicalDeviceDriverProperties<'a> { + #[inline] pub fn driver_id(mut self, driver_id: DriverId) -> Self { - self.inner.driver_id = driver_id; + self.driver_id = driver_id; self } + #[inline] pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self { - self.inner.driver_name = driver_name; + self.driver_name = driver_name; self } + #[inline] pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self { - self.inner.driver_info = driver_info; + self.driver_info = driver_info; self } + #[inline] pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self { - self.inner.conformance_version = conformance_version; + self.conformance_version = conformance_version; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDriverProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PresentRegionsKHR { +pub struct PresentRegionsKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain_count: u32, - pub p_regions: *const PresentRegionKHR, + pub p_regions: *const PresentRegionKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PresentRegionsKHR { +impl ::std::default::Default for PresentRegionsKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PRESENT_REGIONS_KHR, p_next: ::std::ptr::null(), swapchain_count: u32::default(), p_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PresentRegionsKHR { - pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> { - PresentRegionsKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentRegionsKHRBuilder<'a> { - inner: PresentRegionsKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {} -unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {} -impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { - type Target = PresentRegionsKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentRegionsKHRBuilder<'a> { +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR<'_> {} +impl<'a> PresentRegionsKHR<'a> { + #[inline] pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self { - self.inner.swapchain_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.swapchain_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentRegionsKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PresentRegionKHR { +pub struct PresentRegionKHR<'a> { pub rectangle_count: u32, pub p_rectangles: *const RectLayerKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PresentRegionKHR { +impl ::std::default::Default for PresentRegionKHR<'_> { fn default() -> Self { Self { rectangle_count: u32::default(), p_rectangles: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PresentRegionKHR { - pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> { - PresentRegionKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentRegionKHRBuilder<'a> { - inner: PresentRegionKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> { - type Target = PresentRegionKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentRegionKHRBuilder<'a> { +impl<'a> PresentRegionKHR<'a> { + #[inline] pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self { - self.inner.rectangle_count = rectangles.len() as _; - self.inner.p_rectangles = rectangles.as_ptr(); + self.rectangle_count = rectangles.len() as _; + self.p_rectangles = rectangles.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentRegionKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -14481,115 +10193,60 @@ pub struct RectLayerKHR { pub layer: u32, } impl RectLayerKHR { - pub fn builder<'a>() -> RectLayerKHRBuilder<'a> { - RectLayerKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RectLayerKHRBuilder<'a> { - inner: RectLayerKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> { - type Target = RectLayerKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RectLayerKHRBuilder<'a> { + #[inline] pub fn offset(mut self, offset: Offset2D) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn extent(mut self, extent: Extent2D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } + #[inline] pub fn layer(mut self, layer: u32) -> Self { - self.inner.layer = layer; + self.layer = layer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RectLayerKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVariablePointersFeatures { +pub struct PhysicalDeviceVariablePointersFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub variable_pointers_storage_buffer: Bool32, pub variable_pointers: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures { +impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, p_next: ::std::ptr::null_mut(), variable_pointers_storage_buffer: Bool32::default(), variable_pointers: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVariablePointersFeatures { - pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> { - PhysicalDeviceVariablePointersFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> { - inner: PhysicalDeviceVariablePointersFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { - type Target = PhysicalDeviceVariablePointersFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures<'_> {} +impl<'a> PhysicalDeviceVariablePointersFeatures<'a> { + #[inline] pub fn variable_pointers_storage_buffer( mut self, variable_pointers_storage_buffer: bool, ) -> Self { - self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); + self.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); self } + #[inline] pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { - self.inner.variable_pointers = variable_pointers.into(); + self.variable_pointers = variable_pointers.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVariablePointersFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -14601,188 +10258,103 @@ pub struct ExternalMemoryProperties { pub compatible_handle_types: ExternalMemoryHandleTypeFlags, } impl ExternalMemoryProperties { - pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> { - ExternalMemoryPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalMemoryPropertiesBuilder<'a> { - inner: ExternalMemoryProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> { - type Target = ExternalMemoryProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalMemoryPropertiesBuilder<'a> { + #[inline] pub fn external_memory_features( mut self, external_memory_features: ExternalMemoryFeatureFlags, ) -> Self { - self.inner.external_memory_features = external_memory_features; + self.external_memory_features = external_memory_features; self } + #[inline] pub fn export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, ) -> Self { - self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self.export_from_imported_handle_types = export_from_imported_handle_types; self } + #[inline] pub fn compatible_handle_types( mut self, compatible_handle_types: ExternalMemoryHandleTypeFlags, ) -> Self { - self.inner.compatible_handle_types = compatible_handle_types; + self.compatible_handle_types = compatible_handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalMemoryProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExternalImageFormatInfo { +pub struct PhysicalDeviceExternalImageFormatInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { +impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExternalImageFormatInfo { - pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { - PhysicalDeviceExternalImageFormatInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { - inner: PhysicalDeviceExternalImageFormatInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 - for PhysicalDeviceExternalImageFormatInfoBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { - type Target = PhysicalDeviceExternalImageFormatInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo<'_> {} +impl<'a> PhysicalDeviceExternalImageFormatInfo<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalImageFormatProperties { +pub struct ExternalImageFormatProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub external_memory_properties: ExternalMemoryProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalImageFormatProperties { +impl ::std::default::Default for ExternalImageFormatProperties<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES, p_next: ::std::ptr::null_mut(), external_memory_properties: ExternalMemoryProperties::default(), + _marker: PhantomData, } } } -impl ExternalImageFormatProperties { - pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> { - ExternalImageFormatPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalImageFormatPropertiesBuilder<'a> { - inner: ExternalImageFormatProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {} -unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {} -impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> { - type Target = ExternalImageFormatProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalImageFormatPropertiesBuilder<'a> { +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties<'_> {} +impl<'a> ExternalImageFormatProperties<'a> { + #[inline] pub fn external_memory_properties( mut self, external_memory_properties: ExternalMemoryProperties, ) -> Self { - self.inner.external_memory_properties = external_memory_properties; + self.external_memory_properties = external_memory_properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalImageFormatProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExternalBufferInfo { +pub struct PhysicalDeviceExternalBufferInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: BufferCreateFlags, pub usage: BufferUsageFlags, pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { +impl ::std::default::Default for PhysicalDeviceExternalBufferInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, @@ -14790,115 +10362,62 @@ impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { flags: BufferCreateFlags::default(), usage: BufferUsageFlags::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExternalBufferInfo { - pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> { - PhysicalDeviceExternalBufferInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { - inner: PhysicalDeviceExternalBufferInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { - type Target = PhysicalDeviceExternalBufferInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { +impl<'a> PhysicalDeviceExternalBufferInfo<'a> { + #[inline] pub fn flags(mut self, flags: BufferCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn usage(mut self, usage: BufferUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExternalBufferInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalBufferProperties { +pub struct ExternalBufferProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub external_memory_properties: ExternalMemoryProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalBufferProperties { +impl ::std::default::Default for ExternalBufferProperties<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES, p_next: ::std::ptr::null_mut(), external_memory_properties: ExternalMemoryProperties::default(), + _marker: PhantomData, } } } -impl ExternalBufferProperties { - pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> { - ExternalBufferPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalBufferPropertiesBuilder<'a> { - inner: ExternalBufferProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { - type Target = ExternalBufferProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalBufferPropertiesBuilder<'a> { +impl<'a> ExternalBufferProperties<'a> { + #[inline] pub fn external_memory_properties( mut self, external_memory_properties: ExternalMemoryProperties, ) -> Self { - self.inner.external_memory_properties = external_memory_properties; + self.external_memory_properties = external_memory_properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalBufferProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceIDProperties { +pub struct PhysicalDeviceIDProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub device_uuid: [u8; UUID_SIZE], @@ -14906,8 +10425,9 @@ pub struct PhysicalDeviceIDProperties { pub device_luid: [u8; LUID_SIZE], pub device_node_mask: u32, pub device_luid_valid: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceIDProperties { +impl ::std::default::Default for PhysicalDeviceIDProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES, @@ -14917,243 +10437,135 @@ impl ::std::default::Default for PhysicalDeviceIDProperties { device_luid: unsafe { ::std::mem::zeroed() }, device_node_mask: u32::default(), device_luid_valid: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceIDProperties { - pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> { - PhysicalDeviceIDPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceIDPropertiesBuilder<'a> { - inner: PhysicalDeviceIDProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> { - type Target = PhysicalDeviceIDProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties<'_> {} +impl<'a> PhysicalDeviceIDProperties<'a> { + #[inline] pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self { - self.inner.device_uuid = device_uuid; + self.device_uuid = device_uuid; self } + #[inline] pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self { - self.inner.driver_uuid = driver_uuid; + self.driver_uuid = driver_uuid; self } + #[inline] pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self { - self.inner.device_luid = device_luid; + self.device_luid = device_luid; self } + #[inline] pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { - self.inner.device_node_mask = device_node_mask; + self.device_node_mask = device_node_mask; self } + #[inline] pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { - self.inner.device_luid_valid = device_luid_valid.into(); + self.device_luid_valid = device_luid_valid.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceIDProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalMemoryImageCreateInfo { +pub struct ExternalMemoryImageCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalMemoryImageCreateInfo { +impl ::std::default::Default for ExternalMemoryImageCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO, p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl ExternalMemoryImageCreateInfo { - pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> { - ExternalMemoryImageCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalMemoryImageCreateInfoBuilder<'a> { - inner: ExternalMemoryImageCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {} -impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> { - type Target = ExternalMemoryImageCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo<'_> {} +impl<'a> ExternalMemoryImageCreateInfo<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalMemoryImageCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalMemoryBufferCreateInfo { +pub struct ExternalMemoryBufferCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalMemoryBufferCreateInfo { +impl ::std::default::Default for ExternalMemoryBufferCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO, p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl ExternalMemoryBufferCreateInfo { - pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> { - ExternalMemoryBufferCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalMemoryBufferCreateInfoBuilder<'a> { - inner: ExternalMemoryBufferCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {} -impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> { - type Target = ExternalMemoryBufferCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> { +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo<'_> {} +impl<'a> ExternalMemoryBufferCreateInfo<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalMemoryBufferCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportMemoryAllocateInfo { +pub struct ExportMemoryAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMemoryAllocateInfo { +impl ::std::default::Default for ExportMemoryAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO, p_next: ::std::ptr::null(), handle_types: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl ExportMemoryAllocateInfo { - pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> { - ExportMemoryAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportMemoryAllocateInfoBuilder<'a> { - inner: ExportMemoryAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {} -impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> { - type Target = ExportMemoryAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportMemoryAllocateInfoBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo<'_> {} +impl<'a> ExportMemoryAllocateInfo<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportMemoryAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportMemoryWin32HandleInfoKHR { +pub struct ImportMemoryWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, pub handle: HANDLE, pub name: LPCWSTR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { +impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, @@ -15161,67 +10573,41 @@ impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { handle_type: ExternalMemoryHandleTypeFlags::default(), handle: unsafe { ::std::mem::zeroed() }, name: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ImportMemoryWin32HandleInfoKHR { - pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { - ImportMemoryWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> { - inner: ImportMemoryWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {} -impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> { - type Target = ImportMemoryWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR<'_> {} +impl<'a> ImportMemoryWin32HandleInfoKHR<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn handle(mut self, handle: HANDLE) -> Self { - self.inner.handle = handle; + self.handle = handle; self } + #[inline] pub fn name(mut self, name: LPCWSTR) -> Self { - self.inner.name = name; + self.name = name; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportMemoryWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportMemoryWin32HandleInfoKHR { +pub struct ExportMemoryWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_attributes: *const SECURITY_ATTRIBUTES, pub dw_access: DWORD, pub name: LPCWSTR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { +impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, @@ -15229,526 +10615,286 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), name: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ExportMemoryWin32HandleInfoKHR { - pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { - ExportMemoryWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> { - inner: ExportMemoryWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {} -impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { - type Target = ExportMemoryWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR<'_> {} +impl<'a> ExportMemoryWin32HandleInfoKHR<'a> { + #[inline] pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { - self.inner.p_attributes = attributes; + self.p_attributes = attributes; self } + #[inline] pub fn dw_access(mut self, dw_access: DWORD) -> Self { - self.inner.dw_access = dw_access; + self.dw_access = dw_access; self } + #[inline] pub fn name(mut self, name: LPCWSTR) -> Self { - self.inner.name = name; + self.name = name; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportMemoryWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportMemoryZirconHandleInfoFUCHSIA { +pub struct ImportMemoryZirconHandleInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, pub handle: zx_handle_t, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA { +impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), handle: zx_handle_t::default(), + _marker: PhantomData, } } } -impl ImportMemoryZirconHandleInfoFUCHSIA { - pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { - ImportMemoryZirconHandleInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { - inner: ImportMemoryZirconHandleInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIABuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA {} -impl<'a> ::std::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { - type Target = ImportMemoryZirconHandleInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA<'_> {} +impl<'a> ImportMemoryZirconHandleInfoFUCHSIA<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn handle(mut self, handle: zx_handle_t) -> Self { - self.inner.handle = handle; + self.handle = handle; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportMemoryZirconHandleInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryZirconHandlePropertiesFUCHSIA { +pub struct MemoryZirconHandlePropertiesFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_type_bits: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA { +impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA, p_next: ::std::ptr::null_mut(), memory_type_bits: u32::default(), + _marker: PhantomData, } } } -impl MemoryZirconHandlePropertiesFUCHSIA { - pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { - MemoryZirconHandlePropertiesFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { - inner: MemoryZirconHandlePropertiesFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { - type Target = MemoryZirconHandlePropertiesFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { +impl<'a> MemoryZirconHandlePropertiesFUCHSIA<'a> { + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryZirconHandlePropertiesFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryGetZirconHandleInfoFUCHSIA { +pub struct MemoryGetZirconHandleInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA { +impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA, p_next: ::std::ptr::null(), memory: DeviceMemory::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl MemoryGetZirconHandleInfoFUCHSIA { - pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { - MemoryGetZirconHandleInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { - inner: MemoryGetZirconHandleInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { - type Target = MemoryGetZirconHandleInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { +impl<'a> MemoryGetZirconHandleInfoFUCHSIA<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryGetZirconHandleInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryWin32HandlePropertiesKHR { +pub struct MemoryWin32HandlePropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_type_bits: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { +impl ::std::default::Default for MemoryWin32HandlePropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), memory_type_bits: u32::default(), + _marker: PhantomData, } } } -impl MemoryWin32HandlePropertiesKHR { - pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> { - MemoryWin32HandlePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { - inner: MemoryWin32HandlePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { - type Target = MemoryWin32HandlePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { +impl<'a> MemoryWin32HandlePropertiesKHR<'a> { + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryWin32HandlePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryGetWin32HandleInfoKHR { +pub struct MemoryGetWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryGetWin32HandleInfoKHR { +impl ::std::default::Default for MemoryGetWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR, p_next: ::std::ptr::null(), memory: DeviceMemory::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl MemoryGetWin32HandleInfoKHR { - pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> { - MemoryGetWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { - inner: MemoryGetWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { - type Target = MemoryGetWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { +impl<'a> MemoryGetWin32HandleInfoKHR<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryGetWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportMemoryFdInfoKHR { +pub struct ImportMemoryFdInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, pub fd: c_int, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryFdInfoKHR { +impl ::std::default::Default for ImportMemoryFdInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR, p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), fd: c_int::default(), + _marker: PhantomData, } } } -impl ImportMemoryFdInfoKHR { - pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> { - ImportMemoryFdInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportMemoryFdInfoKHRBuilder<'a> { - inner: ImportMemoryFdInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {} -impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> { - type Target = ImportMemoryFdInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportMemoryFdInfoKHRBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR<'_> {} +impl<'a> ImportMemoryFdInfoKHR<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn fd(mut self, fd: c_int) -> Self { - self.inner.fd = fd; + self.fd = fd; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportMemoryFdInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryFdPropertiesKHR { +pub struct MemoryFdPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_type_bits: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryFdPropertiesKHR { +impl ::std::default::Default for MemoryFdPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_FD_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), memory_type_bits: u32::default(), + _marker: PhantomData, } } } -impl MemoryFdPropertiesKHR { - pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> { - MemoryFdPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryFdPropertiesKHRBuilder<'a> { - inner: MemoryFdPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { - type Target = MemoryFdPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryFdPropertiesKHRBuilder<'a> { +impl<'a> MemoryFdPropertiesKHR<'a> { + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryFdPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryGetFdInfoKHR { +pub struct MemoryGetFdInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryGetFdInfoKHR { +impl ::std::default::Default for MemoryGetFdInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_GET_FD_INFO_KHR, p_next: ::std::ptr::null(), memory: DeviceMemory::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl MemoryGetFdInfoKHR { - pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> { - MemoryGetFdInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryGetFdInfoKHRBuilder<'a> { - inner: MemoryGetFdInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { - type Target = MemoryGetFdInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryGetFdInfoKHRBuilder<'a> { +impl<'a> MemoryGetFdInfoKHR<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryGetFdInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct Win32KeyedMutexAcquireReleaseInfoKHR { +pub struct Win32KeyedMutexAcquireReleaseInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acquire_count: u32, @@ -15758,8 +10904,9 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHR { pub release_count: u32, pub p_release_syncs: *const DeviceMemory, pub p_release_keys: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, @@ -15771,122 +10918,75 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { release_count: u32::default(), p_release_syncs: ::std::ptr::null(), p_release_keys: ::std::ptr::null(), + _marker: PhantomData, } } } -impl Win32KeyedMutexAcquireReleaseInfoKHR { - pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - Win32KeyedMutexAcquireReleaseInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - inner: Win32KeyedMutexAcquireReleaseInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {} -unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} -unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {} -impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - type Target = Win32KeyedMutexAcquireReleaseInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR<'_> {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR<'_> {} +impl<'a> Win32KeyedMutexAcquireReleaseInfoKHR<'a> { + #[inline] pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self { - self.inner.acquire_count = acquire_syncs.len() as _; - self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self.acquire_count = acquire_syncs.len() as _; + self.p_acquire_syncs = acquire_syncs.as_ptr(); self } + #[inline] pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self { - self.inner.acquire_count = acquire_keys.len() as _; - self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self.acquire_count = acquire_keys.len() as _; + self.p_acquire_keys = acquire_keys.as_ptr(); self } + #[inline] pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self { - self.inner.acquire_count = acquire_timeouts.len() as _; - self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr(); + self.acquire_count = acquire_timeouts.len() as _; + self.p_acquire_timeouts = acquire_timeouts.as_ptr(); self } + #[inline] pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self { - self.inner.release_count = release_syncs.len() as _; - self.inner.p_release_syncs = release_syncs.as_ptr(); + self.release_count = release_syncs.len() as _; + self.p_release_syncs = release_syncs.as_ptr(); self } + #[inline] pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self { - self.inner.release_count = release_keys.len() as _; - self.inner.p_release_keys = release_keys.as_ptr(); + self.release_count = release_keys.len() as _; + self.p_release_keys = release_keys.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExternalSemaphoreInfo { +pub struct PhysicalDeviceExternalSemaphoreInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { +impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, p_next: ::std::ptr::null(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExternalSemaphoreInfo { - pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { - PhysicalDeviceExternalSemaphoreInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { - inner: PhysicalDeviceExternalSemaphoreInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { - type Target = PhysicalDeviceExternalSemaphoreInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { +impl<'a> PhysicalDeviceExternalSemaphoreInfo<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -15895,30 +10995,25 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalSemaphoreProperties { +pub struct ExternalSemaphoreProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags, pub external_semaphore_features: ExternalSemaphoreFeatureFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalSemaphoreProperties { +impl ::std::default::Default for ExternalSemaphoreProperties<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES, @@ -15926,123 +11021,69 @@ impl ::std::default::Default for ExternalSemaphoreProperties { export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(), compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(), external_semaphore_features: ExternalSemaphoreFeatureFlags::default(), + _marker: PhantomData, } } } -impl ExternalSemaphoreProperties { - pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> { - ExternalSemaphorePropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalSemaphorePropertiesBuilder<'a> { - inner: ExternalSemaphoreProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { - type Target = ExternalSemaphoreProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalSemaphorePropertiesBuilder<'a> { +impl<'a> ExternalSemaphoreProperties<'a> { + #[inline] pub fn export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, ) -> Self { - self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self.export_from_imported_handle_types = export_from_imported_handle_types; self } + #[inline] pub fn compatible_handle_types( mut self, compatible_handle_types: ExternalSemaphoreHandleTypeFlags, ) -> Self { - self.inner.compatible_handle_types = compatible_handle_types; + self.compatible_handle_types = compatible_handle_types; self } + #[inline] pub fn external_semaphore_features( mut self, external_semaphore_features: ExternalSemaphoreFeatureFlags, ) -> Self { - self.inner.external_semaphore_features = external_semaphore_features; + self.external_semaphore_features = external_semaphore_features; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalSemaphoreProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportSemaphoreCreateInfo { +pub struct ExportSemaphoreCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalSemaphoreHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportSemaphoreCreateInfo { +impl ::std::default::Default for ExportSemaphoreCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO, p_next: ::std::ptr::null(), handle_types: ExternalSemaphoreHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl ExportSemaphoreCreateInfo { - pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> { - ExportSemaphoreCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportSemaphoreCreateInfoBuilder<'a> { - inner: ExportSemaphoreCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {} -impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> { - type Target = ExportSemaphoreCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportSemaphoreCreateInfoBuilder<'a> { +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo<'_> {} +impl<'a> ExportSemaphoreCreateInfo<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportSemaphoreCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportSemaphoreWin32HandleInfoKHR { +pub struct ImportSemaphoreWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, @@ -16050,8 +11091,9 @@ pub struct ImportSemaphoreWin32HandleInfoKHR { pub handle_type: ExternalSemaphoreHandleTypeFlags, pub handle: HANDLE, pub name: LPCWSTR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { +impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, @@ -16061,73 +11103,50 @@ impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { handle_type: ExternalSemaphoreHandleTypeFlags::default(), handle: unsafe { ::std::mem::zeroed() }, name: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ImportSemaphoreWin32HandleInfoKHR { - pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { - ImportSemaphoreWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { - inner: ImportSemaphoreWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { - type Target = ImportSemaphoreWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { +impl<'a> ImportSemaphoreWin32HandleInfoKHR<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn handle(mut self, handle: HANDLE) -> Self { - self.inner.handle = handle; + self.handle = handle; self } + #[inline] pub fn name(mut self, name: LPCWSTR) -> Self { - self.inner.name = name; + self.name = name; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportSemaphoreWin32HandleInfoKHR { +pub struct ExportSemaphoreWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_attributes: *const SECURITY_ATTRIBUTES, pub dw_access: DWORD, pub name: LPCWSTR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { +impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, @@ -16135,68 +11154,42 @@ impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), name: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ExportSemaphoreWin32HandleInfoKHR { - pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { - ExportSemaphoreWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { - inner: ExportSemaphoreWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {} -unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {} -impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { - type Target = ExportSemaphoreWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR<'_> {} +impl<'a> ExportSemaphoreWin32HandleInfoKHR<'a> { + #[inline] pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { - self.inner.p_attributes = attributes; + self.p_attributes = attributes; self } + #[inline] pub fn dw_access(mut self, dw_access: DWORD) -> Self { - self.inner.dw_access = dw_access; + self.dw_access = dw_access; self } + #[inline] pub fn name(mut self, name: LPCWSTR) -> Self { - self.inner.name = name; + self.name = name; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct D3D12FenceSubmitInfoKHR { +pub struct D3D12FenceSubmitInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub wait_semaphore_values_count: u32, pub p_wait_semaphore_values: *const u64, pub signal_semaphore_values_count: u32, pub p_signal_semaphore_values: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for D3D12FenceSubmitInfoKHR { +impl ::std::default::Default for D3D12FenceSubmitInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR, @@ -16205,126 +11198,73 @@ impl ::std::default::Default for D3D12FenceSubmitInfoKHR { p_wait_semaphore_values: ::std::ptr::null(), signal_semaphore_values_count: u32::default(), p_signal_semaphore_values: ::std::ptr::null(), + _marker: PhantomData, } } } -impl D3D12FenceSubmitInfoKHR { - pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> { - D3D12FenceSubmitInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct D3D12FenceSubmitInfoKHRBuilder<'a> { - inner: D3D12FenceSubmitInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {} -impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { - type Target = D3D12FenceSubmitInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR<'_> {} +impl<'a> D3D12FenceSubmitInfoKHR<'a> { + #[inline] pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self { - self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _; - self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self.wait_semaphore_values_count = wait_semaphore_values.len() as _; + self.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); self } + #[inline] pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self { - self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _; - self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self.signal_semaphore_values_count = signal_semaphore_values.len() as _; + self.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> D3D12FenceSubmitInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreGetWin32HandleInfoKHR { +pub struct SemaphoreGetWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR { +impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, p_next: ::std::ptr::null(), semaphore: Semaphore::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl SemaphoreGetWin32HandleInfoKHR { - pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { - SemaphoreGetWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { - inner: SemaphoreGetWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { - type Target = SemaphoreGetWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { +impl<'a> SemaphoreGetWin32HandleInfoKHR<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportSemaphoreFdInfoKHR { +pub struct ImportSemaphoreFdInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub flags: SemaphoreImportFlags, pub handle_type: ExternalSemaphoreHandleTypeFlags, pub fd: c_int, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportSemaphoreFdInfoKHR { +impl ::std::default::Default for ImportSemaphoreFdInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR, @@ -16333,130 +11273,80 @@ impl ::std::default::Default for ImportSemaphoreFdInfoKHR { flags: SemaphoreImportFlags::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), fd: c_int::default(), + _marker: PhantomData, } } } -impl ImportSemaphoreFdInfoKHR { - pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> { - ImportSemaphoreFdInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { - inner: ImportSemaphoreFdInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { - type Target = ImportSemaphoreFdInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { +impl<'a> ImportSemaphoreFdInfoKHR<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn fd(mut self, fd: c_int) -> Self { - self.inner.fd = fd; + self.fd = fd; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportSemaphoreFdInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreGetFdInfoKHR { +pub struct SemaphoreGetFdInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreGetFdInfoKHR { +impl ::std::default::Default for SemaphoreGetFdInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR, p_next: ::std::ptr::null(), semaphore: Semaphore::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl SemaphoreGetFdInfoKHR { - pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> { - SemaphoreGetFdInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreGetFdInfoKHRBuilder<'a> { - inner: SemaphoreGetFdInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { - type Target = SemaphoreGetFdInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { +impl<'a> SemaphoreGetFdInfoKHR<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreGetFdInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportSemaphoreZirconHandleInfoFUCHSIA { +pub struct ImportSemaphoreZirconHandleInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub flags: SemaphoreImportFlags, pub handle_type: ExternalSemaphoreHandleTypeFlags, pub zircon_handle: zx_handle_t, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA { +impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA, @@ -16465,183 +11355,106 @@ impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA { flags: SemaphoreImportFlags::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), zircon_handle: zx_handle_t::default(), + _marker: PhantomData, } } } -impl ImportSemaphoreZirconHandleInfoFUCHSIA { - pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { - ImportSemaphoreZirconHandleInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { - inner: ImportSemaphoreZirconHandleInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { - type Target = ImportSemaphoreZirconHandleInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { +impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIA<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self { - self.inner.zircon_handle = zircon_handle; + self.zircon_handle = zircon_handle; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreGetZirconHandleInfoFUCHSIA { +pub struct SemaphoreGetZirconHandleInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA { +impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA, p_next: ::std::ptr::null(), semaphore: Semaphore::default(), handle_type: ExternalSemaphoreHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl SemaphoreGetZirconHandleInfoFUCHSIA { - pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { - SemaphoreGetZirconHandleInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { - inner: SemaphoreGetZirconHandleInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { - type Target = SemaphoreGetZirconHandleInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { +impl<'a> SemaphoreGetZirconHandleInfoFUCHSIA<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExternalFenceInfo { +pub struct PhysicalDeviceExternalFenceInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalFenceHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { +impl ::std::default::Default for PhysicalDeviceExternalFenceInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, p_next: ::std::ptr::null(), handle_type: ExternalFenceHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExternalFenceInfo { - pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> { - PhysicalDeviceExternalFenceInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { - inner: PhysicalDeviceExternalFenceInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { - type Target = PhysicalDeviceExternalFenceInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { +impl<'a> PhysicalDeviceExternalFenceInfo<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExternalFenceInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalFenceProperties { +pub struct ExternalFenceProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags, pub compatible_handle_types: ExternalFenceHandleTypeFlags, pub external_fence_features: ExternalFenceFeatureFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalFenceProperties { +impl ::std::default::Default for ExternalFenceProperties<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_FENCE_PROPERTIES, @@ -16649,123 +11462,69 @@ impl ::std::default::Default for ExternalFenceProperties { export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(), compatible_handle_types: ExternalFenceHandleTypeFlags::default(), external_fence_features: ExternalFenceFeatureFlags::default(), + _marker: PhantomData, } } } -impl ExternalFenceProperties { - pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> { - ExternalFencePropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalFencePropertiesBuilder<'a> { - inner: ExternalFenceProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { - type Target = ExternalFenceProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalFencePropertiesBuilder<'a> { +impl<'a> ExternalFenceProperties<'a> { + #[inline] pub fn export_from_imported_handle_types( mut self, export_from_imported_handle_types: ExternalFenceHandleTypeFlags, ) -> Self { - self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self.export_from_imported_handle_types = export_from_imported_handle_types; self } + #[inline] pub fn compatible_handle_types( mut self, compatible_handle_types: ExternalFenceHandleTypeFlags, ) -> Self { - self.inner.compatible_handle_types = compatible_handle_types; + self.compatible_handle_types = compatible_handle_types; self } + #[inline] pub fn external_fence_features( mut self, external_fence_features: ExternalFenceFeatureFlags, ) -> Self { - self.inner.external_fence_features = external_fence_features; + self.external_fence_features = external_fence_features; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalFenceProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportFenceCreateInfo { +pub struct ExportFenceCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_types: ExternalFenceHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportFenceCreateInfo { +impl ::std::default::Default for ExportFenceCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_FENCE_CREATE_INFO, p_next: ::std::ptr::null(), handle_types: ExternalFenceHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl ExportFenceCreateInfo { - pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> { - ExportFenceCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportFenceCreateInfoBuilder<'a> { - inner: ExportFenceCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {} -unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {} -impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> { - type Target = ExportFenceCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportFenceCreateInfoBuilder<'a> { +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo<'_> {} +impl<'a> ExportFenceCreateInfo<'a> { + #[inline] pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self { - self.inner.handle_types = handle_types; + self.handle_types = handle_types; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportFenceCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportFenceWin32HandleInfoKHR { +pub struct ImportFenceWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fence: Fence, @@ -16773,8 +11532,9 @@ pub struct ImportFenceWin32HandleInfoKHR { pub handle_type: ExternalFenceHandleTypeFlags, pub handle: HANDLE, pub name: LPCWSTR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { +impl ::std::default::Default for ImportFenceWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, @@ -16784,73 +11544,50 @@ impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { handle_type: ExternalFenceHandleTypeFlags::default(), handle: unsafe { ::std::mem::zeroed() }, name: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ImportFenceWin32HandleInfoKHR { - pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> { - ImportFenceWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { - inner: ImportFenceWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { - type Target = ImportFenceWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { +impl<'a> ImportFenceWin32HandleInfoKHR<'a> { + #[inline] pub fn fence(mut self, fence: Fence) -> Self { - self.inner.fence = fence; + self.fence = fence; self } + #[inline] pub fn flags(mut self, flags: FenceImportFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn handle(mut self, handle: HANDLE) -> Self { - self.inner.handle = handle; + self.handle = handle; self } + #[inline] pub fn name(mut self, name: LPCWSTR) -> Self { - self.inner.name = name; + self.name = name; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportFenceWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExportFenceWin32HandleInfoKHR { +pub struct ExportFenceWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_attributes: *const SECURITY_ATTRIBUTES, pub dw_access: DWORD, pub name: LPCWSTR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { +impl ::std::default::Default for ExportFenceWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, @@ -16858,128 +11595,76 @@ impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { p_attributes: ::std::ptr::null(), dw_access: DWORD::default(), name: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ExportFenceWin32HandleInfoKHR { - pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> { - ExportFenceWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> { - inner: ExportFenceWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {} -unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {} -impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { - type Target = ExportFenceWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR<'_> {} +impl<'a> ExportFenceWin32HandleInfoKHR<'a> { + #[inline] pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { - self.inner.p_attributes = attributes; + self.p_attributes = attributes; self } + #[inline] pub fn dw_access(mut self, dw_access: DWORD) -> Self { - self.inner.dw_access = dw_access; + self.dw_access = dw_access; self } + #[inline] pub fn name(mut self, name: LPCWSTR) -> Self { - self.inner.name = name; + self.name = name; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExportFenceWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FenceGetWin32HandleInfoKHR { +pub struct FenceGetWin32HandleInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fence: Fence, pub handle_type: ExternalFenceHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FenceGetWin32HandleInfoKHR { +impl ::std::default::Default for FenceGetWin32HandleInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR, p_next: ::std::ptr::null(), fence: Fence::default(), handle_type: ExternalFenceHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl FenceGetWin32HandleInfoKHR { - pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> { - FenceGetWin32HandleInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { - inner: FenceGetWin32HandleInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { - type Target = FenceGetWin32HandleInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { +impl<'a> FenceGetWin32HandleInfoKHR<'a> { + #[inline] pub fn fence(mut self, fence: Fence) -> Self { - self.inner.fence = fence; + self.fence = fence; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FenceGetWin32HandleInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportFenceFdInfoKHR { +pub struct ImportFenceFdInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fence: Fence, pub flags: FenceImportFlags, pub handle_type: ExternalFenceHandleTypeFlags, pub fd: c_int, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportFenceFdInfoKHR { +impl ::std::default::Default for ImportFenceFdInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR, @@ -16988,129 +11673,79 @@ impl ::std::default::Default for ImportFenceFdInfoKHR { flags: FenceImportFlags::default(), handle_type: ExternalFenceHandleTypeFlags::default(), fd: c_int::default(), + _marker: PhantomData, } } } -impl ImportFenceFdInfoKHR { - pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> { - ImportFenceFdInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportFenceFdInfoKHRBuilder<'a> { - inner: ImportFenceFdInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { - type Target = ImportFenceFdInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportFenceFdInfoKHRBuilder<'a> { +impl<'a> ImportFenceFdInfoKHR<'a> { + #[inline] pub fn fence(mut self, fence: Fence) -> Self { - self.inner.fence = fence; + self.fence = fence; self } + #[inline] pub fn flags(mut self, flags: FenceImportFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn fd(mut self, fd: c_int) -> Self { - self.inner.fd = fd; + self.fd = fd; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportFenceFdInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FenceGetFdInfoKHR { +pub struct FenceGetFdInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fence: Fence, pub handle_type: ExternalFenceHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FenceGetFdInfoKHR { +impl ::std::default::Default for FenceGetFdInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::FENCE_GET_FD_INFO_KHR, p_next: ::std::ptr::null(), fence: Fence::default(), handle_type: ExternalFenceHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl FenceGetFdInfoKHR { - pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> { - FenceGetFdInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FenceGetFdInfoKHRBuilder<'a> { - inner: FenceGetFdInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { - type Target = FenceGetFdInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FenceGetFdInfoKHRBuilder<'a> { +impl<'a> FenceGetFdInfoKHR<'a> { + #[inline] pub fn fence(mut self, fence: Fence) -> Self { - self.inner.fence = fence; + self.fence = fence; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FenceGetFdInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMultiviewFeatures { +pub struct PhysicalDeviceMultiviewFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub multiview: Bool32, pub multiview_geometry_shader: Bool32, pub multiview_tessellation_shader: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { +impl ::std::default::Default for PhysicalDeviceMultiviewFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES, @@ -17118,124 +11753,69 @@ impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { multiview: Bool32::default(), multiview_geometry_shader: Bool32::default(), multiview_tessellation_shader: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMultiviewFeatures { - pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { - PhysicalDeviceMultiviewFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { - inner: PhysicalDeviceMultiviewFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { - type Target = PhysicalDeviceMultiviewFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures<'_> {} +impl<'a> PhysicalDeviceMultiviewFeatures<'a> { + #[inline] pub fn multiview(mut self, multiview: bool) -> Self { - self.inner.multiview = multiview.into(); + self.multiview = multiview.into(); self } + #[inline] pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self { - self.inner.multiview_geometry_shader = multiview_geometry_shader.into(); + self.multiview_geometry_shader = multiview_geometry_shader.into(); self } + #[inline] pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self { - self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self.multiview_tessellation_shader = multiview_tessellation_shader.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMultiviewFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMultiviewProperties { +pub struct PhysicalDeviceMultiviewProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_multiview_view_count: u32, pub max_multiview_instance_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMultiviewProperties { +impl ::std::default::Default for PhysicalDeviceMultiviewProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, p_next: ::std::ptr::null_mut(), max_multiview_view_count: u32::default(), max_multiview_instance_index: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMultiviewProperties { - pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> { - PhysicalDeviceMultiviewPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> { - inner: PhysicalDeviceMultiviewProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> { - type Target = PhysicalDeviceMultiviewProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties<'_> {} +impl<'a> PhysicalDeviceMultiviewProperties<'a> { + #[inline] pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self { - self.inner.max_multiview_view_count = max_multiview_view_count; + self.max_multiview_view_count = max_multiview_view_count; self } + #[inline] pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self { - self.inner.max_multiview_instance_index = max_multiview_instance_index; + self.max_multiview_instance_index = max_multiview_instance_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMultiviewProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassMultiviewCreateInfo { +pub struct RenderPassMultiviewCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub subpass_count: u32, @@ -17244,8 +11824,9 @@ pub struct RenderPassMultiviewCreateInfo { pub p_view_offsets: *const i32, pub correlation_mask_count: u32, pub p_correlation_masks: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassMultiviewCreateInfo { +impl ::std::default::Default for RenderPassMultiviewCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO, @@ -17256,63 +11837,36 @@ impl ::std::default::Default for RenderPassMultiviewCreateInfo { p_view_offsets: ::std::ptr::null(), correlation_mask_count: u32::default(), p_correlation_masks: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassMultiviewCreateInfo { - pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> { - RenderPassMultiviewCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassMultiviewCreateInfoBuilder<'a> { - inner: RenderPassMultiviewCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {} -impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { - type Target = RenderPassMultiviewCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo<'_> {} +impl<'a> RenderPassMultiviewCreateInfo<'a> { + #[inline] pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self { - self.inner.subpass_count = view_masks.len() as _; - self.inner.p_view_masks = view_masks.as_ptr(); + self.subpass_count = view_masks.len() as _; + self.p_view_masks = view_masks.as_ptr(); self } + #[inline] pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self { - self.inner.dependency_count = view_offsets.len() as _; - self.inner.p_view_offsets = view_offsets.as_ptr(); + self.dependency_count = view_offsets.len() as _; + self.p_view_offsets = view_offsets.as_ptr(); self } + #[inline] pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self { - self.inner.correlation_mask_count = correlation_masks.len() as _; - self.inner.p_correlation_masks = correlation_masks.as_ptr(); + self.correlation_mask_count = correlation_masks.len() as _; + self.p_correlation_masks = correlation_masks.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassMultiviewCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceCapabilities2EXT { +pub struct SurfaceCapabilities2EXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_image_count: u32, @@ -17326,8 +11880,9 @@ pub struct SurfaceCapabilities2EXT { pub supported_composite_alpha: CompositeAlphaFlagsKHR, pub supported_usage_flags: ImageUsageFlags, pub supported_surface_counters: SurfaceCounterFlagsEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceCapabilities2EXT { +impl ::std::default::Default for SurfaceCapabilities2EXT<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_CAPABILITIES_2_EXT, @@ -17343,321 +11898,195 @@ impl ::std::default::Default for SurfaceCapabilities2EXT { supported_composite_alpha: CompositeAlphaFlagsKHR::default(), supported_usage_flags: ImageUsageFlags::default(), supported_surface_counters: SurfaceCounterFlagsEXT::default(), + _marker: PhantomData, } } } -impl SurfaceCapabilities2EXT { - pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> { - SurfaceCapabilities2EXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceCapabilities2EXTBuilder<'a> { - inner: SurfaceCapabilities2EXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { - type Target = SurfaceCapabilities2EXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceCapabilities2EXTBuilder<'a> { +impl<'a> SurfaceCapabilities2EXT<'a> { + #[inline] pub fn min_image_count(mut self, min_image_count: u32) -> Self { - self.inner.min_image_count = min_image_count; + self.min_image_count = min_image_count; self } + #[inline] pub fn max_image_count(mut self, max_image_count: u32) -> Self { - self.inner.max_image_count = max_image_count; + self.max_image_count = max_image_count; self } + #[inline] pub fn current_extent(mut self, current_extent: Extent2D) -> Self { - self.inner.current_extent = current_extent; + self.current_extent = current_extent; self } + #[inline] pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self { - self.inner.min_image_extent = min_image_extent; + self.min_image_extent = min_image_extent; self } + #[inline] pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self { - self.inner.max_image_extent = max_image_extent; + self.max_image_extent = max_image_extent; self } + #[inline] pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { - self.inner.max_image_array_layers = max_image_array_layers; + self.max_image_array_layers = max_image_array_layers; self } + #[inline] pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { - self.inner.supported_transforms = supported_transforms; + self.supported_transforms = supported_transforms; self } + #[inline] pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.current_transform = current_transform; + self.current_transform = current_transform; self } + #[inline] pub fn supported_composite_alpha( mut self, supported_composite_alpha: CompositeAlphaFlagsKHR, ) -> Self { - self.inner.supported_composite_alpha = supported_composite_alpha; + self.supported_composite_alpha = supported_composite_alpha; self } + #[inline] pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self { - self.inner.supported_usage_flags = supported_usage_flags; + self.supported_usage_flags = supported_usage_flags; self } + #[inline] pub fn supported_surface_counters( mut self, supported_surface_counters: SurfaceCounterFlagsEXT, ) -> Self { - self.inner.supported_surface_counters = supported_surface_counters; + self.supported_surface_counters = supported_surface_counters; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceCapabilities2EXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayPowerInfoEXT { +pub struct DisplayPowerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub power_state: DisplayPowerStateEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayPowerInfoEXT { +impl ::std::default::Default for DisplayPowerInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_POWER_INFO_EXT, p_next: ::std::ptr::null(), power_state: DisplayPowerStateEXT::default(), + _marker: PhantomData, } } } -impl DisplayPowerInfoEXT { - pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> { - DisplayPowerInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPowerInfoEXTBuilder<'a> { - inner: DisplayPowerInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { - type Target = DisplayPowerInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPowerInfoEXTBuilder<'a> { +impl<'a> DisplayPowerInfoEXT<'a> { + #[inline] pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self { - self.inner.power_state = power_state; + self.power_state = power_state; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPowerInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceEventInfoEXT { +pub struct DeviceEventInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub device_event: DeviceEventTypeEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceEventInfoEXT { +impl ::std::default::Default for DeviceEventInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_EVENT_INFO_EXT, p_next: ::std::ptr::null(), device_event: DeviceEventTypeEXT::default(), + _marker: PhantomData, } } } -impl DeviceEventInfoEXT { - pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> { - DeviceEventInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceEventInfoEXTBuilder<'a> { - inner: DeviceEventInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { - type Target = DeviceEventInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceEventInfoEXTBuilder<'a> { +impl<'a> DeviceEventInfoEXT<'a> { + #[inline] pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self { - self.inner.device_event = device_event; + self.device_event = device_event; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceEventInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayEventInfoEXT { +pub struct DisplayEventInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub display_event: DisplayEventTypeEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayEventInfoEXT { +impl ::std::default::Default for DisplayEventInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_EVENT_INFO_EXT, p_next: ::std::ptr::null(), display_event: DisplayEventTypeEXT::default(), + _marker: PhantomData, } } } -impl DisplayEventInfoEXT { - pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> { - DisplayEventInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayEventInfoEXTBuilder<'a> { - inner: DisplayEventInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { - type Target = DisplayEventInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayEventInfoEXTBuilder<'a> { +impl<'a> DisplayEventInfoEXT<'a> { + #[inline] pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self { - self.inner.display_event = display_event; + self.display_event = display_event; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayEventInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SwapchainCounterCreateInfoEXT { +pub struct SwapchainCounterCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub surface_counters: SurfaceCounterFlagsEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SwapchainCounterCreateInfoEXT { +impl ::std::default::Default for SwapchainCounterCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT, p_next: ::std::ptr::null(), surface_counters: SurfaceCounterFlagsEXT::default(), + _marker: PhantomData, } } } -impl SwapchainCounterCreateInfoEXT { - pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> { - SwapchainCounterCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SwapchainCounterCreateInfoEXTBuilder<'a> { - inner: SwapchainCounterCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {} -impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> { - type Target = SwapchainCounterCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT<'_> {} +impl<'a> SwapchainCounterCreateInfoEXT<'a> { + #[inline] pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self { - self.inner.surface_counters = surface_counters; + self.surface_counters = surface_counters; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SwapchainCounterCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceGroupProperties { +pub struct PhysicalDeviceGroupProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub physical_device_count: u32, pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], pub subset_allocation: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceGroupProperties { +impl ::std::default::Default for PhysicalDeviceGroupProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES, @@ -17665,130 +12094,78 @@ impl ::std::default::Default for PhysicalDeviceGroupProperties { physical_device_count: u32::default(), physical_devices: unsafe { ::std::mem::zeroed() }, subset_allocation: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceGroupProperties { - pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> { - PhysicalDeviceGroupPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { - inner: PhysicalDeviceGroupProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { - type Target = PhysicalDeviceGroupProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { +impl<'a> PhysicalDeviceGroupProperties<'a> { + #[inline] pub fn physical_device_count(mut self, physical_device_count: u32) -> Self { - self.inner.physical_device_count = physical_device_count; + self.physical_device_count = physical_device_count; self } + #[inline] pub fn physical_devices( mut self, physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], ) -> Self { - self.inner.physical_devices = physical_devices; + self.physical_devices = physical_devices; self } + #[inline] pub fn subset_allocation(mut self, subset_allocation: bool) -> Self { - self.inner.subset_allocation = subset_allocation.into(); + self.subset_allocation = subset_allocation.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceGroupProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryAllocateFlagsInfo { +pub struct MemoryAllocateFlagsInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: MemoryAllocateFlags, pub device_mask: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryAllocateFlagsInfo { +impl ::std::default::Default for MemoryAllocateFlagsInfo<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO, p_next: ::std::ptr::null(), flags: MemoryAllocateFlags::default(), device_mask: u32::default(), + _marker: PhantomData, } } } -impl MemoryAllocateFlagsInfo { - pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> { - MemoryAllocateFlagsInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryAllocateFlagsInfoBuilder<'a> { - inner: MemoryAllocateFlagsInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {} -impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> { - type Target = MemoryAllocateFlagsInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryAllocateFlagsInfoBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo<'_> {} +impl<'a> MemoryAllocateFlagsInfo<'a> { + #[inline] pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn device_mask(mut self, device_mask: u32) -> Self { - self.inner.device_mask = device_mask; + self.device_mask = device_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryAllocateFlagsInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindBufferMemoryInfo { +pub struct BindBufferMemoryInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: Buffer, pub memory: DeviceMemory, pub memory_offset: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindBufferMemoryInfo { +impl ::std::default::Default for BindBufferMemoryInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_BUFFER_MEMORY_INFO, @@ -17796,139 +12173,86 @@ impl ::std::default::Default for BindBufferMemoryInfo { buffer: Buffer::default(), memory: DeviceMemory::default(), memory_offset: DeviceSize::default(), + _marker: PhantomData, } } } -impl BindBufferMemoryInfo { - pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> { - BindBufferMemoryInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindBufferMemoryInfoBuilder<'a> { - inner: BindBufferMemoryInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsBindBufferMemoryInfo {} -impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> { - type Target = BindBufferMemoryInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindBufferMemoryInfoBuilder<'a> { +impl<'a> BindBufferMemoryInfo<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { - self.inner.memory_offset = memory_offset; + self.memory_offset = memory_offset; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindBufferMemoryInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindBufferMemoryDeviceGroupInfo { +pub struct BindBufferMemoryDeviceGroupInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub device_index_count: u32, pub p_device_indices: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { +impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, p_next: ::std::ptr::null(), device_index_count: u32::default(), p_device_indices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl BindBufferMemoryDeviceGroupInfo { - pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { - BindBufferMemoryDeviceGroupInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> { - inner: BindBufferMemoryDeviceGroupInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {} -unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {} -impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { - type Target = BindBufferMemoryDeviceGroupInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo<'_> {} +impl<'a> BindBufferMemoryDeviceGroupInfo<'a> { + #[inline] pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { - self.inner.device_index_count = device_indices.len() as _; - self.inner.p_device_indices = device_indices.as_ptr(); + self.device_index_count = device_indices.len() as _; + self.p_device_indices = device_indices.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindBufferMemoryDeviceGroupInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindImageMemoryInfo { +pub struct BindImageMemoryInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, pub memory: DeviceMemory, pub memory_offset: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindImageMemoryInfo { +impl ::std::default::Default for BindImageMemoryInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_IMAGE_MEMORY_INFO, @@ -17936,81 +12260,56 @@ impl ::std::default::Default for BindImageMemoryInfo { image: Image::default(), memory: DeviceMemory::default(), memory_offset: DeviceSize::default(), + _marker: PhantomData, } } } -impl BindImageMemoryInfo { - pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> { - BindImageMemoryInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindImageMemoryInfoBuilder<'a> { - inner: BindImageMemoryInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsBindImageMemoryInfo {} -impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> { - type Target = BindImageMemoryInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindImageMemoryInfoBuilder<'a> { +impl<'a> BindImageMemoryInfo<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { - self.inner.memory_offset = memory_offset; + self.memory_offset = memory_offset; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindImageMemoryInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindImageMemoryDeviceGroupInfo { +pub struct BindImageMemoryDeviceGroupInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub device_index_count: u32, pub p_device_indices: *const u32, pub split_instance_bind_region_count: u32, pub p_split_instance_bind_regions: *const Rect2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { +impl ::std::default::Default for BindImageMemoryDeviceGroupInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, @@ -18019,68 +12318,41 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { p_device_indices: ::std::ptr::null(), split_instance_bind_region_count: u32::default(), p_split_instance_bind_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl BindImageMemoryDeviceGroupInfo { - pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> { - BindImageMemoryDeviceGroupInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> { - inner: BindImageMemoryDeviceGroupInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {} -impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { - type Target = BindImageMemoryDeviceGroupInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo<'_> {} +impl<'a> BindImageMemoryDeviceGroupInfo<'a> { + #[inline] pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { - self.inner.device_index_count = device_indices.len() as _; - self.inner.p_device_indices = device_indices.as_ptr(); + self.device_index_count = device_indices.len() as _; + self.p_device_indices = device_indices.as_ptr(); self } + #[inline] pub fn split_instance_bind_regions( mut self, split_instance_bind_regions: &'a [Rect2D], ) -> Self { - self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _; - self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr(); + self.split_instance_bind_region_count = split_instance_bind_regions.len() as _; + self.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindImageMemoryDeviceGroupInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupRenderPassBeginInfo { +pub struct DeviceGroupRenderPassBeginInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub device_mask: u32, pub device_render_area_count: u32, pub p_device_render_areas: *const Rect2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { +impl ::std::default::Default for DeviceGroupRenderPassBeginInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, @@ -18088,115 +12360,58 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { device_mask: u32::default(), device_render_area_count: u32::default(), p_device_render_areas: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DeviceGroupRenderPassBeginInfo { - pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> { - DeviceGroupRenderPassBeginInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> { - inner: DeviceGroupRenderPassBeginInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} -unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {} -unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} -unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {} -impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { - type Target = DeviceGroupRenderPassBeginInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo<'_> {} +unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo<'_> {} +impl<'a> DeviceGroupRenderPassBeginInfo<'a> { + #[inline] pub fn device_mask(mut self, device_mask: u32) -> Self { - self.inner.device_mask = device_mask; + self.device_mask = device_mask; self } + #[inline] pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self { - self.inner.device_render_area_count = device_render_areas.len() as _; - self.inner.p_device_render_areas = device_render_areas.as_ptr(); + self.device_render_area_count = device_render_areas.len() as _; + self.p_device_render_areas = device_render_areas.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupRenderPassBeginInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupCommandBufferBeginInfo { +pub struct DeviceGroupCommandBufferBeginInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub device_mask: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { +impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, p_next: ::std::ptr::null(), device_mask: u32::default(), + _marker: PhantomData, } } } -impl DeviceGroupCommandBufferBeginInfo { - pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> { - DeviceGroupCommandBufferBeginInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> { - inner: DeviceGroupCommandBufferBeginInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {} -unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {} -impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> { - type Target = DeviceGroupCommandBufferBeginInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> { +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo<'_> {} +impl<'a> DeviceGroupCommandBufferBeginInfo<'a> { + #[inline] pub fn device_mask(mut self, device_mask: u32) -> Self { - self.inner.device_mask = device_mask; + self.device_mask = device_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupCommandBufferBeginInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupSubmitInfo { +pub struct DeviceGroupSubmitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub wait_semaphore_count: u32, @@ -18205,8 +12420,9 @@ pub struct DeviceGroupSubmitInfo { pub p_command_buffer_device_masks: *const u32, pub signal_semaphore_count: u32, pub p_signal_semaphore_device_indices: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupSubmitInfo { +impl ::std::default::Default for DeviceGroupSubmitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO, @@ -18217,309 +12433,174 @@ impl ::std::default::Default for DeviceGroupSubmitInfo { p_command_buffer_device_masks: ::std::ptr::null(), signal_semaphore_count: u32::default(), p_signal_semaphore_device_indices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DeviceGroupSubmitInfo { - pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> { - DeviceGroupSubmitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupSubmitInfoBuilder<'a> { - inner: DeviceGroupSubmitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {} -impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { - type Target = DeviceGroupSubmitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupSubmitInfoBuilder<'a> { +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo<'_> {} +impl<'a> DeviceGroupSubmitInfo<'a> { + #[inline] pub fn wait_semaphore_device_indices( mut self, wait_semaphore_device_indices: &'a [u32], ) -> Self { - self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _; - self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr(); + self.wait_semaphore_count = wait_semaphore_device_indices.len() as _; + self.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr(); self } + #[inline] pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self { - self.inner.command_buffer_count = command_buffer_device_masks.len() as _; - self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr(); + self.command_buffer_count = command_buffer_device_masks.len() as _; + self.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr(); self } + #[inline] pub fn signal_semaphore_device_indices( mut self, signal_semaphore_device_indices: &'a [u32], ) -> Self { - self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _; - self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr(); + self.signal_semaphore_count = signal_semaphore_device_indices.len() as _; + self.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupSubmitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupBindSparseInfo { +pub struct DeviceGroupBindSparseInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub resource_device_index: u32, pub memory_device_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupBindSparseInfo { +impl ::std::default::Default for DeviceGroupBindSparseInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO, p_next: ::std::ptr::null(), resource_device_index: u32::default(), memory_device_index: u32::default(), + _marker: PhantomData, } } } -impl DeviceGroupBindSparseInfo { - pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> { - DeviceGroupBindSparseInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupBindSparseInfoBuilder<'a> { - inner: DeviceGroupBindSparseInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {} -unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {} -impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> { - type Target = DeviceGroupBindSparseInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupBindSparseInfoBuilder<'a> { +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo<'_> {} +impl<'a> DeviceGroupBindSparseInfo<'a> { + #[inline] pub fn resource_device_index(mut self, resource_device_index: u32) -> Self { - self.inner.resource_device_index = resource_device_index; + self.resource_device_index = resource_device_index; self } + #[inline] pub fn memory_device_index(mut self, memory_device_index: u32) -> Self { - self.inner.memory_device_index = memory_device_index; + self.memory_device_index = memory_device_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupBindSparseInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupPresentCapabilitiesKHR { +pub struct DeviceGroupPresentCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], pub modes: DeviceGroupPresentModeFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { +impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, p_next: ::std::ptr::null_mut(), present_mask: unsafe { ::std::mem::zeroed() }, modes: DeviceGroupPresentModeFlagsKHR::default(), + _marker: PhantomData, } } } -impl DeviceGroupPresentCapabilitiesKHR { - pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { - DeviceGroupPresentCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { - inner: DeviceGroupPresentCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { - type Target = DeviceGroupPresentCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { +impl<'a> DeviceGroupPresentCapabilitiesKHR<'a> { + #[inline] pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self { - self.inner.present_mask = present_mask; + self.present_mask = present_mask; self } + #[inline] pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self { - self.inner.modes = modes; + self.modes = modes; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageSwapchainCreateInfoKHR { +pub struct ImageSwapchainCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain: SwapchainKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageSwapchainCreateInfoKHR { +impl ::std::default::Default for ImageSwapchainCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR, p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), + _marker: PhantomData, } } } -impl ImageSwapchainCreateInfoKHR { - pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> { - ImageSwapchainCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageSwapchainCreateInfoKHRBuilder<'a> { - inner: ImageSwapchainCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {} -impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> { - type Target = ImageSwapchainCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR<'_> {} +impl<'a> ImageSwapchainCreateInfoKHR<'a> { + #[inline] pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { - self.inner.swapchain = swapchain; + self.swapchain = swapchain; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageSwapchainCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindImageMemorySwapchainInfoKHR { +pub struct BindImageMemorySwapchainInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain: SwapchainKHR, pub image_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { +impl ::std::default::Default for BindImageMemorySwapchainInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, p_next: ::std::ptr::null(), swapchain: SwapchainKHR::default(), image_index: u32::default(), + _marker: PhantomData, } } } -impl BindImageMemorySwapchainInfoKHR { - pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> { - BindImageMemorySwapchainInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> { - inner: BindImageMemorySwapchainInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {} -unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {} -impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> { - type Target = BindImageMemorySwapchainInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> { +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR<'_> {} +impl<'a> BindImageMemorySwapchainInfoKHR<'a> { + #[inline] pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { - self.inner.swapchain = swapchain; + self.swapchain = swapchain; self } + #[inline] pub fn image_index(mut self, image_index: u32) -> Self { - self.inner.image_index = image_index; + self.image_index = image_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindImageMemorySwapchainInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AcquireNextImageInfoKHR { +pub struct AcquireNextImageInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain: SwapchainKHR, @@ -18527,8 +12608,9 @@ pub struct AcquireNextImageInfoKHR { pub semaphore: Semaphore, pub fence: Fence, pub device_mask: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AcquireNextImageInfoKHR { +impl ::std::default::Default for AcquireNextImageInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR, @@ -18538,73 +12620,50 @@ impl ::std::default::Default for AcquireNextImageInfoKHR { semaphore: Semaphore::default(), fence: Fence::default(), device_mask: u32::default(), + _marker: PhantomData, } } } -impl AcquireNextImageInfoKHR { - pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> { - AcquireNextImageInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AcquireNextImageInfoKHRBuilder<'a> { - inner: AcquireNextImageInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { - type Target = AcquireNextImageInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AcquireNextImageInfoKHRBuilder<'a> { +impl<'a> AcquireNextImageInfoKHR<'a> { + #[inline] pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { - self.inner.swapchain = swapchain; + self.swapchain = swapchain; self } + #[inline] pub fn timeout(mut self, timeout: u64) -> Self { - self.inner.timeout = timeout; + self.timeout = timeout; self } + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn fence(mut self, fence: Fence) -> Self { - self.inner.fence = fence; + self.fence = fence; self } + #[inline] pub fn device_mask(mut self, device_mask: u32) -> Self { - self.inner.device_mask = device_mask; + self.device_mask = device_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AcquireNextImageInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupPresentInfoKHR { +pub struct DeviceGroupPresentInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain_count: u32, pub p_device_masks: *const u32, pub mode: DeviceGroupPresentModeFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupPresentInfoKHR { +impl ::std::default::Default for DeviceGroupPresentInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR, @@ -18612,166 +12671,82 @@ impl ::std::default::Default for DeviceGroupPresentInfoKHR { swapchain_count: u32::default(), p_device_masks: ::std::ptr::null(), mode: DeviceGroupPresentModeFlagsKHR::default(), + _marker: PhantomData, } } } -impl DeviceGroupPresentInfoKHR { - pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> { - DeviceGroupPresentInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupPresentInfoKHRBuilder<'a> { - inner: DeviceGroupPresentInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {} -unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {} -impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { - type Target = DeviceGroupPresentInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR<'_> {} +impl<'a> DeviceGroupPresentInfoKHR<'a> { + #[inline] pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self { - self.inner.swapchain_count = device_masks.len() as _; - self.inner.p_device_masks = device_masks.as_ptr(); + self.swapchain_count = device_masks.len() as _; + self.p_device_masks = device_masks.as_ptr(); self } + #[inline] pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self { - self.inner.mode = mode; + self.mode = mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupPresentInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupDeviceCreateInfo { +pub struct DeviceGroupDeviceCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub physical_device_count: u32, pub p_physical_devices: *const PhysicalDevice, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupDeviceCreateInfo { +impl ::std::default::Default for DeviceGroupDeviceCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO, p_next: ::std::ptr::null(), physical_device_count: u32::default(), p_physical_devices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DeviceGroupDeviceCreateInfo { - pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> { - DeviceGroupDeviceCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupDeviceCreateInfoBuilder<'a> { - inner: DeviceGroupDeviceCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {} -impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { - type Target = DeviceGroupDeviceCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo<'_> {} +impl<'a> DeviceGroupDeviceCreateInfo<'a> { + #[inline] pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self { - self.inner.physical_device_count = physical_devices.len() as _; - self.inner.p_physical_devices = physical_devices.as_ptr(); + self.physical_device_count = physical_devices.len() as _; + self.p_physical_devices = physical_devices.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupDeviceCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceGroupSwapchainCreateInfoKHR { +pub struct DeviceGroupSwapchainCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub modes: DeviceGroupPresentModeFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { +impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, p_next: ::std::ptr::null(), modes: DeviceGroupPresentModeFlagsKHR::default(), + _marker: PhantomData, } } } -impl DeviceGroupSwapchainCreateInfoKHR { - pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { - DeviceGroupSwapchainCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { - inner: DeviceGroupSwapchainCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {} -impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { - type Target = DeviceGroupSwapchainCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR<'_> {} +impl<'a> DeviceGroupSwapchainCreateInfoKHR<'a> { + #[inline] pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self { - self.inner.modes = modes; + self.modes = modes; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -18786,66 +12761,42 @@ pub struct DescriptorUpdateTemplateEntry { pub stride: usize, } impl DescriptorUpdateTemplateEntry { - pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> { - DescriptorUpdateTemplateEntryBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorUpdateTemplateEntryBuilder<'a> { - inner: DescriptorUpdateTemplateEntry, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> { - type Target = DescriptorUpdateTemplateEntry; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> { + #[inline] pub fn dst_binding(mut self, dst_binding: u32) -> Self { - self.inner.dst_binding = dst_binding; + self.dst_binding = dst_binding; self } + #[inline] pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { - self.inner.dst_array_element = dst_array_element; + self.dst_array_element = dst_array_element; self } + #[inline] pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { - self.inner.descriptor_count = descriptor_count; + self.descriptor_count = descriptor_count; self } + #[inline] pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { - self.inner.descriptor_type = descriptor_type; + self.descriptor_type = descriptor_type; self } + #[inline] pub fn offset(mut self, offset: usize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn stride(mut self, stride: usize) -> Self { - self.inner.stride = stride; + self.stride = stride; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorUpdateTemplateEntry { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorUpdateTemplateCreateInfo { +pub struct DescriptorUpdateTemplateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DescriptorUpdateTemplateCreateFlags, @@ -18856,8 +12807,9 @@ pub struct DescriptorUpdateTemplateCreateInfo { pub pipeline_bind_point: PipelineBindPoint, pub pipeline_layout: PipelineLayout, pub set: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { +impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, @@ -18870,72 +12822,50 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { pipeline_bind_point: PipelineBindPoint::default(), pipeline_layout: PipelineLayout::default(), set: u32::default(), + _marker: PhantomData, } } } -impl DescriptorUpdateTemplateCreateInfo { - pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { - DescriptorUpdateTemplateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { - inner: DescriptorUpdateTemplateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { - type Target = DescriptorUpdateTemplateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { +impl<'a> DescriptorUpdateTemplateCreateInfo<'a> { + #[inline] pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn descriptor_update_entries( mut self, descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], ) -> Self { - self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _; - self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr(); + self.descriptor_update_entry_count = descriptor_update_entries.len() as _; + self.p_descriptor_update_entries = descriptor_update_entries.as_ptr(); self } + #[inline] pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self { - self.inner.template_type = template_type; + self.template_type = template_type; self } + #[inline] pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { - self.inner.descriptor_set_layout = descriptor_set_layout; + self.descriptor_set_layout = descriptor_set_layout; self } + #[inline] pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { - self.inner.pipeline_bind_point = pipeline_bind_point; + self.pipeline_bind_point = pipeline_bind_point; self } + #[inline] pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self { - self.inner.pipeline_layout = pipeline_layout; + self.pipeline_layout = pipeline_layout; self } + #[inline] pub fn set(mut self, set: u32) -> Self { - self.inner.set = set; + self.set = set; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorUpdateTemplateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -18946,225 +12876,111 @@ pub struct XYColorEXT { pub y: f32, } impl XYColorEXT { - pub fn builder<'a>() -> XYColorEXTBuilder<'a> { - XYColorEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct XYColorEXTBuilder<'a> { - inner: XYColorEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> { - type Target = XYColorEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> XYColorEXTBuilder<'a> { + #[inline] pub fn x(mut self, x: f32) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: f32) -> Self { - self.inner.y = y; + self.y = y; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> XYColorEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePresentIdFeaturesKHR { +pub struct PhysicalDevicePresentIdFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub present_id: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR { +impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, p_next: ::std::ptr::null_mut(), present_id: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePresentIdFeaturesKHR { - pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { - PhysicalDevicePresentIdFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { - inner: PhysicalDevicePresentIdFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { - type Target = PhysicalDevicePresentIdFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR<'_> {} +impl<'a> PhysicalDevicePresentIdFeaturesKHR<'a> { + #[inline] pub fn present_id(mut self, present_id: bool) -> Self { - self.inner.present_id = present_id.into(); + self.present_id = present_id.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PresentIdKHR { +pub struct PresentIdKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain_count: u32, pub p_present_ids: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PresentIdKHR { +impl ::std::default::Default for PresentIdKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PRESENT_ID_KHR, p_next: ::std::ptr::null(), swapchain_count: u32::default(), p_present_ids: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PresentIdKHR { - pub fn builder<'a>() -> PresentIdKHRBuilder<'a> { - PresentIdKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentIdKHRBuilder<'a> { - inner: PresentIdKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {} -unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {} -impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> { - type Target = PresentIdKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentIdKHRBuilder<'a> { +unsafe impl ExtendsPresentInfoKHR for PresentIdKHR<'_> {} +impl<'a> PresentIdKHR<'a> { + #[inline] pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self { - self.inner.swapchain_count = present_ids.len() as _; - self.inner.p_present_ids = present_ids.as_ptr(); + self.swapchain_count = present_ids.len() as _; + self.p_present_ids = present_ids.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentIdKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePresentWaitFeaturesKHR { +pub struct PhysicalDevicePresentWaitFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub present_wait: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR { +impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, p_next: ::std::ptr::null_mut(), present_wait: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePresentWaitFeaturesKHR { - pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { - PhysicalDevicePresentWaitFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { - inner: PhysicalDevicePresentWaitFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { - type Target = PhysicalDevicePresentWaitFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR<'_> {} +impl<'a> PhysicalDevicePresentWaitFeaturesKHR<'a> { + #[inline] pub fn present_wait(mut self, present_wait: bool) -> Self { - self.inner.present_wait = present_wait.into(); + self.present_wait = present_wait.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct HdrMetadataEXT { +pub struct HdrMetadataEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub display_primary_red: XYColorEXT, @@ -19175,8 +12991,9 @@ pub struct HdrMetadataEXT { pub min_luminance: f32, pub max_content_light_level: f32, pub max_frame_average_light_level: f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for HdrMetadataEXT { +impl ::std::default::Default for HdrMetadataEXT<'_> { fn default() -> Self { Self { s_type: StructureType::HDR_METADATA_EXT, @@ -19189,184 +13006,107 @@ impl ::std::default::Default for HdrMetadataEXT { min_luminance: f32::default(), max_content_light_level: f32::default(), max_frame_average_light_level: f32::default(), + _marker: PhantomData, } } } -impl HdrMetadataEXT { - pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> { - HdrMetadataEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct HdrMetadataEXTBuilder<'a> { - inner: HdrMetadataEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { - type Target = HdrMetadataEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> HdrMetadataEXTBuilder<'a> { +impl<'a> HdrMetadataEXT<'a> { + #[inline] pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self { - self.inner.display_primary_red = display_primary_red; + self.display_primary_red = display_primary_red; self } + #[inline] pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self { - self.inner.display_primary_green = display_primary_green; + self.display_primary_green = display_primary_green; self } + #[inline] pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self { - self.inner.display_primary_blue = display_primary_blue; + self.display_primary_blue = display_primary_blue; self } + #[inline] pub fn white_point(mut self, white_point: XYColorEXT) -> Self { - self.inner.white_point = white_point; + self.white_point = white_point; self } + #[inline] pub fn max_luminance(mut self, max_luminance: f32) -> Self { - self.inner.max_luminance = max_luminance; + self.max_luminance = max_luminance; self } + #[inline] pub fn min_luminance(mut self, min_luminance: f32) -> Self { - self.inner.min_luminance = min_luminance; + self.min_luminance = min_luminance; self } + #[inline] pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self { - self.inner.max_content_light_level = max_content_light_level; + self.max_content_light_level = max_content_light_level; self } + #[inline] pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self { - self.inner.max_frame_average_light_level = max_frame_average_light_level; + self.max_frame_average_light_level = max_frame_average_light_level; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> HdrMetadataEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayNativeHdrSurfaceCapabilitiesAMD { +pub struct DisplayNativeHdrSurfaceCapabilitiesAMD<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub local_dimming_support: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD { +impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, p_next: ::std::ptr::null_mut(), local_dimming_support: Bool32::default(), + _marker: PhantomData, } } } -impl DisplayNativeHdrSurfaceCapabilitiesAMD { - pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { - DisplayNativeHdrSurfaceCapabilitiesAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { - inner: DisplayNativeHdrSurfaceCapabilitiesAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {} -unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {} -impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { - type Target = DisplayNativeHdrSurfaceCapabilitiesAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { +unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD<'_> {} +impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMD<'a> { + #[inline] pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self { - self.inner.local_dimming_support = local_dimming_support.into(); + self.local_dimming_support = local_dimming_support.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SwapchainDisplayNativeHdrCreateInfoAMD { +pub struct SwapchainDisplayNativeHdrCreateInfoAMD<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub local_dimming_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD { +impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD<'_> { fn default() -> Self { Self { s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, p_next: ::std::ptr::null(), local_dimming_enable: Bool32::default(), + _marker: PhantomData, } } } -impl SwapchainDisplayNativeHdrCreateInfoAMD { - pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { - SwapchainDisplayNativeHdrCreateInfoAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { - inner: SwapchainDisplayNativeHdrCreateInfoAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {} -impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { - type Target = SwapchainDisplayNativeHdrCreateInfoAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD<'_> {} +impl<'a> SwapchainDisplayNativeHdrCreateInfoAMD<'a> { + #[inline] pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self { - self.inner.local_dimming_enable = local_dimming_enable.into(); + self.local_dimming_enable = local_dimming_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -19376,40 +13116,11 @@ pub struct RefreshCycleDurationGOOGLE { pub refresh_duration: u64, } impl RefreshCycleDurationGOOGLE { - pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> { - RefreshCycleDurationGOOGLEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RefreshCycleDurationGOOGLEBuilder<'a> { - inner: RefreshCycleDurationGOOGLE, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> { - type Target = RefreshCycleDurationGOOGLE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> { + #[inline] pub fn refresh_duration(mut self, refresh_duration: u64) -> Self { - self.inner.refresh_duration = refresh_duration; + self.refresh_duration = refresh_duration; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RefreshCycleDurationGOOGLE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -19423,115 +13134,62 @@ pub struct PastPresentationTimingGOOGLE { pub present_margin: u64, } impl PastPresentationTimingGOOGLE { - pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> { - PastPresentationTimingGOOGLEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PastPresentationTimingGOOGLEBuilder<'a> { - inner: PastPresentationTimingGOOGLE, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> { - type Target = PastPresentationTimingGOOGLE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PastPresentationTimingGOOGLEBuilder<'a> { + #[inline] pub fn present_id(mut self, present_id: u32) -> Self { - self.inner.present_id = present_id; + self.present_id = present_id; self } + #[inline] pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { - self.inner.desired_present_time = desired_present_time; + self.desired_present_time = desired_present_time; self } + #[inline] pub fn actual_present_time(mut self, actual_present_time: u64) -> Self { - self.inner.actual_present_time = actual_present_time; + self.actual_present_time = actual_present_time; self } + #[inline] pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self { - self.inner.earliest_present_time = earliest_present_time; + self.earliest_present_time = earliest_present_time; self } + #[inline] pub fn present_margin(mut self, present_margin: u64) -> Self { - self.inner.present_margin = present_margin; + self.present_margin = present_margin; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PastPresentationTimingGOOGLE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PresentTimesInfoGOOGLE { +pub struct PresentTimesInfoGOOGLE<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub swapchain_count: u32, pub p_times: *const PresentTimeGOOGLE, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PresentTimesInfoGOOGLE { +impl ::std::default::Default for PresentTimesInfoGOOGLE<'_> { fn default() -> Self { Self { s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE, p_next: ::std::ptr::null(), swapchain_count: u32::default(), p_times: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PresentTimesInfoGOOGLE { - pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> { - PresentTimesInfoGOOGLEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentTimesInfoGOOGLEBuilder<'a> { - inner: PresentTimesInfoGOOGLE, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {} -unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {} -impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { - type Target = PresentTimesInfoGOOGLE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentTimesInfoGOOGLEBuilder<'a> { +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE<'_> {} +impl<'a> PresentTimesInfoGOOGLE<'a> { + #[inline] pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self { - self.inner.swapchain_count = times.len() as _; - self.inner.p_times = times.as_ptr(); + self.swapchain_count = times.len() as _; + self.p_times = times.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentTimesInfoGOOGLE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -19542,224 +13200,118 @@ pub struct PresentTimeGOOGLE { pub desired_present_time: u64, } impl PresentTimeGOOGLE { - pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> { - PresentTimeGOOGLEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentTimeGOOGLEBuilder<'a> { - inner: PresentTimeGOOGLE, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> { - type Target = PresentTimeGOOGLE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentTimeGOOGLEBuilder<'a> { + #[inline] pub fn present_id(mut self, present_id: u32) -> Self { - self.inner.present_id = present_id; + self.present_id = present_id; self } + #[inline] pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { - self.inner.desired_present_time = desired_present_time; + self.desired_present_time = desired_present_time; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentTimeGOOGLE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct IOSSurfaceCreateInfoMVK { +pub struct IOSSurfaceCreateInfoMVK<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: IOSSurfaceCreateFlagsMVK, pub p_view: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for IOSSurfaceCreateInfoMVK { +impl ::std::default::Default for IOSSurfaceCreateInfoMVK<'_> { fn default() -> Self { Self { s_type: StructureType::IOS_SURFACE_CREATE_INFO_MVK, p_next: ::std::ptr::null(), flags: IOSSurfaceCreateFlagsMVK::default(), p_view: ::std::ptr::null(), + _marker: PhantomData, } } } -impl IOSSurfaceCreateInfoMVK { - pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> { - IOSSurfaceCreateInfoMVKBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { - inner: IOSSurfaceCreateInfoMVK, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { - type Target = IOSSurfaceCreateInfoMVK; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { +impl<'a> IOSSurfaceCreateInfoMVK<'a> { + #[inline] pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn view(mut self, view: *const c_void) -> Self { - self.inner.p_view = view; + self.p_view = view; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> IOSSurfaceCreateInfoMVK { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MacOSSurfaceCreateInfoMVK { +pub struct MacOSSurfaceCreateInfoMVK<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: MacOSSurfaceCreateFlagsMVK, pub p_view: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { +impl ::std::default::Default for MacOSSurfaceCreateInfoMVK<'_> { fn default() -> Self { Self { s_type: StructureType::MACOS_SURFACE_CREATE_INFO_MVK, p_next: ::std::ptr::null(), flags: MacOSSurfaceCreateFlagsMVK::default(), p_view: ::std::ptr::null(), + _marker: PhantomData, } } } -impl MacOSSurfaceCreateInfoMVK { - pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> { - MacOSSurfaceCreateInfoMVKBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { - inner: MacOSSurfaceCreateInfoMVK, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { - type Target = MacOSSurfaceCreateInfoMVK; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { +impl<'a> MacOSSurfaceCreateInfoMVK<'a> { + #[inline] pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn view(mut self, view: *const c_void) -> Self { - self.inner.p_view = view; + self.p_view = view; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MacOSSurfaceCreateInfoMVK { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MetalSurfaceCreateInfoEXT { +pub struct MetalSurfaceCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: MetalSurfaceCreateFlagsEXT, pub p_layer: *const CAMetalLayer, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MetalSurfaceCreateInfoEXT { +impl ::std::default::Default for MetalSurfaceCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), flags: MetalSurfaceCreateFlagsEXT::default(), p_layer: ::std::ptr::null(), + _marker: PhantomData, } } } -impl MetalSurfaceCreateInfoEXT { - pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> { - MetalSurfaceCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MetalSurfaceCreateInfoEXTBuilder<'a> { - inner: MetalSurfaceCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> { - type Target = MetalSurfaceCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> { +impl<'a> MetalSurfaceCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn layer(mut self, layer: *const CAMetalLayer) -> Self { - self.inner.p_layer = layer; + self.p_layer = layer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MetalSurfaceCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -19770,57 +13322,30 @@ pub struct ViewportWScalingNV { pub ycoeff: f32, } impl ViewportWScalingNV { - pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> { - ViewportWScalingNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ViewportWScalingNVBuilder<'a> { - inner: ViewportWScalingNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> { - type Target = ViewportWScalingNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ViewportWScalingNVBuilder<'a> { + #[inline] pub fn xcoeff(mut self, xcoeff: f32) -> Self { - self.inner.xcoeff = xcoeff; + self.xcoeff = xcoeff; self } + #[inline] pub fn ycoeff(mut self, ycoeff: f32) -> Self { - self.inner.ycoeff = ycoeff; + self.ycoeff = ycoeff; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ViewportWScalingNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportWScalingStateCreateInfoNV { +pub struct PipelineViewportWScalingStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub viewport_w_scaling_enable: Bool32, pub viewport_count: u32, pub p_viewport_w_scalings: *const ViewportWScalingNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { +impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, @@ -19828,54 +13353,26 @@ impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { viewport_w_scaling_enable: Bool32::default(), viewport_count: u32::default(), p_viewport_w_scalings: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineViewportWScalingStateCreateInfoNV { - pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { - PipelineViewportWScalingStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { - inner: PipelineViewportWScalingStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportWScalingStateCreateInfoNVBuilder<'_> + for PipelineViewportWScalingStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {} -impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { - type Target = PipelineViewportWScalingStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineViewportWScalingStateCreateInfoNV<'a> { + #[inline] pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self { - self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into(); + self.viewport_w_scaling_enable = viewport_w_scaling_enable.into(); self } + #[inline] pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self { - self.inner.viewport_count = viewport_w_scalings.len() as _; - self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr(); + self.viewport_count = viewport_w_scalings.len() as _; + self.p_viewport_w_scalings = viewport_w_scalings.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -19888,65 +13385,40 @@ pub struct ViewportSwizzleNV { pub w: ViewportCoordinateSwizzleNV, } impl ViewportSwizzleNV { - pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> { - ViewportSwizzleNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ViewportSwizzleNVBuilder<'a> { - inner: ViewportSwizzleNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> { - type Target = ViewportSwizzleNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ViewportSwizzleNVBuilder<'a> { + #[inline] pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self { - self.inner.y = y; + self.y = y; self } + #[inline] pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self { - self.inner.z = z; + self.z = z; self } + #[inline] pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self { - self.inner.w = w; + self.w = w; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ViewportSwizzleNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportSwizzleStateCreateInfoNV { +pub struct PipelineViewportSwizzleStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineViewportSwizzleStateCreateFlagsNV, pub viewport_count: u32, pub p_viewport_swizzles: *const ViewportSwizzleNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { +impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, @@ -19954,127 +13426,69 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { flags: PipelineViewportSwizzleStateCreateFlagsNV::default(), viewport_count: u32::default(), p_viewport_swizzles: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineViewportSwizzleStateCreateInfoNV { - pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { - PipelineViewportSwizzleStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { - inner: PipelineViewportSwizzleStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_> + for PipelineViewportSwizzleStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {} -impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { - type Target = PipelineViewportSwizzleStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineViewportSwizzleStateCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self { - self.inner.viewport_count = viewport_swizzles.len() as _; - self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr(); + self.viewport_count = viewport_swizzles.len() as _; + self.p_viewport_swizzles = viewport_swizzles.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { +pub struct PhysicalDeviceDiscardRectanglePropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_discard_rectangles: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { +impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), max_discard_rectangles: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDiscardRectanglePropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { - PhysicalDeviceDiscardRectanglePropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { - inner: PhysicalDeviceDiscardRectanglePropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceDiscardRectanglePropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT<'_> {} +impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXT<'a> { + #[inline] pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self { - self.inner.max_discard_rectangles = max_discard_rectangles; + self.max_discard_rectangles = max_discard_rectangles; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineDiscardRectangleStateCreateInfoEXT { +pub struct PipelineDiscardRectangleStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineDiscardRectangleStateCreateFlagsEXT, pub discard_rectangle_mode: DiscardRectangleModeEXT, pub discard_rectangle_count: u32, pub p_discard_rectangles: *const Rect2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { +impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, @@ -20083,126 +13497,65 @@ impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { discard_rectangle_mode: DiscardRectangleModeEXT::default(), discard_rectangle_count: u32::default(), p_discard_rectangles: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineDiscardRectangleStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { - PipelineDiscardRectangleStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { - inner: PipelineDiscardRectangleStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsGraphicsPipelineCreateInfo - for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_> -{ -} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {} -impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { - type Target = PipelineDiscardRectangleStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT<'_> {} +impl<'a> PipelineDiscardRectangleStateCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn discard_rectangle_mode( mut self, discard_rectangle_mode: DiscardRectangleModeEXT, ) -> Self { - self.inner.discard_rectangle_mode = discard_rectangle_mode; + self.discard_rectangle_mode = discard_rectangle_mode; self } + #[inline] pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self { - self.inner.discard_rectangle_count = discard_rectangles.len() as _; - self.inner.p_discard_rectangles = discard_rectangles.as_ptr(); + self.discard_rectangle_count = discard_rectangles.len() as _; + self.p_discard_rectangles = discard_rectangles.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub per_view_position_all_components: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, p_next: ::std::ptr::null_mut(), per_view_position_all_components: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { - inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_> + for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX -{ -} -impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { - type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { +impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> { + #[inline] pub fn per_view_position_all_components( mut self, per_view_position_all_components: bool, ) -> Self { - self.inner.per_view_position_all_components = per_view_position_all_components.into(); + self.per_view_position_all_components = per_view_position_all_components.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -20214,657 +13567,360 @@ pub struct InputAttachmentAspectReference { pub aspect_mask: ImageAspectFlags, } impl InputAttachmentAspectReference { - pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> { - InputAttachmentAspectReferenceBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct InputAttachmentAspectReferenceBuilder<'a> { - inner: InputAttachmentAspectReference, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> { - type Target = InputAttachmentAspectReference; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> InputAttachmentAspectReferenceBuilder<'a> { + #[inline] pub fn subpass(mut self, subpass: u32) -> Self { - self.inner.subpass = subpass; + self.subpass = subpass; self } + #[inline] pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self { - self.inner.input_attachment_index = input_attachment_index; + self.input_attachment_index = input_attachment_index; self } + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> InputAttachmentAspectReference { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassInputAttachmentAspectCreateInfo { +pub struct RenderPassInputAttachmentAspectCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub aspect_reference_count: u32, pub p_aspect_references: *const InputAttachmentAspectReference, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { +impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, p_next: ::std::ptr::null(), aspect_reference_count: u32::default(), p_aspect_references: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassInputAttachmentAspectCreateInfo { - pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { - RenderPassInputAttachmentAspectCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { - inner: RenderPassInputAttachmentAspectCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {} -impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { - type Target = RenderPassInputAttachmentAspectCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo<'_> {} +impl<'a> RenderPassInputAttachmentAspectCreateInfo<'a> { + #[inline] pub fn aspect_references( mut self, aspect_references: &'a [InputAttachmentAspectReference], ) -> Self { - self.inner.aspect_reference_count = aspect_references.len() as _; - self.inner.p_aspect_references = aspect_references.as_ptr(); + self.aspect_reference_count = aspect_references.len() as _; + self.p_aspect_references = aspect_references.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSurfaceInfo2KHR { +pub struct PhysicalDeviceSurfaceInfo2KHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub surface: SurfaceKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { +impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, p_next: ::std::ptr::null(), surface: SurfaceKHR::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSurfaceInfo2KHR { - pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { - PhysicalDeviceSurfaceInfo2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { - inner: PhysicalDeviceSurfaceInfo2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { - type Target = PhysicalDeviceSurfaceInfo2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { +impl<'a> PhysicalDeviceSurfaceInfo2KHR<'a> { + #[inline] pub fn surface(mut self, surface: SurfaceKHR) -> Self { - self.inner.surface = surface; + self.surface = surface; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceCapabilities2KHR { +pub struct SurfaceCapabilities2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub surface_capabilities: SurfaceCapabilitiesKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceCapabilities2KHR { +impl ::std::default::Default for SurfaceCapabilities2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_CAPABILITIES_2_KHR, p_next: ::std::ptr::null_mut(), surface_capabilities: SurfaceCapabilitiesKHR::default(), + _marker: PhantomData, } } } -impl SurfaceCapabilities2KHR { - pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> { - SurfaceCapabilities2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceCapabilities2KHRBuilder<'a> { - inner: SurfaceCapabilities2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSurfaceCapabilities2KHR {} -impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> { - type Target = SurfaceCapabilities2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceCapabilities2KHRBuilder<'a> { +impl<'a> SurfaceCapabilities2KHR<'a> { + #[inline] pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self { - self.inner.surface_capabilities = surface_capabilities; + self.surface_capabilities = surface_capabilities; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceCapabilities2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceFormat2KHR { +pub struct SurfaceFormat2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub surface_format: SurfaceFormatKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceFormat2KHR { +impl ::std::default::Default for SurfaceFormat2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_FORMAT_2_KHR, p_next: ::std::ptr::null_mut(), surface_format: SurfaceFormatKHR::default(), + _marker: PhantomData, } } } -impl SurfaceFormat2KHR { - pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> { - SurfaceFormat2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceFormat2KHRBuilder<'a> { - inner: SurfaceFormat2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { - type Target = SurfaceFormat2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceFormat2KHRBuilder<'a> { +impl<'a> SurfaceFormat2KHR<'a> { + #[inline] pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self { - self.inner.surface_format = surface_format; + self.surface_format = surface_format; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceFormat2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayProperties2KHR { +pub struct DisplayProperties2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub display_properties: DisplayPropertiesKHR, + pub display_properties: DisplayPropertiesKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayProperties2KHR { +impl ::std::default::Default for DisplayProperties2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_PROPERTIES_2_KHR, p_next: ::std::ptr::null_mut(), display_properties: DisplayPropertiesKHR::default(), + _marker: PhantomData, } } } -impl DisplayProperties2KHR { - pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> { - DisplayProperties2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayProperties2KHRBuilder<'a> { - inner: DisplayProperties2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { - type Target = DisplayProperties2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayProperties2KHRBuilder<'a> { - pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self { - self.inner.display_properties = display_properties; +impl<'a> DisplayProperties2KHR<'a> { + #[inline] + pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR<'a>) -> Self { + self.display_properties = display_properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayProperties2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayPlaneProperties2KHR { +pub struct DisplayPlaneProperties2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub display_plane_properties: DisplayPlanePropertiesKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayPlaneProperties2KHR { +impl ::std::default::Default for DisplayPlaneProperties2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR, p_next: ::std::ptr::null_mut(), display_plane_properties: DisplayPlanePropertiesKHR::default(), + _marker: PhantomData, } } } -impl DisplayPlaneProperties2KHR { - pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> { - DisplayPlaneProperties2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPlaneProperties2KHRBuilder<'a> { - inner: DisplayPlaneProperties2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { - type Target = DisplayPlaneProperties2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { +impl<'a> DisplayPlaneProperties2KHR<'a> { + #[inline] pub fn display_plane_properties( mut self, display_plane_properties: DisplayPlanePropertiesKHR, ) -> Self { - self.inner.display_plane_properties = display_plane_properties; + self.display_plane_properties = display_plane_properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPlaneProperties2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayModeProperties2KHR { +pub struct DisplayModeProperties2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub display_mode_properties: DisplayModePropertiesKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayModeProperties2KHR { +impl ::std::default::Default for DisplayModeProperties2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR, p_next: ::std::ptr::null_mut(), display_mode_properties: DisplayModePropertiesKHR::default(), + _marker: PhantomData, } } } -impl DisplayModeProperties2KHR { - pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> { - DisplayModeProperties2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayModeProperties2KHRBuilder<'a> { - inner: DisplayModeProperties2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { - type Target = DisplayModeProperties2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayModeProperties2KHRBuilder<'a> { +impl<'a> DisplayModeProperties2KHR<'a> { + #[inline] pub fn display_mode_properties( mut self, display_mode_properties: DisplayModePropertiesKHR, ) -> Self { - self.inner.display_mode_properties = display_mode_properties; + self.display_mode_properties = display_mode_properties; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayModeProperties2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayPlaneInfo2KHR { +pub struct DisplayPlaneInfo2KHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub mode: DisplayModeKHR, pub plane_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayPlaneInfo2KHR { +impl ::std::default::Default for DisplayPlaneInfo2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR, p_next: ::std::ptr::null(), mode: DisplayModeKHR::default(), plane_index: u32::default(), + _marker: PhantomData, } } } -impl DisplayPlaneInfo2KHR { - pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> { - DisplayPlaneInfo2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPlaneInfo2KHRBuilder<'a> { - inner: DisplayPlaneInfo2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { - type Target = DisplayPlaneInfo2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { +impl<'a> DisplayPlaneInfo2KHR<'a> { + #[inline] pub fn mode(mut self, mode: DisplayModeKHR) -> Self { - self.inner.mode = mode; + self.mode = mode; self } + #[inline] pub fn plane_index(mut self, plane_index: u32) -> Self { - self.inner.plane_index = plane_index; + self.plane_index = plane_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPlaneInfo2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DisplayPlaneCapabilities2KHR { +pub struct DisplayPlaneCapabilities2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub capabilities: DisplayPlaneCapabilitiesKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DisplayPlaneCapabilities2KHR { +impl ::std::default::Default for DisplayPlaneCapabilities2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR, p_next: ::std::ptr::null_mut(), capabilities: DisplayPlaneCapabilitiesKHR::default(), + _marker: PhantomData, } } } -impl DisplayPlaneCapabilities2KHR { - pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> { - DisplayPlaneCapabilities2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { - inner: DisplayPlaneCapabilities2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { - type Target = DisplayPlaneCapabilities2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { +impl<'a> DisplayPlaneCapabilities2KHR<'a> { + #[inline] pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self { - self.inner.capabilities = capabilities; + self.capabilities = capabilities; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DisplayPlaneCapabilities2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SharedPresentSurfaceCapabilitiesKHR { +pub struct SharedPresentSurfaceCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shared_present_supported_usage_flags: ImageUsageFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { +impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, p_next: ::std::ptr::null_mut(), shared_present_supported_usage_flags: ImageUsageFlags::default(), + _marker: PhantomData, } } } -impl SharedPresentSurfaceCapabilitiesKHR { - pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { - SharedPresentSurfaceCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { - inner: SharedPresentSurfaceCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {} -unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {} -impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { - type Target = SharedPresentSurfaceCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR<'_> {} +impl<'a> SharedPresentSurfaceCapabilitiesKHR<'a> { + #[inline] pub fn shared_present_supported_usage_flags( mut self, shared_present_supported_usage_flags: ImageUsageFlags, ) -> Self { - self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags; + self.shared_present_supported_usage_flags = shared_present_supported_usage_flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevice16BitStorageFeatures { +pub struct PhysicalDevice16BitStorageFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub storage_buffer16_bit_access: Bool32, pub uniform_and_storage_buffer16_bit_access: Bool32, pub storage_push_constant16: Bool32, pub storage_input_output16: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { +impl ::std::default::Default for PhysicalDevice16BitStorageFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, @@ -20873,78 +13929,52 @@ impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { uniform_and_storage_buffer16_bit_access: Bool32::default(), storage_push_constant16: Bool32::default(), storage_input_output16: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevice16BitStorageFeatures { - pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { - PhysicalDevice16BitStorageFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { - inner: PhysicalDevice16BitStorageFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { - type Target = PhysicalDevice16BitStorageFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures<'_> {} +impl<'a> PhysicalDevice16BitStorageFeatures<'a> { + #[inline] pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self { - self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); self } + #[inline] pub fn uniform_and_storage_buffer16_bit_access( mut self, uniform_and_storage_buffer16_bit_access: bool, ) -> Self { - self.inner.uniform_and_storage_buffer16_bit_access = + self.uniform_and_storage_buffer16_bit_access = uniform_and_storage_buffer16_bit_access.into(); self } + #[inline] pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { - self.inner.storage_push_constant16 = storage_push_constant16.into(); + self.storage_push_constant16 = storage_push_constant16.into(); self } + #[inline] pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { - self.inner.storage_input_output16 = storage_input_output16.into(); + self.storage_input_output16 = storage_input_output16.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevice16BitStorageFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSubgroupProperties { +pub struct PhysicalDeviceSubgroupProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub subgroup_size: u32, pub supported_stages: ShaderStageFlags, pub supported_operations: SubgroupFeatureFlags, pub quad_operations_in_all_stages: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSubgroupProperties { +impl ::std::default::Default for PhysicalDeviceSubgroupProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, @@ -20953,904 +13983,488 @@ impl ::std::default::Default for PhysicalDeviceSubgroupProperties { supported_stages: ShaderStageFlags::default(), supported_operations: SubgroupFeatureFlags::default(), quad_operations_in_all_stages: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSubgroupProperties { - pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { - PhysicalDeviceSubgroupPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> { - inner: PhysicalDeviceSubgroupProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> { - type Target = PhysicalDeviceSubgroupProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties<'_> {} +impl<'a> PhysicalDeviceSubgroupProperties<'a> { + #[inline] pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { - self.inner.subgroup_size = subgroup_size; + self.subgroup_size = subgroup_size; self } + #[inline] pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self { - self.inner.supported_stages = supported_stages; + self.supported_stages = supported_stages; self } + #[inline] pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self { - self.inner.supported_operations = supported_operations; + self.supported_operations = supported_operations; self } + #[inline] pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self { - self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into(); + self.quad_operations_in_all_stages = quad_operations_in_all_stages.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSubgroupProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures { +pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_subgroup_extended_types: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures { +impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, p_next: ::std::ptr::null_mut(), shader_subgroup_extended_types: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures { - pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { - PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { - inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> + for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'_> {} +impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> { + #[inline] pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self { - self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferMemoryRequirementsInfo2 { +pub struct BufferMemoryRequirementsInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferMemoryRequirementsInfo2 { +impl ::std::default::Default for BufferMemoryRequirementsInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2, p_next: ::std::ptr::null(), buffer: Buffer::default(), + _marker: PhantomData, } } } -impl BufferMemoryRequirementsInfo2 { - pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> { - BufferMemoryRequirementsInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferMemoryRequirementsInfo2Builder<'a> { - inner: BufferMemoryRequirementsInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { - type Target = BufferMemoryRequirementsInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { +impl<'a> BufferMemoryRequirementsInfo2<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferMemoryRequirementsInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceBufferMemoryRequirements { +pub struct DeviceBufferMemoryRequirements<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_create_info: *const BufferCreateInfo, + pub p_create_info: *const BufferCreateInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceBufferMemoryRequirements { +impl ::std::default::Default for DeviceBufferMemoryRequirements<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS, p_next: ::std::ptr::null(), p_create_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DeviceBufferMemoryRequirements { - pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> { - DeviceBufferMemoryRequirementsBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceBufferMemoryRequirementsBuilder<'a> { - inner: DeviceBufferMemoryRequirements, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> { - type Target = DeviceBufferMemoryRequirements; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> { - pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self { - self.inner.p_create_info = create_info; +impl<'a> DeviceBufferMemoryRequirements<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a BufferCreateInfo<'a>) -> Self { + self.p_create_info = create_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceBufferMemoryRequirements { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageMemoryRequirementsInfo2 { +pub struct ImageMemoryRequirementsInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageMemoryRequirementsInfo2 { +impl ::std::default::Default for ImageMemoryRequirementsInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2, p_next: ::std::ptr::null(), image: Image::default(), + _marker: PhantomData, } } } -impl ImageMemoryRequirementsInfo2 { - pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> { - ImageMemoryRequirementsInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageMemoryRequirementsInfo2Builder<'a> { - inner: ImageMemoryRequirementsInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {} -impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> { - type Target = ImageMemoryRequirementsInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { +impl<'a> ImageMemoryRequirementsInfo2<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageMemoryRequirementsInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageSparseMemoryRequirementsInfo2 { +pub struct ImageSparseMemoryRequirementsInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { +impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, p_next: ::std::ptr::null(), image: Image::default(), + _marker: PhantomData, } } } -impl ImageSparseMemoryRequirementsInfo2 { - pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> { - ImageSparseMemoryRequirementsInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { - inner: ImageSparseMemoryRequirementsInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { - type Target = ImageSparseMemoryRequirementsInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { +impl<'a> ImageSparseMemoryRequirementsInfo2<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceImageMemoryRequirements { +pub struct DeviceImageMemoryRequirements<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_create_info: *const ImageCreateInfo, + pub p_create_info: *const ImageCreateInfo<'a>, pub plane_aspect: ImageAspectFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceImageMemoryRequirements { +impl ::std::default::Default for DeviceImageMemoryRequirements<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS, p_next: ::std::ptr::null(), p_create_info: ::std::ptr::null(), plane_aspect: ImageAspectFlags::default(), + _marker: PhantomData, } } } -impl DeviceImageMemoryRequirements { - pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> { - DeviceImageMemoryRequirementsBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceImageMemoryRequirementsBuilder<'a> { - inner: DeviceImageMemoryRequirements, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> { - type Target = DeviceImageMemoryRequirements; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceImageMemoryRequirementsBuilder<'a> { - pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self { - self.inner.p_create_info = create_info; +impl<'a> DeviceImageMemoryRequirements<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a ImageCreateInfo<'a>) -> Self { + self.p_create_info = create_info; self } + #[inline] pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { - self.inner.plane_aspect = plane_aspect; + self.plane_aspect = plane_aspect; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceImageMemoryRequirements { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryRequirements2 { +pub struct MemoryRequirements2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_requirements: MemoryRequirements, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryRequirements2 { +impl ::std::default::Default for MemoryRequirements2<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_REQUIREMENTS_2, p_next: ::std::ptr::null_mut(), memory_requirements: MemoryRequirements::default(), + _marker: PhantomData, } } } -impl MemoryRequirements2 { - pub fn builder<'a>() -> MemoryRequirements2Builder<'a> { - MemoryRequirements2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryRequirements2Builder<'a> { - inner: MemoryRequirements2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsMemoryRequirements2 {} -impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> { - type Target = MemoryRequirements2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryRequirements2Builder<'a> { +impl<'a> MemoryRequirements2<'a> { + #[inline] pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self { - self.inner.memory_requirements = memory_requirements; + self.memory_requirements = memory_requirements; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryRequirements2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SparseImageMemoryRequirements2 { +pub struct SparseImageMemoryRequirements2<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_requirements: SparseImageMemoryRequirements, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SparseImageMemoryRequirements2 { +impl ::std::default::Default for SparseImageMemoryRequirements2<'_> { fn default() -> Self { Self { s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, p_next: ::std::ptr::null_mut(), memory_requirements: SparseImageMemoryRequirements::default(), + _marker: PhantomData, } } } -impl SparseImageMemoryRequirements2 { - pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> { - SparseImageMemoryRequirements2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SparseImageMemoryRequirements2Builder<'a> { - inner: SparseImageMemoryRequirements2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { - type Target = SparseImageMemoryRequirements2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SparseImageMemoryRequirements2Builder<'a> { +impl<'a> SparseImageMemoryRequirements2<'a> { + #[inline] pub fn memory_requirements( mut self, memory_requirements: SparseImageMemoryRequirements, ) -> Self { - self.inner.memory_requirements = memory_requirements; + self.memory_requirements = memory_requirements; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SparseImageMemoryRequirements2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePointClippingProperties { +pub struct PhysicalDevicePointClippingProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub point_clipping_behavior: PointClippingBehavior, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePointClippingProperties { +impl ::std::default::Default for PhysicalDevicePointClippingProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, p_next: ::std::ptr::null_mut(), point_clipping_behavior: PointClippingBehavior::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePointClippingProperties { - pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> { - PhysicalDevicePointClippingPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> { - inner: PhysicalDevicePointClippingProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {} -impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> { - type Target = PhysicalDevicePointClippingProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties<'_> {} +impl<'a> PhysicalDevicePointClippingProperties<'a> { + #[inline] pub fn point_clipping_behavior( mut self, point_clipping_behavior: PointClippingBehavior, ) -> Self { - self.inner.point_clipping_behavior = point_clipping_behavior; + self.point_clipping_behavior = point_clipping_behavior; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePointClippingProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryDedicatedRequirements { +pub struct MemoryDedicatedRequirements<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub prefers_dedicated_allocation: Bool32, pub requires_dedicated_allocation: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryDedicatedRequirements { +impl ::std::default::Default for MemoryDedicatedRequirements<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS, p_next: ::std::ptr::null_mut(), prefers_dedicated_allocation: Bool32::default(), requires_dedicated_allocation: Bool32::default(), + _marker: PhantomData, } } } -impl MemoryDedicatedRequirements { - pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> { - MemoryDedicatedRequirementsBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryDedicatedRequirementsBuilder<'a> { - inner: MemoryDedicatedRequirements, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {} -unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {} -impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> { - type Target = MemoryDedicatedRequirements; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryDedicatedRequirementsBuilder<'a> { +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements<'_> {} +impl<'a> MemoryDedicatedRequirements<'a> { + #[inline] pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self { - self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into(); + self.prefers_dedicated_allocation = prefers_dedicated_allocation.into(); self } + #[inline] pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self { - self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into(); + self.requires_dedicated_allocation = requires_dedicated_allocation.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryDedicatedRequirements { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryDedicatedAllocateInfo { +pub struct MemoryDedicatedAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image: Image, pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryDedicatedAllocateInfo { +impl ::std::default::Default for MemoryDedicatedAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO, p_next: ::std::ptr::null(), image: Image::default(), buffer: Buffer::default(), + _marker: PhantomData, } } } -impl MemoryDedicatedAllocateInfo { - pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> { - MemoryDedicatedAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryDedicatedAllocateInfoBuilder<'a> { - inner: MemoryDedicatedAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {} -impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> { - type Target = MemoryDedicatedAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo<'_> {} +impl<'a> MemoryDedicatedAllocateInfo<'a> { + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryDedicatedAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageViewUsageCreateInfo { +pub struct ImageViewUsageCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub usage: ImageUsageFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageViewUsageCreateInfo { +impl ::std::default::Default for ImageViewUsageCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO, p_next: ::std::ptr::null(), usage: ImageUsageFlags::default(), + _marker: PhantomData, } } } -impl ImageViewUsageCreateInfo { - pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> { - ImageViewUsageCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageViewUsageCreateInfoBuilder<'a> { - inner: ImageViewUsageCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {} -impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> { - type Target = ImageViewUsageCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageViewUsageCreateInfoBuilder<'a> { +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo<'_> {} +impl<'a> ImageViewUsageCreateInfo<'a> { + #[inline] pub fn usage(mut self, usage: ImageUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageViewUsageCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineTessellationDomainOriginStateCreateInfo { +pub struct PipelineTessellationDomainOriginStateCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub domain_origin: TessellationDomainOrigin, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo { +impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, p_next: ::std::ptr::null(), domain_origin: TessellationDomainOrigin::default(), + _marker: PhantomData, } } } -impl PipelineTessellationDomainOriginStateCreateInfo { - pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { - PipelineTessellationDomainOriginStateCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { - inner: PipelineTessellationDomainOriginStateCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineTessellationStateCreateInfo - for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_> + for PipelineTessellationDomainOriginStateCreateInfo<'_> { } -unsafe impl ExtendsPipelineTessellationStateCreateInfo - for PipelineTessellationDomainOriginStateCreateInfo -{ -} -impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { - type Target = PipelineTessellationDomainOriginStateCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { +impl<'a> PipelineTessellationDomainOriginStateCreateInfo<'a> { + #[inline] pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self { - self.inner.domain_origin = domain_origin; + self.domain_origin = domain_origin; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerYcbcrConversionInfo { +pub struct SamplerYcbcrConversionInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub conversion: SamplerYcbcrConversion, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SamplerYcbcrConversionInfo { +impl ::std::default::Default for SamplerYcbcrConversionInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO, p_next: ::std::ptr::null(), conversion: SamplerYcbcrConversion::default(), + _marker: PhantomData, } } } -impl SamplerYcbcrConversionInfo { - pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> { - SamplerYcbcrConversionInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerYcbcrConversionInfoBuilder<'a> { - inner: SamplerYcbcrConversionInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} -unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {} -unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {} -impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { - type Target = SamplerYcbcrConversionInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerYcbcrConversionInfoBuilder<'a> { +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo<'_> {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo<'_> {} +impl<'a> SamplerYcbcrConversionInfo<'a> { + #[inline] pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self { - self.inner.conversion = conversion; + self.conversion = conversion; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerYcbcrConversionInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerYcbcrConversionCreateInfo { +pub struct SamplerYcbcrConversionCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub format: Format, @@ -21861,8 +14475,9 @@ pub struct SamplerYcbcrConversionCreateInfo { pub y_chroma_offset: ChromaLocation, pub chroma_filter: Filter, pub force_explicit_reconstruction: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { +impl ::std::default::Default for SamplerYcbcrConversionCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO, @@ -21875,71 +14490,56 @@ impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { y_chroma_offset: ChromaLocation::default(), chroma_filter: Filter::default(), force_explicit_reconstruction: Bool32::default(), + _marker: PhantomData, } } } -impl SamplerYcbcrConversionCreateInfo { - pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> { - SamplerYcbcrConversionCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> { - inner: SamplerYcbcrConversionCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {} -impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> { - type Target = SamplerYcbcrConversionCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { +impl<'a> SamplerYcbcrConversionCreateInfo<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self { - self.inner.ycbcr_model = ycbcr_model; + self.ycbcr_model = ycbcr_model; self } + #[inline] pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self { - self.inner.ycbcr_range = ycbcr_range; + self.ycbcr_range = ycbcr_range; self } + #[inline] pub fn components(mut self, components: ComponentMapping) -> Self { - self.inner.components = components; + self.components = components; self } + #[inline] pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self { - self.inner.x_chroma_offset = x_chroma_offset; + self.x_chroma_offset = x_chroma_offset; self } + #[inline] pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self { - self.inner.y_chroma_offset = y_chroma_offset; + self.y_chroma_offset = y_chroma_offset; self } + #[inline] pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self { - self.inner.chroma_filter = chroma_filter; + self.chroma_filter = chroma_filter; self } + #[inline] pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self { - self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into(); + self.force_explicit_reconstruction = force_explicit_reconstruction.into(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -21948,326 +14548,172 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerYcbcrConversionCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindImagePlaneMemoryInfo { +pub struct BindImagePlaneMemoryInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub plane_aspect: ImageAspectFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindImagePlaneMemoryInfo { +impl ::std::default::Default for BindImagePlaneMemoryInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO, p_next: ::std::ptr::null(), plane_aspect: ImageAspectFlags::default(), + _marker: PhantomData, } } } -impl BindImagePlaneMemoryInfo { - pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> { - BindImagePlaneMemoryInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindImagePlaneMemoryInfoBuilder<'a> { - inner: BindImagePlaneMemoryInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {} -unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {} -impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> { - type Target = BindImagePlaneMemoryInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindImagePlaneMemoryInfoBuilder<'a> { +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo<'_> {} +impl<'a> BindImagePlaneMemoryInfo<'a> { + #[inline] pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { - self.inner.plane_aspect = plane_aspect; + self.plane_aspect = plane_aspect; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindImagePlaneMemoryInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImagePlaneMemoryRequirementsInfo { +pub struct ImagePlaneMemoryRequirementsInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub plane_aspect: ImageAspectFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { +impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, p_next: ::std::ptr::null(), plane_aspect: ImageAspectFlags::default(), + _marker: PhantomData, } } } -impl ImagePlaneMemoryRequirementsInfo { - pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> { - ImagePlaneMemoryRequirementsInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> { - inner: ImagePlaneMemoryRequirementsInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {} -unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {} -impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> { - type Target = ImagePlaneMemoryRequirementsInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> { +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo<'_> {} +impl<'a> ImagePlaneMemoryRequirementsInfo<'a> { + #[inline] pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { - self.inner.plane_aspect = plane_aspect; + self.plane_aspect = plane_aspect; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImagePlaneMemoryRequirementsInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { +pub struct PhysicalDeviceSamplerYcbcrConversionFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub sampler_ycbcr_conversion: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { +impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, p_next: ::std::ptr::null_mut(), sampler_ycbcr_conversion: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSamplerYcbcrConversionFeatures { - pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { - PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { - inner: PhysicalDeviceSamplerYcbcrConversionFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { - type Target = PhysicalDeviceSamplerYcbcrConversionFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures<'_> {} +impl<'a> PhysicalDeviceSamplerYcbcrConversionFeatures<'a> { + #[inline] pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self { - self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerYcbcrConversionImageFormatProperties { +pub struct SamplerYcbcrConversionImageFormatProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub combined_image_sampler_descriptor_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { +impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, p_next: ::std::ptr::null_mut(), combined_image_sampler_descriptor_count: u32::default(), + _marker: PhantomData, } } } -impl SamplerYcbcrConversionImageFormatProperties { - pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { - SamplerYcbcrConversionImageFormatPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { - inner: SamplerYcbcrConversionImageFormatProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageFormatProperties2 - for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {} -impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { - type Target = SamplerYcbcrConversionImageFormatProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { +unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties<'_> {} +impl<'a> SamplerYcbcrConversionImageFormatProperties<'a> { + #[inline] pub fn combined_image_sampler_descriptor_count( mut self, combined_image_sampler_descriptor_count: u32, ) -> Self { - self.inner.combined_image_sampler_descriptor_count = - combined_image_sampler_descriptor_count; + self.combined_image_sampler_descriptor_count = combined_image_sampler_descriptor_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct TextureLODGatherFormatPropertiesAMD { +pub struct TextureLODGatherFormatPropertiesAMD<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub supports_texture_gather_lod_bias_amd: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { +impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD<'_> { fn default() -> Self { Self { s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, p_next: ::std::ptr::null_mut(), supports_texture_gather_lod_bias_amd: Bool32::default(), + _marker: PhantomData, } } } -impl TextureLODGatherFormatPropertiesAMD { - pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> { - TextureLODGatherFormatPropertiesAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> { - inner: TextureLODGatherFormatPropertiesAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {} -unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {} -impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> { - type Target = TextureLODGatherFormatPropertiesAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> { +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD<'_> {} +impl<'a> TextureLODGatherFormatPropertiesAMD<'a> { + #[inline] pub fn supports_texture_gather_lod_bias_amd( mut self, supports_texture_gather_lod_bias_amd: bool, ) -> Self { - self.inner.supports_texture_gather_lod_bias_amd = - supports_texture_gather_lod_bias_amd.into(); + self.supports_texture_gather_lod_bias_amd = supports_texture_gather_lod_bias_amd.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> TextureLODGatherFormatPropertiesAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ConditionalRenderingBeginInfoEXT { +pub struct ConditionalRenderingBeginInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: Buffer, pub offset: DeviceSize, pub flags: ConditionalRenderingFlagsEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ConditionalRenderingBeginInfoEXT { +impl ::std::default::Default for ConditionalRenderingBeginInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT, @@ -22275,238 +14721,125 @@ impl ::std::default::Default for ConditionalRenderingBeginInfoEXT { buffer: Buffer::default(), offset: DeviceSize::default(), flags: ConditionalRenderingFlagsEXT::default(), + _marker: PhantomData, } } } -impl ConditionalRenderingBeginInfoEXT { - pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> { - ConditionalRenderingBeginInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> { - inner: ConditionalRenderingBeginInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> { - type Target = ConditionalRenderingBeginInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { +impl<'a> ConditionalRenderingBeginInfoEXT<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ConditionalRenderingBeginInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ProtectedSubmitInfo { +pub struct ProtectedSubmitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub protected_submit: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ProtectedSubmitInfo { +impl ::std::default::Default for ProtectedSubmitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PROTECTED_SUBMIT_INFO, p_next: ::std::ptr::null(), protected_submit: Bool32::default(), + _marker: PhantomData, } } } -impl ProtectedSubmitInfo { - pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> { - ProtectedSubmitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ProtectedSubmitInfoBuilder<'a> { - inner: ProtectedSubmitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {} -impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> { - type Target = ProtectedSubmitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ProtectedSubmitInfoBuilder<'a> { +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo<'_> {} +impl<'a> ProtectedSubmitInfo<'a> { + #[inline] pub fn protected_submit(mut self, protected_submit: bool) -> Self { - self.inner.protected_submit = protected_submit.into(); + self.protected_submit = protected_submit.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ProtectedSubmitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceProtectedMemoryFeatures { +pub struct PhysicalDeviceProtectedMemoryFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub protected_memory: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { +impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, p_next: ::std::ptr::null_mut(), protected_memory: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceProtectedMemoryFeatures { - pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { - PhysicalDeviceProtectedMemoryFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { - inner: PhysicalDeviceProtectedMemoryFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { - type Target = PhysicalDeviceProtectedMemoryFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures<'_> {} +impl<'a> PhysicalDeviceProtectedMemoryFeatures<'a> { + #[inline] pub fn protected_memory(mut self, protected_memory: bool) -> Self { - self.inner.protected_memory = protected_memory.into(); + self.protected_memory = protected_memory.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceProtectedMemoryProperties { +pub struct PhysicalDeviceProtectedMemoryProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub protected_no_fault: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { +impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, p_next: ::std::ptr::null_mut(), protected_no_fault: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceProtectedMemoryProperties { - pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { - PhysicalDeviceProtectedMemoryPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { - inner: PhysicalDeviceProtectedMemoryProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { - type Target = PhysicalDeviceProtectedMemoryProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties<'_> {} +impl<'a> PhysicalDeviceProtectedMemoryProperties<'a> { + #[inline] pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { - self.inner.protected_no_fault = protected_no_fault.into(); + self.protected_no_fault = protected_no_fault.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceQueueInfo2 { +pub struct DeviceQueueInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceQueueCreateFlags, pub queue_family_index: u32, pub queue_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceQueueInfo2 { +impl ::std::default::Default for DeviceQueueInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_QUEUE_INFO_2, @@ -22514,65 +14847,40 @@ impl ::std::default::Default for DeviceQueueInfo2 { flags: DeviceQueueCreateFlags::default(), queue_family_index: u32::default(), queue_index: u32::default(), + _marker: PhantomData, } } } -impl DeviceQueueInfo2 { - pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> { - DeviceQueueInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceQueueInfo2Builder<'a> { - inner: DeviceQueueInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { - type Target = DeviceQueueInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceQueueInfo2Builder<'a> { +impl<'a> DeviceQueueInfo2<'a> { + #[inline] pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { - self.inner.queue_family_index = queue_family_index; + self.queue_family_index = queue_family_index; self } + #[inline] pub fn queue_index(mut self, queue_index: u32) -> Self { - self.inner.queue_index = queue_index; + self.queue_index = queue_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceQueueInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineCoverageToColorStateCreateInfoNV { +pub struct PipelineCoverageToColorStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCoverageToColorStateCreateFlagsNV, pub coverage_to_color_enable: Bool32, pub coverage_to_color_location: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { +impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, @@ -22580,130 +14888,71 @@ impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { flags: PipelineCoverageToColorStateCreateFlagsNV::default(), coverage_to_color_enable: Bool32::default(), coverage_to_color_location: u32::default(), + _marker: PhantomData, } } } -impl PipelineCoverageToColorStateCreateInfoNV { - pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { - PipelineCoverageToColorStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { - inner: PipelineCoverageToColorStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineCoverageToColorStateCreateInfoNVBuilder<'_> + for PipelineCoverageToColorStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {} -impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { - type Target = PipelineCoverageToColorStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineCoverageToColorStateCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self { - self.inner.coverage_to_color_enable = coverage_to_color_enable.into(); + self.coverage_to_color_enable = coverage_to_color_enable.into(); self } + #[inline] pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self { - self.inner.coverage_to_color_location = coverage_to_color_location; + self.coverage_to_color_location = coverage_to_color_location; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSamplerFilterMinmaxProperties { +pub struct PhysicalDeviceSamplerFilterMinmaxProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub filter_minmax_single_component_formats: Bool32, pub filter_minmax_image_component_mapping: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties { +impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, p_next: ::std::ptr::null_mut(), filter_minmax_single_component_formats: Bool32::default(), filter_minmax_image_component_mapping: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSamplerFilterMinmaxProperties { - pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { - PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { - inner: PhysicalDeviceSamplerFilterMinmaxProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { - type Target = PhysicalDeviceSamplerFilterMinmaxProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties<'_> {} +impl<'a> PhysicalDeviceSamplerFilterMinmaxProperties<'a> { + #[inline] pub fn filter_minmax_single_component_formats( mut self, filter_minmax_single_component_formats: bool, ) -> Self { - self.inner.filter_minmax_single_component_formats = - filter_minmax_single_component_formats.into(); + self.filter_minmax_single_component_formats = filter_minmax_single_component_formats.into(); self } + #[inline] pub fn filter_minmax_image_component_mapping( mut self, filter_minmax_image_component_mapping: bool, ) -> Self { - self.inner.filter_minmax_image_component_mapping = - filter_minmax_image_component_mapping.into(); + self.filter_minmax_image_component_mapping = filter_minmax_image_component_mapping.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -22714,58 +14963,31 @@ pub struct SampleLocationEXT { pub y: f32, } impl SampleLocationEXT { - pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> { - SampleLocationEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SampleLocationEXTBuilder<'a> { - inner: SampleLocationEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> { - type Target = SampleLocationEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SampleLocationEXTBuilder<'a> { + #[inline] pub fn x(mut self, x: f32) -> Self { - self.inner.x = x; + self.x = x; self } + #[inline] pub fn y(mut self, y: f32) -> Self { - self.inner.y = y; + self.y = y; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SampleLocationEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SampleLocationsInfoEXT { +pub struct SampleLocationsInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub sample_locations_per_pixel: SampleCountFlags, pub sample_location_grid_size: Extent2D, pub sample_locations_count: u32, pub p_sample_locations: *const SampleLocationEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SampleLocationsInfoEXT { +impl ::std::default::Default for SampleLocationsInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT, @@ -22774,170 +14996,95 @@ impl ::std::default::Default for SampleLocationsInfoEXT { sample_location_grid_size: Extent2D::default(), sample_locations_count: u32::default(), p_sample_locations: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SampleLocationsInfoEXT { - pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> { - SampleLocationsInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SampleLocationsInfoEXTBuilder<'a> { - inner: SampleLocationsInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {} -unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {} -unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {} -unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {} -impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> { - type Target = SampleLocationsInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SampleLocationsInfoEXTBuilder<'a> { +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT<'_> {} +unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT<'_> {} +impl<'a> SampleLocationsInfoEXT<'a> { + #[inline] pub fn sample_locations_per_pixel( mut self, sample_locations_per_pixel: SampleCountFlags, ) -> Self { - self.inner.sample_locations_per_pixel = sample_locations_per_pixel; + self.sample_locations_per_pixel = sample_locations_per_pixel; self } + #[inline] pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self { - self.inner.sample_location_grid_size = sample_location_grid_size; + self.sample_location_grid_size = sample_location_grid_size; self } + #[inline] pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self { - self.inner.sample_locations_count = sample_locations.len() as _; - self.inner.p_sample_locations = sample_locations.as_ptr(); + self.sample_locations_count = sample_locations.len() as _; + self.p_sample_locations = sample_locations.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SampleLocationsInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] #[doc = ""] -pub struct AttachmentSampleLocationsEXT { +pub struct AttachmentSampleLocationsEXT<'a> { pub attachment_index: u32, - pub sample_locations_info: SampleLocationsInfoEXT, + pub sample_locations_info: SampleLocationsInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl AttachmentSampleLocationsEXT { - pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> { - AttachmentSampleLocationsEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentSampleLocationsEXTBuilder<'a> { - inner: AttachmentSampleLocationsEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> { - type Target = AttachmentSampleLocationsEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentSampleLocationsEXTBuilder<'a> { +impl<'a> AttachmentSampleLocationsEXT<'a> { + #[inline] pub fn attachment_index(mut self, attachment_index: u32) -> Self { - self.inner.attachment_index = attachment_index; + self.attachment_index = attachment_index; self } - pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { - self.inner.sample_locations_info = sample_locations_info; + #[inline] + pub fn sample_locations_info( + mut self, + sample_locations_info: SampleLocationsInfoEXT<'a>, + ) -> Self { + self.sample_locations_info = sample_locations_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentSampleLocationsEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] #[doc = ""] -pub struct SubpassSampleLocationsEXT { +pub struct SubpassSampleLocationsEXT<'a> { pub subpass_index: u32, - pub sample_locations_info: SampleLocationsInfoEXT, + pub sample_locations_info: SampleLocationsInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl SubpassSampleLocationsEXT { - pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> { - SubpassSampleLocationsEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassSampleLocationsEXTBuilder<'a> { - inner: SubpassSampleLocationsEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> { - type Target = SubpassSampleLocationsEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassSampleLocationsEXTBuilder<'a> { +impl<'a> SubpassSampleLocationsEXT<'a> { + #[inline] pub fn subpass_index(mut self, subpass_index: u32) -> Self { - self.inner.subpass_index = subpass_index; + self.subpass_index = subpass_index; self } - pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { - self.inner.sample_locations_info = sample_locations_info; + #[inline] + pub fn sample_locations_info( + mut self, + sample_locations_info: SampleLocationsInfoEXT<'a>, + ) -> Self { + self.sample_locations_info = sample_locations_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassSampleLocationsEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassSampleLocationsBeginInfoEXT { +pub struct RenderPassSampleLocationsBeginInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub attachment_initial_sample_locations_count: u32, - pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT, + pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT<'a>, pub post_subpass_sample_locations_count: u32, - pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, + pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { +impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, @@ -22946,134 +15093,78 @@ impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { p_attachment_initial_sample_locations: ::std::ptr::null(), post_subpass_sample_locations_count: u32::default(), p_post_subpass_sample_locations: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassSampleLocationsBeginInfoEXT { - pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - RenderPassSampleLocationsBeginInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - inner: RenderPassSampleLocationsBeginInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {} -impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - type Target = RenderPassSampleLocationsBeginInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT<'_> {} +impl<'a> RenderPassSampleLocationsBeginInfoEXT<'a> { + #[inline] pub fn attachment_initial_sample_locations( mut self, attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], ) -> Self { - self.inner.attachment_initial_sample_locations_count = + self.attachment_initial_sample_locations_count = attachment_initial_sample_locations.len() as _; - self.inner.p_attachment_initial_sample_locations = - attachment_initial_sample_locations.as_ptr(); + self.p_attachment_initial_sample_locations = attachment_initial_sample_locations.as_ptr(); self } + #[inline] pub fn post_subpass_sample_locations( mut self, post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], ) -> Self { - self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _; - self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr(); + self.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _; + self.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineSampleLocationsStateCreateInfoEXT { +pub struct PipelineSampleLocationsStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub sample_locations_enable: Bool32, - pub sample_locations_info: SampleLocationsInfoEXT, + pub sample_locations_info: SampleLocationsInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { +impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), sample_locations_enable: Bool32::default(), sample_locations_info: SampleLocationsInfoEXT::default(), + _marker: PhantomData, } } } -impl PipelineSampleLocationsStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { - PipelineSampleLocationsStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { - inner: PipelineSampleLocationsStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_> + for PipelineSampleLocationsStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineSampleLocationsStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { - type Target = PipelineSampleLocationsStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineSampleLocationsStateCreateInfoEXT<'a> { + #[inline] pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self { - self.inner.sample_locations_enable = sample_locations_enable.into(); + self.sample_locations_enable = sample_locations_enable.into(); self } - pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { - self.inner.sample_locations_info = sample_locations_info; + #[inline] + pub fn sample_locations_info( + mut self, + sample_locations_info: SampleLocationsInfoEXT<'a>, + ) -> Self { + self.sample_locations_info = sample_locations_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSampleLocationsPropertiesEXT { +pub struct PhysicalDeviceSampleLocationsPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub sample_location_sample_counts: SampleCountFlags, @@ -23081,8 +15172,9 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT { pub sample_location_coordinate_range: [f32; 2], pub sample_location_sub_pixel_bits: u32, pub variable_sample_locations: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, @@ -23092,315 +15184,171 @@ impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { sample_location_coordinate_range: unsafe { ::std::mem::zeroed() }, sample_location_sub_pixel_bits: u32::default(), variable_sample_locations: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSampleLocationsPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { - PhysicalDeviceSampleLocationsPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceSampleLocationsPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceSampleLocationsPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceSampleLocationsPropertiesEXT<'a> { + #[inline] pub fn sample_location_sample_counts( mut self, sample_location_sample_counts: SampleCountFlags, ) -> Self { - self.inner.sample_location_sample_counts = sample_location_sample_counts; + self.sample_location_sample_counts = sample_location_sample_counts; self } + #[inline] pub fn max_sample_location_grid_size( mut self, max_sample_location_grid_size: Extent2D, ) -> Self { - self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self.max_sample_location_grid_size = max_sample_location_grid_size; self } + #[inline] pub fn sample_location_coordinate_range( mut self, sample_location_coordinate_range: [f32; 2], ) -> Self { - self.inner.sample_location_coordinate_range = sample_location_coordinate_range; + self.sample_location_coordinate_range = sample_location_coordinate_range; self } + #[inline] pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self { - self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits; + self.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits; self } + #[inline] pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self { - self.inner.variable_sample_locations = variable_sample_locations.into(); + self.variable_sample_locations = variable_sample_locations.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MultisamplePropertiesEXT { +pub struct MultisamplePropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_sample_location_grid_size: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MultisamplePropertiesEXT { +impl ::std::default::Default for MultisamplePropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), max_sample_location_grid_size: Extent2D::default(), + _marker: PhantomData, } } } -impl MultisamplePropertiesEXT { - pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> { - MultisamplePropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MultisamplePropertiesEXTBuilder<'a> { - inner: MultisamplePropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { - type Target = MultisamplePropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MultisamplePropertiesEXTBuilder<'a> { +impl<'a> MultisamplePropertiesEXT<'a> { + #[inline] pub fn max_sample_location_grid_size( mut self, max_sample_location_grid_size: Extent2D, ) -> Self { - self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self.max_sample_location_grid_size = max_sample_location_grid_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MultisamplePropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerReductionModeCreateInfo { +pub struct SamplerReductionModeCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub reduction_mode: SamplerReductionMode, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SamplerReductionModeCreateInfo { +impl ::std::default::Default for SamplerReductionModeCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO, p_next: ::std::ptr::null(), reduction_mode: SamplerReductionMode::default(), + _marker: PhantomData, } } } -impl SamplerReductionModeCreateInfo { - pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> { - SamplerReductionModeCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerReductionModeCreateInfoBuilder<'a> { - inner: SamplerReductionModeCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {} -unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {} -impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> { - type Target = SamplerReductionModeCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerReductionModeCreateInfoBuilder<'a> { +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo<'_> {} +impl<'a> SamplerReductionModeCreateInfo<'a> { + #[inline] pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self { - self.inner.reduction_mode = reduction_mode; + self.reduction_mode = reduction_mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerReductionModeCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub advanced_blend_coherent_operations: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, p_next: ::std::ptr::null_mut(), advanced_blend_coherent_operations: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { - PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> { + #[inline] pub fn advanced_blend_coherent_operations( mut self, advanced_blend_coherent_operations: bool, ) -> Self { - self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into(); + self.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMultiDrawFeaturesEXT { +pub struct PhysicalDeviceMultiDrawFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub multi_draw: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, p_next: ::std::ptr::null_mut(), multi_draw: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMultiDrawFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { - PhysicalDeviceMultiDrawFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceMultiDrawFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceMultiDrawFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceMultiDrawFeaturesEXT<'a> { + #[inline] pub fn multi_draw(mut self, multi_draw: bool) -> Self { - self.inner.multi_draw = multi_draw.into(); + self.multi_draw = multi_draw.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMultiDrawFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub advanced_blend_max_color_attachments: u32, @@ -23409,8 +15357,9 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { pub advanced_blend_non_premultiplied_dst_color: Bool32, pub advanced_blend_correlated_overlap: Bool32, pub advanced_blend_all_operations: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, @@ -23421,99 +15370,76 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesE advanced_blend_non_premultiplied_dst_color: Bool32::default(), advanced_blend_correlated_overlap: Bool32::default(), advanced_blend_all_operations: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { - PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_> + for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { +impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { + #[inline] pub fn advanced_blend_max_color_attachments( mut self, advanced_blend_max_color_attachments: u32, ) -> Self { - self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments; + self.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments; self } + #[inline] pub fn advanced_blend_independent_blend( mut self, advanced_blend_independent_blend: bool, ) -> Self { - self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into(); + self.advanced_blend_independent_blend = advanced_blend_independent_blend.into(); self } + #[inline] pub fn advanced_blend_non_premultiplied_src_color( mut self, advanced_blend_non_premultiplied_src_color: bool, ) -> Self { - self.inner.advanced_blend_non_premultiplied_src_color = + self.advanced_blend_non_premultiplied_src_color = advanced_blend_non_premultiplied_src_color.into(); self } + #[inline] pub fn advanced_blend_non_premultiplied_dst_color( mut self, advanced_blend_non_premultiplied_dst_color: bool, ) -> Self { - self.inner.advanced_blend_non_premultiplied_dst_color = + self.advanced_blend_non_premultiplied_dst_color = advanced_blend_non_premultiplied_dst_color.into(); self } + #[inline] pub fn advanced_blend_correlated_overlap( mut self, advanced_blend_correlated_overlap: bool, ) -> Self { - self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into(); + self.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into(); self } + #[inline] pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self { - self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into(); + self.advanced_blend_all_operations = advanced_blend_all_operations.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { +pub struct PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_premultiplied: Bool32, pub dst_premultiplied: Bool32, pub blend_overlap: BlendOverlapEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { +impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, @@ -23521,135 +15447,76 @@ impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { src_premultiplied: Bool32::default(), dst_premultiplied: Bool32::default(), blend_overlap: BlendOverlapEXT::default(), + _marker: PhantomData, } } } -impl PipelineColorBlendAdvancedStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { - PipelineColorBlendAdvancedStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { - inner: PipelineColorBlendAdvancedStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineColorBlendStateCreateInfo - for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_> + for PipelineColorBlendAdvancedStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineColorBlendStateCreateInfo - for PipelineColorBlendAdvancedStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { - type Target = PipelineColorBlendAdvancedStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { + #[inline] pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { - self.inner.src_premultiplied = src_premultiplied.into(); + self.src_premultiplied = src_premultiplied.into(); self } + #[inline] pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { - self.inner.dst_premultiplied = dst_premultiplied.into(); + self.dst_premultiplied = dst_premultiplied.into(); self } + #[inline] pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self { - self.inner.blend_overlap = blend_overlap; + self.blend_overlap = blend_overlap; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceInlineUniformBlockFeatures { +pub struct PhysicalDeviceInlineUniformBlockFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub inline_uniform_block: Bool32, pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures { +impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, p_next: ::std::ptr::null_mut(), inline_uniform_block: Bool32::default(), descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceInlineUniformBlockFeatures { - pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { - PhysicalDeviceInlineUniformBlockFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { - inner: PhysicalDeviceInlineUniformBlockFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { - type Target = PhysicalDeviceInlineUniformBlockFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures<'_> {} +impl<'a> PhysicalDeviceInlineUniformBlockFeatures<'a> { + #[inline] pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { - self.inner.inline_uniform_block = inline_uniform_block.into(); + self.inline_uniform_block = inline_uniform_block.into(); self } + #[inline] pub fn descriptor_binding_inline_uniform_block_update_after_bind( mut self, descriptor_binding_inline_uniform_block_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_inline_uniform_block_update_after_bind = + self.descriptor_binding_inline_uniform_block_update_after_bind = descriptor_binding_inline_uniform_block_update_after_bind.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceInlineUniformBlockProperties { +pub struct PhysicalDeviceInlineUniformBlockProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_inline_uniform_block_size: u32, @@ -23657,8 +15524,9 @@ pub struct PhysicalDeviceInlineUniformBlockProperties { pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, pub max_descriptor_set_inline_uniform_blocks: u32, pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties { +impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, @@ -23668,210 +15536,120 @@ impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties { max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(), max_descriptor_set_inline_uniform_blocks: u32::default(), max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceInlineUniformBlockProperties { - pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { - PhysicalDeviceInlineUniformBlockPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { - inner: PhysicalDeviceInlineUniformBlockProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { - type Target = PhysicalDeviceInlineUniformBlockProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties<'_> {} +impl<'a> PhysicalDeviceInlineUniformBlockProperties<'a> { + #[inline] pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self { - self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size; + self.max_inline_uniform_block_size = max_inline_uniform_block_size; self } + #[inline] pub fn max_per_stage_descriptor_inline_uniform_blocks( mut self, max_per_stage_descriptor_inline_uniform_blocks: u32, ) -> Self { - self.inner.max_per_stage_descriptor_inline_uniform_blocks = + self.max_per_stage_descriptor_inline_uniform_blocks = max_per_stage_descriptor_inline_uniform_blocks; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( mut self, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = + self.max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; self } + #[inline] pub fn max_descriptor_set_inline_uniform_blocks( mut self, max_descriptor_set_inline_uniform_blocks: u32, ) -> Self { - self.inner.max_descriptor_set_inline_uniform_blocks = - max_descriptor_set_inline_uniform_blocks; + self.max_descriptor_set_inline_uniform_blocks = max_descriptor_set_inline_uniform_blocks; self } + #[inline] pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( mut self, max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_inline_uniform_blocks = + self.max_descriptor_set_update_after_bind_inline_uniform_blocks = max_descriptor_set_update_after_bind_inline_uniform_blocks; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct WriteDescriptorSetInlineUniformBlock { +pub struct WriteDescriptorSetInlineUniformBlock<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub data_size: u32, pub p_data: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock { +impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock<'_> { fn default() -> Self { Self { s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, p_next: ::std::ptr::null(), data_size: u32::default(), p_data: ::std::ptr::null(), + _marker: PhantomData, } } } -impl WriteDescriptorSetInlineUniformBlock { - pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> { - WriteDescriptorSetInlineUniformBlockBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> { - inner: WriteDescriptorSetInlineUniformBlock, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {} -impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> { - type Target = WriteDescriptorSetInlineUniformBlock; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> { +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock<'_> {} +impl<'a> WriteDescriptorSetInlineUniformBlock<'a> { + #[inline] pub fn data(mut self, data: &'a [u8]) -> Self { - self.inner.data_size = data.len() as _; - self.inner.p_data = data.as_ptr() as *const c_void; + self.data_size = data.len() as _; + self.p_data = data.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> WriteDescriptorSetInlineUniformBlock { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorPoolInlineUniformBlockCreateInfo { +pub struct DescriptorPoolInlineUniformBlockCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_inline_uniform_block_bindings: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo { +impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, p_next: ::std::ptr::null(), max_inline_uniform_block_bindings: u32::default(), + _marker: PhantomData, } } } -impl DescriptorPoolInlineUniformBlockCreateInfo { - pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { - DescriptorPoolInlineUniformBlockCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { - inner: DescriptorPoolInlineUniformBlockCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDescriptorPoolCreateInfo - for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_> -{ -} -unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {} -impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { - type Target = DescriptorPoolInlineUniformBlockCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { +unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo<'_> {} +impl<'a> DescriptorPoolInlineUniformBlockCreateInfo<'a> { + #[inline] pub fn max_inline_uniform_block_bindings( mut self, max_inline_uniform_block_bindings: u32, ) -> Self { - self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings; + self.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineCoverageModulationStateCreateInfoNV { +pub struct PipelineCoverageModulationStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCoverageModulationStateCreateFlagsNV, @@ -23879,8 +15657,9 @@ pub struct PipelineCoverageModulationStateCreateInfoNV { pub coverage_modulation_table_enable: Bool32, pub coverage_modulation_table_count: u32, pub p_coverage_modulation_table: *const f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { +impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, @@ -23890,147 +15669,89 @@ impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { coverage_modulation_table_enable: Bool32::default(), coverage_modulation_table_count: u32::default(), p_coverage_modulation_table: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineCoverageModulationStateCreateInfoNV { - pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { - PipelineCoverageModulationStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { - inner: PipelineCoverageModulationStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineCoverageModulationStateCreateInfoNVBuilder<'_> + for PipelineCoverageModulationStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineCoverageModulationStateCreateInfoNV -{ -} -impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { - type Target = PipelineCoverageModulationStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineCoverageModulationStateCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn coverage_modulation_mode( mut self, coverage_modulation_mode: CoverageModulationModeNV, ) -> Self { - self.inner.coverage_modulation_mode = coverage_modulation_mode; + self.coverage_modulation_mode = coverage_modulation_mode; self } + #[inline] pub fn coverage_modulation_table_enable( mut self, coverage_modulation_table_enable: bool, ) -> Self { - self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into(); + self.coverage_modulation_table_enable = coverage_modulation_table_enable.into(); self } + #[inline] pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self { - self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _; - self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); + self.coverage_modulation_table_count = coverage_modulation_table.len() as _; + self.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageFormatListCreateInfo { +pub struct ImageFormatListCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub view_format_count: u32, pub p_view_formats: *const Format, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageFormatListCreateInfo { +impl ::std::default::Default for ImageFormatListCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO, p_next: ::std::ptr::null(), view_format_count: u32::default(), p_view_formats: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ImageFormatListCreateInfo { - pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> { - ImageFormatListCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageFormatListCreateInfoBuilder<'a> { - inner: ImageFormatListCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {} -unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {} -impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> { - type Target = ImageFormatListCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageFormatListCreateInfoBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo<'_> {} +impl<'a> ImageFormatListCreateInfo<'a> { + #[inline] pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self { - self.inner.view_format_count = view_formats.len() as _; - self.inner.p_view_formats = view_formats.as_ptr(); + self.view_format_count = view_formats.len() as _; + self.p_view_formats = view_formats.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageFormatListCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ValidationCacheCreateInfoEXT { +pub struct ValidationCacheCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ValidationCacheCreateFlagsEXT, pub initial_data_size: usize, pub p_initial_data: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ValidationCacheCreateInfoEXT { +impl ::std::default::Default for ValidationCacheCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT, @@ -24038,481 +15759,255 @@ impl ::std::default::Default for ValidationCacheCreateInfoEXT { flags: ValidationCacheCreateFlagsEXT::default(), initial_data_size: usize::default(), p_initial_data: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ValidationCacheCreateInfoEXT { - pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> { - ValidationCacheCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ValidationCacheCreateInfoEXTBuilder<'a> { - inner: ValidationCacheCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { - type Target = ValidationCacheCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { +impl<'a> ValidationCacheCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self { - self.inner.initial_data_size = initial_data.len(); - self.inner.p_initial_data = initial_data.as_ptr() as *const c_void; + self.initial_data_size = initial_data.len(); + self.p_initial_data = initial_data.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ValidationCacheCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ShaderModuleValidationCacheCreateInfoEXT { +pub struct ShaderModuleValidationCacheCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub validation_cache: ValidationCacheEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { +impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), validation_cache: ValidationCacheEXT::default(), + _marker: PhantomData, } } } -impl ShaderModuleValidationCacheCreateInfoEXT { - pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { - ShaderModuleValidationCacheCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { - inner: ShaderModuleValidationCacheCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} -impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { - type Target = ShaderModuleValidationCacheCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT<'_> {} +impl<'a> ShaderModuleValidationCacheCreateInfoEXT<'a> { + #[inline] pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self { - self.inner.validation_cache = validation_cache; + self.validation_cache = validation_cache; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMaintenance3Properties { +pub struct PhysicalDeviceMaintenance3Properties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_per_set_descriptors: u32, pub max_memory_allocation_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { +impl ::std::default::Default for PhysicalDeviceMaintenance3Properties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, p_next: ::std::ptr::null_mut(), max_per_set_descriptors: u32::default(), max_memory_allocation_size: DeviceSize::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMaintenance3Properties { - pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { - PhysicalDeviceMaintenance3PropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> { - inner: PhysicalDeviceMaintenance3Properties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { - type Target = PhysicalDeviceMaintenance3Properties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties<'_> {} +impl<'a> PhysicalDeviceMaintenance3Properties<'a> { + #[inline] pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { - self.inner.max_per_set_descriptors = max_per_set_descriptors; + self.max_per_set_descriptors = max_per_set_descriptors; self } + #[inline] pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self { - self.inner.max_memory_allocation_size = max_memory_allocation_size; + self.max_memory_allocation_size = max_memory_allocation_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMaintenance3Properties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMaintenance4Features { +pub struct PhysicalDeviceMaintenance4Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub maintenance4: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMaintenance4Features { +impl ::std::default::Default for PhysicalDeviceMaintenance4Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, p_next: ::std::ptr::null_mut(), maintenance4: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMaintenance4Features { - pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> { - PhysicalDeviceMaintenance4FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> { - inner: PhysicalDeviceMaintenance4Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> { - type Target = PhysicalDeviceMaintenance4Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features<'_> {} +impl<'a> PhysicalDeviceMaintenance4Features<'a> { + #[inline] pub fn maintenance4(mut self, maintenance4: bool) -> Self { - self.inner.maintenance4 = maintenance4.into(); + self.maintenance4 = maintenance4.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMaintenance4Features { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMaintenance4Properties { +pub struct PhysicalDeviceMaintenance4Properties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_buffer_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMaintenance4Properties { +impl ::std::default::Default for PhysicalDeviceMaintenance4Properties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, p_next: ::std::ptr::null_mut(), max_buffer_size: DeviceSize::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMaintenance4Properties { - pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> { - PhysicalDeviceMaintenance4PropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> { - inner: PhysicalDeviceMaintenance4Properties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> { - type Target = PhysicalDeviceMaintenance4Properties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties<'_> {} +impl<'a> PhysicalDeviceMaintenance4Properties<'a> { + #[inline] pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { - self.inner.max_buffer_size = max_buffer_size; + self.max_buffer_size = max_buffer_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMaintenance4Properties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetLayoutSupport { +pub struct DescriptorSetLayoutSupport<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub supported: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetLayoutSupport { +impl ::std::default::Default for DescriptorSetLayoutSupport<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT, p_next: ::std::ptr::null_mut(), supported: Bool32::default(), + _marker: PhantomData, } } } -impl DescriptorSetLayoutSupport { - pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> { - DescriptorSetLayoutSupportBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetLayoutSupportBuilder<'a> { - inner: DescriptorSetLayoutSupport, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsDescriptorSetLayoutSupport {} -impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> { - type Target = DescriptorSetLayoutSupport; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetLayoutSupportBuilder<'a> { +impl<'a> DescriptorSetLayoutSupport<'a> { + #[inline] pub fn supported(mut self, supported: bool) -> Self { - self.inner.supported = supported.into(); + self.supported = supported.into(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetLayoutSupport { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderDrawParametersFeatures { +pub struct PhysicalDeviceShaderDrawParametersFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_draw_parameters: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures { +impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, p_next: ::std::ptr::null_mut(), shader_draw_parameters: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderDrawParametersFeatures { - pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { - PhysicalDeviceShaderDrawParametersFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { - inner: PhysicalDeviceShaderDrawParametersFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderDrawParametersFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures<'_> {} +impl<'a> PhysicalDeviceShaderDrawParametersFeatures<'a> { + #[inline] pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { - self.inner.shader_draw_parameters = shader_draw_parameters.into(); + self.shader_draw_parameters = shader_draw_parameters.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderFloat16Int8Features { +pub struct PhysicalDeviceShaderFloat16Int8Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_float16: Bool32, pub shader_int8: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features { +impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, p_next: ::std::ptr::null_mut(), shader_float16: Bool32::default(), shader_int8: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderFloat16Int8Features { - pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { - PhysicalDeviceShaderFloat16Int8FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { - inner: PhysicalDeviceShaderFloat16Int8Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderFloat16Int8Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features<'_> {} +impl<'a> PhysicalDeviceShaderFloat16Int8Features<'a> { + #[inline] pub fn shader_float16(mut self, shader_float16: bool) -> Self { - self.inner.shader_float16 = shader_float16.into(); + self.shader_float16 = shader_float16.into(); self } + #[inline] pub fn shader_int8(mut self, shader_int8: bool) -> Self { - self.inner.shader_int8 = shader_int8.into(); + self.shader_int8 = shader_int8.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFloatControlsProperties { +pub struct PhysicalDeviceFloatControlsProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub denorm_behavior_independence: ShaderFloatControlsIndependence, @@ -24532,8 +16027,9 @@ pub struct PhysicalDeviceFloatControlsProperties { pub shader_rounding_mode_rtz_float16: Bool32, pub shader_rounding_mode_rtz_float32: Bool32, pub shader_rounding_mode_rtz_float64: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFloatControlsProperties { +impl ::std::default::Default for PhysicalDeviceFloatControlsProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, @@ -24555,213 +16051,171 @@ impl ::std::default::Default for PhysicalDeviceFloatControlsProperties { shader_rounding_mode_rtz_float16: Bool32::default(), shader_rounding_mode_rtz_float32: Bool32::default(), shader_rounding_mode_rtz_float64: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFloatControlsProperties { - pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> { - PhysicalDeviceFloatControlsPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> { - inner: PhysicalDeviceFloatControlsProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> { - type Target = PhysicalDeviceFloatControlsProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties<'_> {} +impl<'a> PhysicalDeviceFloatControlsProperties<'a> { + #[inline] pub fn denorm_behavior_independence( mut self, denorm_behavior_independence: ShaderFloatControlsIndependence, ) -> Self { - self.inner.denorm_behavior_independence = denorm_behavior_independence; + self.denorm_behavior_independence = denorm_behavior_independence; self } + #[inline] pub fn rounding_mode_independence( mut self, rounding_mode_independence: ShaderFloatControlsIndependence, ) -> Self { - self.inner.rounding_mode_independence = rounding_mode_independence; + self.rounding_mode_independence = rounding_mode_independence; self } + #[inline] pub fn shader_signed_zero_inf_nan_preserve_float16( mut self, shader_signed_zero_inf_nan_preserve_float16: bool, ) -> Self { - self.inner.shader_signed_zero_inf_nan_preserve_float16 = + self.shader_signed_zero_inf_nan_preserve_float16 = shader_signed_zero_inf_nan_preserve_float16.into(); self } + #[inline] pub fn shader_signed_zero_inf_nan_preserve_float32( mut self, shader_signed_zero_inf_nan_preserve_float32: bool, ) -> Self { - self.inner.shader_signed_zero_inf_nan_preserve_float32 = + self.shader_signed_zero_inf_nan_preserve_float32 = shader_signed_zero_inf_nan_preserve_float32.into(); self } + #[inline] pub fn shader_signed_zero_inf_nan_preserve_float64( mut self, shader_signed_zero_inf_nan_preserve_float64: bool, ) -> Self { - self.inner.shader_signed_zero_inf_nan_preserve_float64 = + self.shader_signed_zero_inf_nan_preserve_float64 = shader_signed_zero_inf_nan_preserve_float64.into(); self } + #[inline] pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self { - self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); self } + #[inline] pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self { - self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); self } + #[inline] pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self { - self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); self } + #[inline] pub fn shader_denorm_flush_to_zero_float16( mut self, shader_denorm_flush_to_zero_float16: bool, ) -> Self { - self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); + self.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); self } + #[inline] pub fn shader_denorm_flush_to_zero_float32( mut self, shader_denorm_flush_to_zero_float32: bool, ) -> Self { - self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); + self.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); self } + #[inline] pub fn shader_denorm_flush_to_zero_float64( mut self, shader_denorm_flush_to_zero_float64: bool, ) -> Self { - self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); + self.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); self } + #[inline] pub fn shader_rounding_mode_rte_float16( mut self, shader_rounding_mode_rte_float16: bool, ) -> Self { - self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); + self.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); self } + #[inline] pub fn shader_rounding_mode_rte_float32( mut self, shader_rounding_mode_rte_float32: bool, ) -> Self { - self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); + self.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); self } + #[inline] pub fn shader_rounding_mode_rte_float64( mut self, shader_rounding_mode_rte_float64: bool, ) -> Self { - self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); + self.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); self } + #[inline] pub fn shader_rounding_mode_rtz_float16( mut self, shader_rounding_mode_rtz_float16: bool, ) -> Self { - self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); + self.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); self } + #[inline] pub fn shader_rounding_mode_rtz_float32( mut self, shader_rounding_mode_rtz_float32: bool, ) -> Self { - self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); + self.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); self } + #[inline] pub fn shader_rounding_mode_rtz_float64( mut self, shader_rounding_mode_rtz_float64: bool, ) -> Self { - self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); + self.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFloatControlsProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceHostQueryResetFeatures { +pub struct PhysicalDeviceHostQueryResetFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub host_query_reset: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures { +impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, p_next: ::std::ptr::null_mut(), host_query_reset: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceHostQueryResetFeatures { - pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { - PhysicalDeviceHostQueryResetFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { - inner: PhysicalDeviceHostQueryResetFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { - type Target = PhysicalDeviceHostQueryResetFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures<'_> {} +impl<'a> PhysicalDeviceHostQueryResetFeatures<'a> { + #[inline] pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { - self.inner.host_query_reset = host_query_reset.into(); + self.host_query_reset = host_query_reset.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -24772,50 +16226,22 @@ pub struct NativeBufferUsage2ANDROID { pub producer: u64, } impl NativeBufferUsage2ANDROID { - pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> { - NativeBufferUsage2ANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct NativeBufferUsage2ANDROIDBuilder<'a> { - inner: NativeBufferUsage2ANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> { - type Target = NativeBufferUsage2ANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> { + #[inline] pub fn consumer(mut self, consumer: u64) -> Self { - self.inner.consumer = consumer; + self.consumer = consumer; self } + #[inline] pub fn producer(mut self, producer: u64) -> Self { - self.inner.producer = producer; + self.producer = producer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> NativeBufferUsage2ANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct NativeBufferANDROID { +pub struct NativeBufferANDROID<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle: *const c_void, @@ -24823,8 +16249,9 @@ pub struct NativeBufferANDROID { pub format: c_int, pub usage: c_int, pub usage2: NativeBufferUsage2ANDROID, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for NativeBufferANDROID { +impl ::std::default::Default for NativeBufferANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::NATIVE_BUFFER_ANDROID, @@ -24834,168 +16261,90 @@ impl ::std::default::Default for NativeBufferANDROID { format: c_int::default(), usage: c_int::default(), usage2: NativeBufferUsage2ANDROID::default(), + _marker: PhantomData, } } } -impl NativeBufferANDROID { - pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> { - NativeBufferANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct NativeBufferANDROIDBuilder<'a> { - inner: NativeBufferANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { - type Target = NativeBufferANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> NativeBufferANDROIDBuilder<'a> { +impl<'a> NativeBufferANDROID<'a> { + #[inline] pub fn handle(mut self, handle: *const c_void) -> Self { - self.inner.handle = handle; + self.handle = handle; self } + #[inline] pub fn stride(mut self, stride: c_int) -> Self { - self.inner.stride = stride; + self.stride = stride; self } + #[inline] pub fn format(mut self, format: c_int) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn usage(mut self, usage: c_int) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self { - self.inner.usage2 = usage2; + self.usage2 = usage2; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> NativeBufferANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SwapchainImageCreateInfoANDROID { +pub struct SwapchainImageCreateInfoANDROID<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub usage: SwapchainImageUsageFlagsANDROID, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SwapchainImageCreateInfoANDROID { +impl ::std::default::Default for SwapchainImageCreateInfoANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID, p_next: ::std::ptr::null(), usage: SwapchainImageUsageFlagsANDROID::default(), + _marker: PhantomData, } } } -impl SwapchainImageCreateInfoANDROID { - pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> { - SwapchainImageCreateInfoANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> { - inner: SwapchainImageCreateInfoANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> { - type Target = SwapchainImageCreateInfoANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> { +impl<'a> SwapchainImageCreateInfoANDROID<'a> { + #[inline] pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self { - self.inner.usage = usage; + self.usage = usage; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SwapchainImageCreateInfoANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePresentationPropertiesANDROID { +pub struct PhysicalDevicePresentationPropertiesANDROID<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub shared_image: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID { +impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID, p_next: ::std::ptr::null(), shared_image: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePresentationPropertiesANDROID { - pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { - PhysicalDevicePresentationPropertiesANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { - inner: PhysicalDevicePresentationPropertiesANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { - type Target = PhysicalDevicePresentationPropertiesANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { +impl<'a> PhysicalDevicePresentationPropertiesANDROID<'a> { + #[inline] pub fn shared_image(mut self, shared_image: bool) -> Self { - self.inner.shared_image = shared_image.into(); + self.shared_image = shared_image.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -25009,56 +16358,31 @@ pub struct ShaderResourceUsageAMD { pub scratch_mem_usage_in_bytes: usize, } impl ShaderResourceUsageAMD { - pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> { - ShaderResourceUsageAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ShaderResourceUsageAMDBuilder<'a> { - inner: ShaderResourceUsageAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> { - type Target = ShaderResourceUsageAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ShaderResourceUsageAMDBuilder<'a> { + #[inline] pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self { - self.inner.num_used_vgprs = num_used_vgprs; + self.num_used_vgprs = num_used_vgprs; self } + #[inline] pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self { - self.inner.num_used_sgprs = num_used_sgprs; + self.num_used_sgprs = num_used_sgprs; self } + #[inline] pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self { - self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group; + self.lds_size_per_local_work_group = lds_size_per_local_work_group; self } + #[inline] pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self { - self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes; + self.lds_usage_size_in_bytes = lds_usage_size_in_bytes; self } + #[inline] pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self { - self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes; + self.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ShaderResourceUsageAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -25087,259 +16411,150 @@ impl ::std::default::Default for ShaderStatisticsInfoAMD { } } impl ShaderStatisticsInfoAMD { - pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> { - ShaderStatisticsInfoAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ShaderStatisticsInfoAMDBuilder<'a> { - inner: ShaderStatisticsInfoAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> { - type Target = ShaderStatisticsInfoAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ShaderStatisticsInfoAMDBuilder<'a> { + #[inline] pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self { - self.inner.shader_stage_mask = shader_stage_mask; + self.shader_stage_mask = shader_stage_mask; self } + #[inline] pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self { - self.inner.resource_usage = resource_usage; + self.resource_usage = resource_usage; self } + #[inline] pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self { - self.inner.num_physical_vgprs = num_physical_vgprs; + self.num_physical_vgprs = num_physical_vgprs; self } + #[inline] pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self { - self.inner.num_physical_sgprs = num_physical_sgprs; + self.num_physical_sgprs = num_physical_sgprs; self } + #[inline] pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self { - self.inner.num_available_vgprs = num_available_vgprs; + self.num_available_vgprs = num_available_vgprs; self } + #[inline] pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self { - self.inner.num_available_sgprs = num_available_sgprs; + self.num_available_sgprs = num_available_sgprs; self } + #[inline] pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self { - self.inner.compute_work_group_size = compute_work_group_size; + self.compute_work_group_size = compute_work_group_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ShaderStatisticsInfoAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceQueueGlobalPriorityCreateInfoKHR { +pub struct DeviceQueueGlobalPriorityCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub global_priority: QueueGlobalPriorityKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR { +impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, p_next: ::std::ptr::null(), global_priority: QueueGlobalPriorityKHR::default(), + _marker: PhantomData, } } } -impl DeviceQueueGlobalPriorityCreateInfoKHR { - pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { - DeviceQueueGlobalPriorityCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { - inner: DeviceQueueGlobalPriorityCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {} -unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {} -impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { - type Target = DeviceQueueGlobalPriorityCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR<'_> {} +impl<'a> DeviceQueueGlobalPriorityCreateInfoKHR<'a> { + #[inline] pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self { - self.inner.global_priority = global_priority; + self.global_priority = global_priority; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR { +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub global_priority_query: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, p_next: ::std::ptr::null_mut(), global_priority_query: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { - PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHR<'a> { + #[inline] pub fn global_priority_query(mut self, global_priority_query: bool) -> Self { - self.inner.global_priority_query = global_priority_query.into(); + self.global_priority_query = global_priority_query.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueueFamilyGlobalPriorityPropertiesKHR { +pub struct QueueFamilyGlobalPriorityPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub priority_count: u32, pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR { +impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), priority_count: u32::default(), priorities: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl QueueFamilyGlobalPriorityPropertiesKHR { - pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { - QueueFamilyGlobalPriorityPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { - inner: QueueFamilyGlobalPriorityPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {} -impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { - type Target = QueueFamilyGlobalPriorityPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR<'_> {} +impl<'a> QueueFamilyGlobalPriorityPropertiesKHR<'a> { + #[inline] pub fn priority_count(mut self, priority_count: u32) -> Self { - self.inner.priority_count = priority_count; + self.priority_count = priority_count; self } + #[inline] pub fn priorities( mut self, priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], ) -> Self { - self.inner.priorities = priorities; + self.priorities = priorities; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugUtilsObjectNameInfoEXT { +pub struct DebugUtilsObjectNameInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: ObjectType, pub object_handle: u64, pub p_object_name: *const c_char, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { +impl ::std::default::Default for DebugUtilsObjectNameInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT, @@ -25347,58 +16562,32 @@ impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { object_type: ObjectType::default(), object_handle: u64::default(), p_object_name: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DebugUtilsObjectNameInfoEXT { - pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> { - DebugUtilsObjectNameInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { - inner: DebugUtilsObjectNameInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { - type Target = DebugUtilsObjectNameInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { +impl<'a> DebugUtilsObjectNameInfoEXT<'a> { + #[inline] pub fn object_type(mut self, object_type: ObjectType) -> Self { - self.inner.object_type = object_type; + self.object_type = object_type; self } + #[inline] pub fn object_handle(mut self, object_handle: u64) -> Self { - self.inner.object_handle = object_handle; + self.object_handle = object_handle; self } + #[inline] pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_object_name = object_name.as_ptr(); + self.p_object_name = object_name.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugUtilsObjectNameInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugUtilsObjectTagInfoEXT { +pub struct DebugUtilsObjectTagInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub object_type: ObjectType, @@ -25406,8 +16595,9 @@ pub struct DebugUtilsObjectTagInfoEXT { pub tag_name: u64, pub tag_size: usize, pub p_tag: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { +impl ::std::default::Default for DebugUtilsObjectTagInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT, @@ -25417,122 +16607,71 @@ impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { tag_name: u64::default(), tag_size: usize::default(), p_tag: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DebugUtilsObjectTagInfoEXT { - pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> { - DebugUtilsObjectTagInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { - inner: DebugUtilsObjectTagInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { - type Target = DebugUtilsObjectTagInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { +impl<'a> DebugUtilsObjectTagInfoEXT<'a> { + #[inline] pub fn object_type(mut self, object_type: ObjectType) -> Self { - self.inner.object_type = object_type; + self.object_type = object_type; self } + #[inline] pub fn object_handle(mut self, object_handle: u64) -> Self { - self.inner.object_handle = object_handle; + self.object_handle = object_handle; self } + #[inline] pub fn tag_name(mut self, tag_name: u64) -> Self { - self.inner.tag_name = tag_name; + self.tag_name = tag_name; self } + #[inline] pub fn tag(mut self, tag: &'a [u8]) -> Self { - self.inner.tag_size = tag.len(); - self.inner.p_tag = tag.as_ptr() as *const c_void; + self.tag_size = tag.len(); + self.p_tag = tag.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugUtilsObjectTagInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugUtilsLabelEXT { +pub struct DebugUtilsLabelEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_label_name: *const c_char, pub color: [f32; 4], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugUtilsLabelEXT { +impl ::std::default::Default for DebugUtilsLabelEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_UTILS_LABEL_EXT, p_next: ::std::ptr::null(), p_label_name: ::std::ptr::null(), color: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl DebugUtilsLabelEXT { - pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> { - DebugUtilsLabelEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugUtilsLabelEXTBuilder<'a> { - inner: DebugUtilsLabelEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { - type Target = DebugUtilsLabelEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugUtilsLabelEXTBuilder<'a> { +impl<'a> DebugUtilsLabelEXT<'a> { + #[inline] pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_label_name = label_name.as_ptr(); + self.p_label_name = label_name.as_ptr(); self } + #[inline] pub fn color(mut self, color: [f32; 4]) -> Self { - self.inner.color = color; + self.color = color; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugUtilsLabelEXT { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugUtilsMessengerCreateInfoEXT { +pub struct DebugUtilsMessengerCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DebugUtilsMessengerCreateFlagsEXT, @@ -25540,9 +16679,10 @@ pub struct DebugUtilsMessengerCreateInfoEXT { pub message_type: DebugUtilsMessageTypeFlagsEXT, pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, pub p_user_data: *mut c_void, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { +impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT") .field("s_type", &self.s_type) @@ -25558,7 +16698,7 @@ impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { .finish() } } -impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { +impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, @@ -25568,71 +16708,46 @@ impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { message_type: DebugUtilsMessageTypeFlagsEXT::default(), pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(), p_user_data: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl DebugUtilsMessengerCreateInfoEXT { - pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { - DebugUtilsMessengerCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> { - inner: DebugUtilsMessengerCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {} -impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { - type Target = DebugUtilsMessengerCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT<'_> {} +impl<'a> DebugUtilsMessengerCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self { - self.inner.message_severity = message_severity; + self.message_severity = message_severity; self } + #[inline] pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self { - self.inner.message_type = message_type; + self.message_type = message_type; self } + #[inline] pub fn pfn_user_callback( mut self, pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, ) -> Self { - self.inner.pfn_user_callback = pfn_user_callback; + self.pfn_user_callback = pfn_user_callback; self } + #[inline] pub fn user_data(mut self, user_data: *mut c_void) -> Self { - self.inner.p_user_data = user_data; + self.p_user_data = user_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DebugUtilsMessengerCallbackDataEXT { +pub struct DebugUtilsMessengerCallbackDataEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DebugUtilsMessengerCallbackDataFlagsEXT, @@ -25640,13 +16755,14 @@ pub struct DebugUtilsMessengerCallbackDataEXT { pub message_id_number: i32, pub p_message: *const c_char, pub queue_label_count: u32, - pub p_queue_labels: *const DebugUtilsLabelEXT, + pub p_queue_labels: *const DebugUtilsLabelEXT<'a>, pub cmd_buf_label_count: u32, - pub p_cmd_buf_labels: *const DebugUtilsLabelEXT, + pub p_cmd_buf_labels: *const DebugUtilsLabelEXT<'a>, pub object_count: u32, - pub p_objects: *const DebugUtilsObjectNameInfoEXT, + pub p_objects: *const DebugUtilsObjectNameInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { +impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, @@ -25661,145 +16777,92 @@ impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { p_cmd_buf_labels: ::std::ptr::null(), object_count: u32::default(), p_objects: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DebugUtilsMessengerCallbackDataEXT { - pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - DebugUtilsMessengerCallbackDataEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - inner: DebugUtilsMessengerCallbackDataEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - type Target = DebugUtilsMessengerCallbackDataEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { +impl<'a> DebugUtilsMessengerCallbackDataEXT<'a> { + #[inline] pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_message_id_name = message_id_name.as_ptr(); + self.p_message_id_name = message_id_name.as_ptr(); self } + #[inline] pub fn message_id_number(mut self, message_id_number: i32) -> Self { - self.inner.message_id_number = message_id_number; + self.message_id_number = message_id_number; self } + #[inline] pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self { - self.inner.p_message = message.as_ptr(); + self.p_message = message.as_ptr(); self } + #[inline] pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self { - self.inner.queue_label_count = queue_labels.len() as _; - self.inner.p_queue_labels = queue_labels.as_ptr(); + self.queue_label_count = queue_labels.len() as _; + self.p_queue_labels = queue_labels.as_ptr(); self } + #[inline] pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self { - self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _; - self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr(); + self.cmd_buf_label_count = cmd_buf_labels.len() as _; + self.p_cmd_buf_labels = cmd_buf_labels.as_ptr(); self } + #[inline] pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self { - self.inner.object_count = objects.len() as _; - self.inner.p_objects = objects.as_ptr(); + self.object_count = objects.len() as _; + self.p_objects = objects.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT { +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub device_memory_report: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, p_next: ::std::ptr::null_mut(), device_memory_report: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDeviceMemoryReportFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { - PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> { + #[inline] pub fn device_memory_report(mut self, device_memory_report: bool) -> Self { - self.inner.device_memory_report = device_memory_report.into(); + self.device_memory_report = device_memory_report.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceDeviceMemoryReportCreateInfoEXT { +pub struct DeviceDeviceMemoryReportCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceMemoryReportFlagsEXT, pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, pub p_user_data: *mut c_void, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT { +impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT") .field("s_type", &self.s_type) @@ -25813,7 +16876,7 @@ impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT { .finish() } } -impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT { +impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, @@ -25821,63 +16884,36 @@ impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT { flags: DeviceMemoryReportFlagsEXT::default(), pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(), p_user_data: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl DeviceDeviceMemoryReportCreateInfoEXT { - pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { - DeviceDeviceMemoryReportCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { - inner: DeviceDeviceMemoryReportCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {} -impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { - type Target = DeviceDeviceMemoryReportCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT<'_> {} +impl<'a> DeviceDeviceMemoryReportCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn pfn_user_callback( mut self, pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, ) -> Self { - self.inner.pfn_user_callback = pfn_user_callback; + self.pfn_user_callback = pfn_user_callback; self } + #[inline] pub fn user_data(mut self, user_data: *mut c_void) -> Self { - self.inner.p_user_data = user_data; + self.p_user_data = user_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceMemoryReportCallbackDataEXT { +pub struct DeviceMemoryReportCallbackDataEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: DeviceMemoryReportFlagsEXT, @@ -25887,8 +16923,9 @@ pub struct DeviceMemoryReportCallbackDataEXT { pub object_type: ObjectType, pub object_handle: u64, pub heap_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT { +impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, @@ -25900,252 +16937,145 @@ impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT { object_type: ObjectType::default(), object_handle: u64::default(), heap_index: u32::default(), + _marker: PhantomData, } } } -impl DeviceMemoryReportCallbackDataEXT { - pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { - DeviceMemoryReportCallbackDataEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> { - inner: DeviceMemoryReportCallbackDataEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> { - type Target = DeviceMemoryReportCallbackDataEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> { +impl<'a> DeviceMemoryReportCallbackDataEXT<'a> { + #[inline] pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn memory_object_id(mut self, memory_object_id: u64) -> Self { - self.inner.memory_object_id = memory_object_id; + self.memory_object_id = memory_object_id; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn object_type(mut self, object_type: ObjectType) -> Self { - self.inner.object_type = object_type; + self.object_type = object_type; self } + #[inline] pub fn object_handle(mut self, object_handle: u64) -> Self { - self.inner.object_handle = object_handle; + self.object_handle = object_handle; self } + #[inline] pub fn heap_index(mut self, heap_index: u32) -> Self { - self.inner.heap_index = heap_index; + self.heap_index = heap_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceMemoryReportCallbackDataEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportMemoryHostPointerInfoEXT { +pub struct ImportMemoryHostPointerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub handle_type: ExternalMemoryHandleTypeFlags, pub p_host_pointer: *mut c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { +impl ::std::default::Default for ImportMemoryHostPointerInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT, p_next: ::std::ptr::null(), handle_type: ExternalMemoryHandleTypeFlags::default(), p_host_pointer: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl ImportMemoryHostPointerInfoEXT { - pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> { - ImportMemoryHostPointerInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> { - inner: ImportMemoryHostPointerInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {} -impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> { - type Target = ImportMemoryHostPointerInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT<'_> {} +impl<'a> ImportMemoryHostPointerInfoEXT<'a> { + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } + #[inline] pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self { - self.inner.p_host_pointer = host_pointer; + self.p_host_pointer = host_pointer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportMemoryHostPointerInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryHostPointerPropertiesEXT { +pub struct MemoryHostPointerPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_type_bits: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryHostPointerPropertiesEXT { +impl ::std::default::Default for MemoryHostPointerPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), memory_type_bits: u32::default(), + _marker: PhantomData, } } } -impl MemoryHostPointerPropertiesEXT { - pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> { - MemoryHostPointerPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { - inner: MemoryHostPointerPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { - type Target = MemoryHostPointerPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { +impl<'a> MemoryHostPointerPropertiesEXT<'a> { + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryHostPointerPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_imported_host_pointer_alignment: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), min_imported_host_pointer_alignment: DeviceSize::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExternalMemoryHostPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { - PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceExternalMemoryHostPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> { + #[inline] pub fn min_imported_host_pointer_alignment( mut self, min_imported_host_pointer_alignment: DeviceSize, ) -> Self { - self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; + self.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub primitive_overestimation_size: f32, @@ -26157,8 +17087,9 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { pub degenerate_lines_rasterized: Bool32, pub fully_covered_fragment_shader_input_variable: Bool32, pub conservative_rasterization_post_depth_coverage: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, @@ -26172,167 +17103,115 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti degenerate_lines_rasterized: Bool32::default(), fully_covered_fragment_shader_input_variable: Bool32::default(), conservative_rasterization_post_depth_coverage: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceConservativeRasterizationPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { - PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceConservativeRasterizationPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_> + for PhysicalDeviceConservativeRasterizationPropertiesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceConservativeRasterizationPropertiesEXT -{ -} -impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { +impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> { + #[inline] pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self { - self.inner.primitive_overestimation_size = primitive_overestimation_size; + self.primitive_overestimation_size = primitive_overestimation_size; self } + #[inline] pub fn max_extra_primitive_overestimation_size( mut self, max_extra_primitive_overestimation_size: f32, ) -> Self { - self.inner.max_extra_primitive_overestimation_size = - max_extra_primitive_overestimation_size; + self.max_extra_primitive_overestimation_size = max_extra_primitive_overestimation_size; self } + #[inline] pub fn extra_primitive_overestimation_size_granularity( mut self, extra_primitive_overestimation_size_granularity: f32, ) -> Self { - self.inner.extra_primitive_overestimation_size_granularity = + self.extra_primitive_overestimation_size_granularity = extra_primitive_overestimation_size_granularity; self } + #[inline] pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self { - self.inner.primitive_underestimation = primitive_underestimation.into(); + self.primitive_underestimation = primitive_underestimation.into(); self } + #[inline] pub fn conservative_point_and_line_rasterization( mut self, conservative_point_and_line_rasterization: bool, ) -> Self { - self.inner.conservative_point_and_line_rasterization = + self.conservative_point_and_line_rasterization = conservative_point_and_line_rasterization.into(); self } + #[inline] pub fn degenerate_triangles_rasterized( mut self, degenerate_triangles_rasterized: bool, ) -> Self { - self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into(); + self.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into(); self } + #[inline] pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self { - self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into(); + self.degenerate_lines_rasterized = degenerate_lines_rasterized.into(); self } + #[inline] pub fn fully_covered_fragment_shader_input_variable( mut self, fully_covered_fragment_shader_input_variable: bool, ) -> Self { - self.inner.fully_covered_fragment_shader_input_variable = + self.fully_covered_fragment_shader_input_variable = fully_covered_fragment_shader_input_variable.into(); self } + #[inline] pub fn conservative_rasterization_post_depth_coverage( mut self, conservative_rasterization_post_depth_coverage: bool, ) -> Self { - self.inner.conservative_rasterization_post_depth_coverage = + self.conservative_rasterization_post_depth_coverage = conservative_rasterization_post_depth_coverage.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CalibratedTimestampInfoEXT { +pub struct CalibratedTimestampInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub time_domain: TimeDomainEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CalibratedTimestampInfoEXT { +impl ::std::default::Default for CalibratedTimestampInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_EXT, p_next: ::std::ptr::null(), time_domain: TimeDomainEXT::default(), + _marker: PhantomData, } } } -impl CalibratedTimestampInfoEXT { - pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> { - CalibratedTimestampInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CalibratedTimestampInfoEXTBuilder<'a> { - inner: CalibratedTimestampInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> { - type Target = CalibratedTimestampInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { +impl<'a> CalibratedTimestampInfoEXT<'a> { + #[inline] pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self { - self.inner.time_domain = time_domain; + self.time_domain = time_domain; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CalibratedTimestampInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderCorePropertiesAMD { +pub struct PhysicalDeviceShaderCorePropertiesAMD<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_engine_count: u32, @@ -26349,8 +17228,9 @@ pub struct PhysicalDeviceShaderCorePropertiesAMD { pub min_vgpr_allocation: u32, pub max_vgpr_allocation: u32, pub vgpr_allocation_granularity: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { +impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, @@ -26369,176 +17249,134 @@ impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { min_vgpr_allocation: u32::default(), max_vgpr_allocation: u32::default(), vgpr_allocation_granularity: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderCorePropertiesAMD { - pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { - PhysicalDeviceShaderCorePropertiesAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { - inner: PhysicalDeviceShaderCorePropertiesAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { - type Target = PhysicalDeviceShaderCorePropertiesAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD<'_> {} +impl<'a> PhysicalDeviceShaderCorePropertiesAMD<'a> { + #[inline] pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self { - self.inner.shader_engine_count = shader_engine_count; + self.shader_engine_count = shader_engine_count; self } + #[inline] pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self { - self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count; + self.shader_arrays_per_engine_count = shader_arrays_per_engine_count; self } + #[inline] pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self { - self.inner.compute_units_per_shader_array = compute_units_per_shader_array; + self.compute_units_per_shader_array = compute_units_per_shader_array; self } + #[inline] pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self { - self.inner.simd_per_compute_unit = simd_per_compute_unit; + self.simd_per_compute_unit = simd_per_compute_unit; self } + #[inline] pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self { - self.inner.wavefronts_per_simd = wavefronts_per_simd; + self.wavefronts_per_simd = wavefronts_per_simd; self } + #[inline] pub fn wavefront_size(mut self, wavefront_size: u32) -> Self { - self.inner.wavefront_size = wavefront_size; + self.wavefront_size = wavefront_size; self } + #[inline] pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self { - self.inner.sgprs_per_simd = sgprs_per_simd; + self.sgprs_per_simd = sgprs_per_simd; self } + #[inline] pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self { - self.inner.min_sgpr_allocation = min_sgpr_allocation; + self.min_sgpr_allocation = min_sgpr_allocation; self } + #[inline] pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self { - self.inner.max_sgpr_allocation = max_sgpr_allocation; + self.max_sgpr_allocation = max_sgpr_allocation; self } + #[inline] pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self { - self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity; + self.sgpr_allocation_granularity = sgpr_allocation_granularity; self } + #[inline] pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self { - self.inner.vgprs_per_simd = vgprs_per_simd; + self.vgprs_per_simd = vgprs_per_simd; self } + #[inline] pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self { - self.inner.min_vgpr_allocation = min_vgpr_allocation; + self.min_vgpr_allocation = min_vgpr_allocation; self } + #[inline] pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self { - self.inner.max_vgpr_allocation = max_vgpr_allocation; + self.max_vgpr_allocation = max_vgpr_allocation; self } + #[inline] pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self { - self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity; + self.vgpr_allocation_granularity = vgpr_allocation_granularity; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderCoreProperties2AMD { +pub struct PhysicalDeviceShaderCoreProperties2AMD<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_core_features: ShaderCorePropertiesFlagsAMD, pub active_compute_unit_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD { +impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, p_next: ::std::ptr::null_mut(), shader_core_features: ShaderCorePropertiesFlagsAMD::default(), active_compute_unit_count: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderCoreProperties2AMD { - pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { - PhysicalDeviceShaderCoreProperties2AMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { - inner: PhysicalDeviceShaderCoreProperties2AMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { - type Target = PhysicalDeviceShaderCoreProperties2AMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD<'_> {} +impl<'a> PhysicalDeviceShaderCoreProperties2AMD<'a> { + #[inline] pub fn shader_core_features( mut self, shader_core_features: ShaderCorePropertiesFlagsAMD, ) -> Self { - self.inner.shader_core_features = shader_core_features; + self.shader_core_features = shader_core_features; self } + #[inline] pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self { - self.inner.active_compute_unit_count = active_compute_unit_count; + self.active_compute_unit_count = active_compute_unit_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationConservativeStateCreateInfoEXT { +pub struct PipelineRasterizationConservativeStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT, pub conservative_rasterization_mode: ConservativeRasterizationModeEXT, pub extra_primitive_overestimation_size: f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT { +impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, @@ -26546,72 +17384,42 @@ impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInf flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(), conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(), extra_primitive_overestimation_size: f32::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationConservativeStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { - PipelineRasterizationConservativeStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { - inner: PipelineRasterizationConservativeStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_> + for PipelineRasterizationConservativeStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationConservativeStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { - type Target = PipelineRasterizationConservativeStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineRasterizationConservativeStateCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn conservative_rasterization_mode( mut self, conservative_rasterization_mode: ConservativeRasterizationModeEXT, ) -> Self { - self.inner.conservative_rasterization_mode = conservative_rasterization_mode; + self.conservative_rasterization_mode = conservative_rasterization_mode; self } + #[inline] pub fn extra_primitive_overestimation_size( mut self, extra_primitive_overestimation_size: f32, ) -> Self { - self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size; + self.extra_primitive_overestimation_size = extra_primitive_overestimation_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDescriptorIndexingFeatures { +pub struct PhysicalDeviceDescriptorIndexingFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_input_attachment_array_dynamic_indexing: Bool32, @@ -26634,8 +17442,9 @@ pub struct PhysicalDeviceDescriptorIndexingFeatures { pub descriptor_binding_partially_bound: Bool32, pub descriptor_binding_variable_descriptor_count: Bool32, pub runtime_descriptor_array: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures { +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, @@ -26660,216 +17469,194 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures { descriptor_binding_partially_bound: Bool32::default(), descriptor_binding_variable_descriptor_count: Bool32::default(), runtime_descriptor_array: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDescriptorIndexingFeatures { - pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { - PhysicalDeviceDescriptorIndexingFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { - inner: PhysicalDeviceDescriptorIndexingFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { - type Target = PhysicalDeviceDescriptorIndexingFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures<'_> {} +impl<'a> PhysicalDeviceDescriptorIndexingFeatures<'a> { + #[inline] pub fn shader_input_attachment_array_dynamic_indexing( mut self, shader_input_attachment_array_dynamic_indexing: bool, ) -> Self { - self.inner.shader_input_attachment_array_dynamic_indexing = + self.shader_input_attachment_array_dynamic_indexing = shader_input_attachment_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_uniform_texel_buffer_array_dynamic_indexing( mut self, shader_uniform_texel_buffer_array_dynamic_indexing: bool, ) -> Self { - self.inner - .shader_uniform_texel_buffer_array_dynamic_indexing = + self.shader_uniform_texel_buffer_array_dynamic_indexing = shader_uniform_texel_buffer_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_storage_texel_buffer_array_dynamic_indexing( mut self, shader_storage_texel_buffer_array_dynamic_indexing: bool, ) -> Self { - self.inner - .shader_storage_texel_buffer_array_dynamic_indexing = + self.shader_storage_texel_buffer_array_dynamic_indexing = shader_storage_texel_buffer_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_uniform_buffer_array_non_uniform_indexing( mut self, shader_uniform_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_uniform_buffer_array_non_uniform_indexing = + self.shader_uniform_buffer_array_non_uniform_indexing = shader_uniform_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_sampled_image_array_non_uniform_indexing( mut self, shader_sampled_image_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_sampled_image_array_non_uniform_indexing = + self.shader_sampled_image_array_non_uniform_indexing = shader_sampled_image_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_storage_buffer_array_non_uniform_indexing( mut self, shader_storage_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_storage_buffer_array_non_uniform_indexing = + self.shader_storage_buffer_array_non_uniform_indexing = shader_storage_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_storage_image_array_non_uniform_indexing( mut self, shader_storage_image_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_storage_image_array_non_uniform_indexing = + self.shader_storage_image_array_non_uniform_indexing = shader_storage_image_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_input_attachment_array_non_uniform_indexing( mut self, shader_input_attachment_array_non_uniform_indexing: bool, ) -> Self { - self.inner - .shader_input_attachment_array_non_uniform_indexing = + self.shader_input_attachment_array_non_uniform_indexing = shader_input_attachment_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( mut self, shader_uniform_texel_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner - .shader_uniform_texel_buffer_array_non_uniform_indexing = + self.shader_uniform_texel_buffer_array_non_uniform_indexing = shader_uniform_texel_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_storage_texel_buffer_array_non_uniform_indexing( mut self, shader_storage_texel_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner - .shader_storage_texel_buffer_array_non_uniform_indexing = + self.shader_storage_texel_buffer_array_non_uniform_indexing = shader_storage_texel_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn descriptor_binding_uniform_buffer_update_after_bind( mut self, descriptor_binding_uniform_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_uniform_buffer_update_after_bind = + self.descriptor_binding_uniform_buffer_update_after_bind = descriptor_binding_uniform_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_sampled_image_update_after_bind( mut self, descriptor_binding_sampled_image_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_sampled_image_update_after_bind = + self.descriptor_binding_sampled_image_update_after_bind = descriptor_binding_sampled_image_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_storage_image_update_after_bind( mut self, descriptor_binding_storage_image_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_storage_image_update_after_bind = + self.descriptor_binding_storage_image_update_after_bind = descriptor_binding_storage_image_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_storage_buffer_update_after_bind( mut self, descriptor_binding_storage_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_storage_buffer_update_after_bind = + self.descriptor_binding_storage_buffer_update_after_bind = descriptor_binding_storage_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( mut self, descriptor_binding_uniform_texel_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_uniform_texel_buffer_update_after_bind = + self.descriptor_binding_uniform_texel_buffer_update_after_bind = descriptor_binding_uniform_texel_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_storage_texel_buffer_update_after_bind( mut self, descriptor_binding_storage_texel_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_storage_texel_buffer_update_after_bind = + self.descriptor_binding_storage_texel_buffer_update_after_bind = descriptor_binding_storage_texel_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_update_unused_while_pending( mut self, descriptor_binding_update_unused_while_pending: bool, ) -> Self { - self.inner.descriptor_binding_update_unused_while_pending = + self.descriptor_binding_update_unused_while_pending = descriptor_binding_update_unused_while_pending.into(); self } + #[inline] pub fn descriptor_binding_partially_bound( mut self, descriptor_binding_partially_bound: bool, ) -> Self { - self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); + self.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); self } + #[inline] pub fn descriptor_binding_variable_descriptor_count( mut self, descriptor_binding_variable_descriptor_count: bool, ) -> Self { - self.inner.descriptor_binding_variable_descriptor_count = + self.descriptor_binding_variable_descriptor_count = descriptor_binding_variable_descriptor_count.into(); self } + #[inline] pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self { - self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); + self.runtime_descriptor_array = runtime_descriptor_array.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDescriptorIndexingProperties { +pub struct PhysicalDeviceDescriptorIndexingProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_update_after_bind_descriptors_in_all_pools: u32, @@ -26895,8 +17682,9 @@ pub struct PhysicalDeviceDescriptorIndexingProperties { pub max_descriptor_set_update_after_bind_sampled_images: u32, pub max_descriptor_set_update_after_bind_storage_images: u32, pub max_descriptor_set_update_after_bind_input_attachments: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties { +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, @@ -26924,435 +17712,315 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties { max_descriptor_set_update_after_bind_sampled_images: u32::default(), max_descriptor_set_update_after_bind_storage_images: u32::default(), max_descriptor_set_update_after_bind_input_attachments: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDescriptorIndexingProperties { - pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { - PhysicalDeviceDescriptorIndexingPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { - inner: PhysicalDeviceDescriptorIndexingProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { - type Target = PhysicalDeviceDescriptorIndexingProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties<'_> {} +impl<'a> PhysicalDeviceDescriptorIndexingProperties<'a> { + #[inline] pub fn max_update_after_bind_descriptors_in_all_pools( mut self, max_update_after_bind_descriptors_in_all_pools: u32, ) -> Self { - self.inner.max_update_after_bind_descriptors_in_all_pools = + self.max_update_after_bind_descriptors_in_all_pools = max_update_after_bind_descriptors_in_all_pools; self } + #[inline] pub fn shader_uniform_buffer_array_non_uniform_indexing_native( mut self, shader_uniform_buffer_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_uniform_buffer_array_non_uniform_indexing_native = + self.shader_uniform_buffer_array_non_uniform_indexing_native = shader_uniform_buffer_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_sampled_image_array_non_uniform_indexing_native( mut self, shader_sampled_image_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_sampled_image_array_non_uniform_indexing_native = + self.shader_sampled_image_array_non_uniform_indexing_native = shader_sampled_image_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_storage_buffer_array_non_uniform_indexing_native( mut self, shader_storage_buffer_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_storage_buffer_array_non_uniform_indexing_native = + self.shader_storage_buffer_array_non_uniform_indexing_native = shader_storage_buffer_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_storage_image_array_non_uniform_indexing_native( mut self, shader_storage_image_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_storage_image_array_non_uniform_indexing_native = + self.shader_storage_image_array_non_uniform_indexing_native = shader_storage_image_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_input_attachment_array_non_uniform_indexing_native( mut self, shader_input_attachment_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_input_attachment_array_non_uniform_indexing_native = + self.shader_input_attachment_array_non_uniform_indexing_native = shader_input_attachment_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn robust_buffer_access_update_after_bind( mut self, robust_buffer_access_update_after_bind: bool, ) -> Self { - self.inner.robust_buffer_access_update_after_bind = - robust_buffer_access_update_after_bind.into(); + self.robust_buffer_access_update_after_bind = robust_buffer_access_update_after_bind.into(); self } + #[inline] pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self { - self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_samplers( mut self, max_per_stage_descriptor_update_after_bind_samplers: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_samplers = + self.max_per_stage_descriptor_update_after_bind_samplers = max_per_stage_descriptor_update_after_bind_samplers; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( mut self, max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_uniform_buffers = + self.max_per_stage_descriptor_update_after_bind_uniform_buffers = max_per_stage_descriptor_update_after_bind_uniform_buffers; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( mut self, max_per_stage_descriptor_update_after_bind_storage_buffers: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_storage_buffers = + self.max_per_stage_descriptor_update_after_bind_storage_buffers = max_per_stage_descriptor_update_after_bind_storage_buffers; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_sampled_images( mut self, max_per_stage_descriptor_update_after_bind_sampled_images: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_sampled_images = + self.max_per_stage_descriptor_update_after_bind_sampled_images = max_per_stage_descriptor_update_after_bind_sampled_images; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_storage_images( mut self, max_per_stage_descriptor_update_after_bind_storage_images: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_storage_images = + self.max_per_stage_descriptor_update_after_bind_storage_images = max_per_stage_descriptor_update_after_bind_storage_images; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_input_attachments( mut self, max_per_stage_descriptor_update_after_bind_input_attachments: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_input_attachments = + self.max_per_stage_descriptor_update_after_bind_input_attachments = max_per_stage_descriptor_update_after_bind_input_attachments; self } + #[inline] pub fn max_per_stage_update_after_bind_resources( mut self, max_per_stage_update_after_bind_resources: u32, ) -> Self { - self.inner.max_per_stage_update_after_bind_resources = - max_per_stage_update_after_bind_resources; + self.max_per_stage_update_after_bind_resources = max_per_stage_update_after_bind_resources; self } + #[inline] pub fn max_descriptor_set_update_after_bind_samplers( mut self, max_descriptor_set_update_after_bind_samplers: u32, ) -> Self { - self.inner.max_descriptor_set_update_after_bind_samplers = + self.max_descriptor_set_update_after_bind_samplers = max_descriptor_set_update_after_bind_samplers; self } + #[inline] pub fn max_descriptor_set_update_after_bind_uniform_buffers( mut self, max_descriptor_set_update_after_bind_uniform_buffers: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_uniform_buffers = + self.max_descriptor_set_update_after_bind_uniform_buffers = max_descriptor_set_update_after_bind_uniform_buffers; self } + #[inline] pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic = max_descriptor_set_update_after_bind_uniform_buffers_dynamic; self } + #[inline] pub fn max_descriptor_set_update_after_bind_storage_buffers( mut self, max_descriptor_set_update_after_bind_storage_buffers: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_storage_buffers = + self.max_descriptor_set_update_after_bind_storage_buffers = max_descriptor_set_update_after_bind_storage_buffers; self } + #[inline] pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + self.max_descriptor_set_update_after_bind_storage_buffers_dynamic = max_descriptor_set_update_after_bind_storage_buffers_dynamic; self } + #[inline] pub fn max_descriptor_set_update_after_bind_sampled_images( mut self, max_descriptor_set_update_after_bind_sampled_images: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_sampled_images = + self.max_descriptor_set_update_after_bind_sampled_images = max_descriptor_set_update_after_bind_sampled_images; self } + #[inline] pub fn max_descriptor_set_update_after_bind_storage_images( mut self, max_descriptor_set_update_after_bind_storage_images: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_storage_images = + self.max_descriptor_set_update_after_bind_storage_images = max_descriptor_set_update_after_bind_storage_images; self } + #[inline] pub fn max_descriptor_set_update_after_bind_input_attachments( mut self, max_descriptor_set_update_after_bind_input_attachments: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_input_attachments = + self.max_descriptor_set_update_after_bind_input_attachments = max_descriptor_set_update_after_bind_input_attachments; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetLayoutBindingFlagsCreateInfo { +pub struct DescriptorSetLayoutBindingFlagsCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub binding_count: u32, pub p_binding_flags: *const DescriptorBindingFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo { +impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, p_next: ::std::ptr::null(), binding_count: u32::default(), p_binding_flags: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DescriptorSetLayoutBindingFlagsCreateInfo { - pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { - DescriptorSetLayoutBindingFlagsCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { - inner: DescriptorSetLayoutBindingFlagsCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDescriptorSetLayoutCreateInfo - for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_> -{ -} -unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {} -impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { - type Target = DescriptorSetLayoutBindingFlagsCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo<'_> {} +impl<'a> DescriptorSetLayoutBindingFlagsCreateInfo<'a> { + #[inline] pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self { - self.inner.binding_count = binding_flags.len() as _; - self.inner.p_binding_flags = binding_flags.as_ptr(); + self.binding_count = binding_flags.len() as _; + self.p_binding_flags = binding_flags.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetVariableDescriptorCountAllocateInfo { +pub struct DescriptorSetVariableDescriptorCountAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub descriptor_set_count: u32, pub p_descriptor_counts: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo { +impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, p_next: ::std::ptr::null(), descriptor_set_count: u32::default(), p_descriptor_counts: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DescriptorSetVariableDescriptorCountAllocateInfo { - pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { - DescriptorSetVariableDescriptorCountAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { - inner: DescriptorSetVariableDescriptorCountAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsDescriptorSetAllocateInfo - for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_> + for DescriptorSetVariableDescriptorCountAllocateInfo<'_> { } -unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {} -impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { - type Target = DescriptorSetVariableDescriptorCountAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { +impl<'a> DescriptorSetVariableDescriptorCountAllocateInfo<'a> { + #[inline] pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self { - self.inner.descriptor_set_count = descriptor_counts.len() as _; - self.inner.p_descriptor_counts = descriptor_counts.as_ptr(); + self.descriptor_set_count = descriptor_counts.len() as _; + self.p_descriptor_counts = descriptor_counts.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetVariableDescriptorCountLayoutSupport { +pub struct DescriptorSetVariableDescriptorCountLayoutSupport<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_variable_descriptor_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport { +impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, p_next: ::std::ptr::null_mut(), max_variable_descriptor_count: u32::default(), + _marker: PhantomData, } } } -impl DescriptorSetVariableDescriptorCountLayoutSupport { - pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { - DescriptorSetVariableDescriptorCountLayoutSupportBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { - inner: DescriptorSetVariableDescriptorCountLayoutSupport, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsDescriptorSetLayoutSupport - for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_> + for DescriptorSetVariableDescriptorCountLayoutSupport<'_> { } -unsafe impl ExtendsDescriptorSetLayoutSupport - for DescriptorSetVariableDescriptorCountLayoutSupport -{ -} -impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { - type Target = DescriptorSetVariableDescriptorCountLayoutSupport; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { +impl<'a> DescriptorSetVariableDescriptorCountLayoutSupport<'a> { + #[inline] pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self { - self.inner.max_variable_descriptor_count = max_variable_descriptor_count; + self.max_variable_descriptor_count = max_variable_descriptor_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AttachmentDescription2 { +pub struct AttachmentDescription2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: AttachmentDescriptionFlags, @@ -27364,8 +18032,9 @@ pub struct AttachmentDescription2 { pub stencil_store_op: AttachmentStoreOp, pub initial_layout: ImageLayout, pub final_layout: ImageLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AttachmentDescription2 { +impl ::std::default::Default for AttachmentDescription2<'_> { fn default() -> Self { Self { s_type: StructureType::ATTACHMENT_DESCRIPTION_2, @@ -27379,104 +18048,85 @@ impl ::std::default::Default for AttachmentDescription2 { stencil_store_op: AttachmentStoreOp::default(), initial_layout: ImageLayout::default(), final_layout: ImageLayout::default(), + _marker: PhantomData, } } } -impl AttachmentDescription2 { - pub fn builder<'a>() -> AttachmentDescription2Builder<'a> { - AttachmentDescription2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentDescription2Builder<'a> { - inner: AttachmentDescription2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsAttachmentDescription2 {} -impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> { - type Target = AttachmentDescription2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentDescription2Builder<'a> { +impl<'a> AttachmentDescription2<'a> { + #[inline] pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn samples(mut self, samples: SampleCountFlags) -> Self { - self.inner.samples = samples; + self.samples = samples; self } + #[inline] pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { - self.inner.load_op = load_op; + self.load_op = load_op; self } + #[inline] pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { - self.inner.store_op = store_op; + self.store_op = store_op; self } + #[inline] pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self { - self.inner.stencil_load_op = stencil_load_op; + self.stencil_load_op = stencil_load_op; self } + #[inline] pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self { - self.inner.stencil_store_op = stencil_store_op; + self.stencil_store_op = stencil_store_op; self } + #[inline] pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { - self.inner.initial_layout = initial_layout; + self.initial_layout = initial_layout; self } + #[inline] pub fn final_layout(mut self, final_layout: ImageLayout) -> Self { - self.inner.final_layout = final_layout; + self.final_layout = final_layout; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentDescription2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AttachmentReference2 { +pub struct AttachmentReference2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub attachment: u32, pub layout: ImageLayout, pub aspect_mask: ImageAspectFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AttachmentReference2 { +impl ::std::default::Default for AttachmentReference2<'_> { fn default() -> Self { Self { s_type: StructureType::ATTACHMENT_REFERENCE_2, @@ -27484,88 +18134,63 @@ impl ::std::default::Default for AttachmentReference2 { attachment: u32::default(), layout: ImageLayout::default(), aspect_mask: ImageAspectFlags::default(), + _marker: PhantomData, } } } -impl AttachmentReference2 { - pub fn builder<'a>() -> AttachmentReference2Builder<'a> { - AttachmentReference2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentReference2Builder<'a> { - inner: AttachmentReference2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsAttachmentReference2 {} -impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> { - type Target = AttachmentReference2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentReference2Builder<'a> { +impl<'a> AttachmentReference2<'a> { + #[inline] pub fn attachment(mut self, attachment: u32) -> Self { - self.inner.attachment = attachment; + self.attachment = attachment; self } + #[inline] pub fn layout(mut self, layout: ImageLayout) -> Self { - self.inner.layout = layout; + self.layout = layout; self } + #[inline] pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { - self.inner.aspect_mask = aspect_mask; + self.aspect_mask = aspect_mask; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentReference2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassDescription2 { +pub struct SubpassDescription2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SubpassDescriptionFlags, pub pipeline_bind_point: PipelineBindPoint, pub view_mask: u32, pub input_attachment_count: u32, - pub p_input_attachments: *const AttachmentReference2, + pub p_input_attachments: *const AttachmentReference2<'a>, pub color_attachment_count: u32, - pub p_color_attachments: *const AttachmentReference2, - pub p_resolve_attachments: *const AttachmentReference2, - pub p_depth_stencil_attachment: *const AttachmentReference2, + pub p_color_attachments: *const AttachmentReference2<'a>, + pub p_resolve_attachments: *const AttachmentReference2<'a>, + pub p_depth_stencil_attachment: *const AttachmentReference2<'a>, pub preserve_attachment_count: u32, pub p_preserve_attachments: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassDescription2 { +impl ::std::default::Default for SubpassDescription2<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_DESCRIPTION_2, @@ -27581,100 +18206,79 @@ impl ::std::default::Default for SubpassDescription2 { p_depth_stencil_attachment: ::std::ptr::null(), preserve_attachment_count: u32::default(), p_preserve_attachments: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubpassDescription2 { - pub fn builder<'a>() -> SubpassDescription2Builder<'a> { - SubpassDescription2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassDescription2Builder<'a> { - inner: SubpassDescription2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSubpassDescription2 {} -impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> { - type Target = SubpassDescription2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassDescription2Builder<'a> { +impl<'a> SubpassDescription2<'a> { + #[inline] pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { - self.inner.pipeline_bind_point = pipeline_bind_point; + self.pipeline_bind_point = pipeline_bind_point; self } + #[inline] pub fn view_mask(mut self, view_mask: u32) -> Self { - self.inner.view_mask = view_mask; + self.view_mask = view_mask; self } + #[inline] pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self { - self.inner.input_attachment_count = input_attachments.len() as _; - self.inner.p_input_attachments = input_attachments.as_ptr(); + self.input_attachment_count = input_attachments.len() as _; + self.p_input_attachments = input_attachments.as_ptr(); self } + #[inline] pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self { - self.inner.color_attachment_count = color_attachments.len() as _; - self.inner.p_color_attachments = color_attachments.as_ptr(); + self.color_attachment_count = color_attachments.len() as _; + self.p_color_attachments = color_attachments.as_ptr(); self } + #[inline] pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self { - self.inner.color_attachment_count = resolve_attachments.len() as _; - self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self.color_attachment_count = resolve_attachments.len() as _; + self.p_resolve_attachments = resolve_attachments.as_ptr(); self } + #[inline] pub fn depth_stencil_attachment( mut self, - depth_stencil_attachment: &'a AttachmentReference2, + depth_stencil_attachment: &'a AttachmentReference2<'a>, ) -> Self { - self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self.p_depth_stencil_attachment = depth_stencil_attachment; self } + #[inline] pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self { - self.inner.preserve_attachment_count = preserve_attachments.len() as _; - self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self.preserve_attachment_count = preserve_attachments.len() as _; + self.p_preserve_attachments = preserve_attachments.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassDescription2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassDependency2 { +pub struct SubpassDependency2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_subpass: u32, @@ -27685,8 +18289,9 @@ pub struct SubpassDependency2 { pub dst_access_mask: AccessFlags, pub dependency_flags: DependencyFlags, pub view_offset: i32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassDependency2 { +impl ::std::default::Default for SubpassDependency2<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_DEPENDENCY_2, @@ -27699,106 +18304,86 @@ impl ::std::default::Default for SubpassDependency2 { dst_access_mask: AccessFlags::default(), dependency_flags: DependencyFlags::default(), view_offset: i32::default(), + _marker: PhantomData, } } } -impl SubpassDependency2 { - pub fn builder<'a>() -> SubpassDependency2Builder<'a> { - SubpassDependency2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassDependency2Builder<'a> { - inner: SubpassDependency2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSubpassDependency2 {} -impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> { - type Target = SubpassDependency2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassDependency2Builder<'a> { +impl<'a> SubpassDependency2<'a> { + #[inline] pub fn src_subpass(mut self, src_subpass: u32) -> Self { - self.inner.src_subpass = src_subpass; + self.src_subpass = src_subpass; self } + #[inline] pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { - self.inner.dst_subpass = dst_subpass; + self.dst_subpass = dst_subpass; self } + #[inline] pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self { - self.inner.src_stage_mask = src_stage_mask; + self.src_stage_mask = src_stage_mask; self } + #[inline] pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self { - self.inner.dst_stage_mask = dst_stage_mask; + self.dst_stage_mask = dst_stage_mask; self } + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } + #[inline] pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { - self.inner.dependency_flags = dependency_flags; + self.dependency_flags = dependency_flags; self } + #[inline] pub fn view_offset(mut self, view_offset: i32) -> Self { - self.inner.view_offset = view_offset; + self.view_offset = view_offset; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassDependency2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassCreateInfo2 { +pub struct RenderPassCreateInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: RenderPassCreateFlags, pub attachment_count: u32, - pub p_attachments: *const AttachmentDescription2, + pub p_attachments: *const AttachmentDescription2<'a>, pub subpass_count: u32, - pub p_subpasses: *const SubpassDescription2, + pub p_subpasses: *const SubpassDescription2<'a>, pub dependency_count: u32, - pub p_dependencies: *const SubpassDependency2, + pub p_dependencies: *const SubpassDependency2<'a>, pub correlated_view_mask_count: u32, pub p_correlated_view_masks: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassCreateInfo2 { +impl ::std::default::Default for RenderPassCreateInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_CREATE_INFO_2, @@ -27812,395 +18397,228 @@ impl ::std::default::Default for RenderPassCreateInfo2 { p_dependencies: ::std::ptr::null(), correlated_view_mask_count: u32::default(), p_correlated_view_masks: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassCreateInfo2 { - pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> { - RenderPassCreateInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassCreateInfo2Builder<'a> { - inner: RenderPassCreateInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsRenderPassCreateInfo2 {} -impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> { - type Target = RenderPassCreateInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassCreateInfo2Builder<'a> { +impl<'a> RenderPassCreateInfo2<'a> { + #[inline] pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self { - self.inner.attachment_count = attachments.len() as _; - self.inner.p_attachments = attachments.as_ptr(); + self.attachment_count = attachments.len() as _; + self.p_attachments = attachments.as_ptr(); self } + #[inline] pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self { - self.inner.subpass_count = subpasses.len() as _; - self.inner.p_subpasses = subpasses.as_ptr(); + self.subpass_count = subpasses.len() as _; + self.p_subpasses = subpasses.as_ptr(); self } + #[inline] pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self { - self.inner.dependency_count = dependencies.len() as _; - self.inner.p_dependencies = dependencies.as_ptr(); + self.dependency_count = dependencies.len() as _; + self.p_dependencies = dependencies.as_ptr(); self } + #[inline] pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self { - self.inner.correlated_view_mask_count = correlated_view_masks.len() as _; - self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr(); + self.correlated_view_mask_count = correlated_view_masks.len() as _; + self.p_correlated_view_masks = correlated_view_masks.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassCreateInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassBeginInfo { +pub struct SubpassBeginInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub contents: SubpassContents, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassBeginInfo { +impl ::std::default::Default for SubpassBeginInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_BEGIN_INFO, p_next: ::std::ptr::null(), contents: SubpassContents::default(), + _marker: PhantomData, } } } -impl SubpassBeginInfo { - pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> { - SubpassBeginInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassBeginInfoBuilder<'a> { - inner: SubpassBeginInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> { - type Target = SubpassBeginInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassBeginInfoBuilder<'a> { +impl<'a> SubpassBeginInfo<'a> { + #[inline] pub fn contents(mut self, contents: SubpassContents) -> Self { - self.inner.contents = contents; + self.contents = contents; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassBeginInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassEndInfo { +pub struct SubpassEndInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassEndInfo { +impl ::std::default::Default for SubpassEndInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_END_INFO, p_next: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubpassEndInfo { - pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> { - SubpassEndInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassEndInfoBuilder<'a> { - inner: SubpassEndInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSubpassEndInfo {} -impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> { - type Target = SubpassEndInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassEndInfoBuilder<'a> { +impl<'a> SubpassEndInfo<'a> { #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassEndInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTimelineSemaphoreFeatures { +pub struct PhysicalDeviceTimelineSemaphoreFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub timeline_semaphore: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures { +impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, p_next: ::std::ptr::null_mut(), timeline_semaphore: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTimelineSemaphoreFeatures { - pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { - PhysicalDeviceTimelineSemaphoreFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { - inner: PhysicalDeviceTimelineSemaphoreFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { - type Target = PhysicalDeviceTimelineSemaphoreFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures<'_> {} +impl<'a> PhysicalDeviceTimelineSemaphoreFeatures<'a> { + #[inline] pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { - self.inner.timeline_semaphore = timeline_semaphore.into(); + self.timeline_semaphore = timeline_semaphore.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTimelineSemaphoreProperties { +pub struct PhysicalDeviceTimelineSemaphoreProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_timeline_semaphore_value_difference: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties { +impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, p_next: ::std::ptr::null_mut(), max_timeline_semaphore_value_difference: u64::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTimelineSemaphoreProperties { - pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { - PhysicalDeviceTimelineSemaphorePropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { - inner: PhysicalDeviceTimelineSemaphoreProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { - type Target = PhysicalDeviceTimelineSemaphoreProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties<'_> {} +impl<'a> PhysicalDeviceTimelineSemaphoreProperties<'a> { + #[inline] pub fn max_timeline_semaphore_value_difference( mut self, max_timeline_semaphore_value_difference: u64, ) -> Self { - self.inner.max_timeline_semaphore_value_difference = - max_timeline_semaphore_value_difference; + self.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreTypeCreateInfo { +pub struct SemaphoreTypeCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore_type: SemaphoreType, pub initial_value: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreTypeCreateInfo { +impl ::std::default::Default for SemaphoreTypeCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO, p_next: ::std::ptr::null(), semaphore_type: SemaphoreType::default(), initial_value: u64::default(), + _marker: PhantomData, } } } -impl SemaphoreTypeCreateInfo { - pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> { - SemaphoreTypeCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreTypeCreateInfoBuilder<'a> { - inner: SemaphoreTypeCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {} -unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {} -unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {} -impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> { - type Target = SemaphoreTypeCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreTypeCreateInfoBuilder<'a> { +unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo<'_> {} +unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo<'_> {} +impl<'a> SemaphoreTypeCreateInfo<'a> { + #[inline] pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self { - self.inner.semaphore_type = semaphore_type; + self.semaphore_type = semaphore_type; self } + #[inline] pub fn initial_value(mut self, initial_value: u64) -> Self { - self.inner.initial_value = initial_value; + self.initial_value = initial_value; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreTypeCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct TimelineSemaphoreSubmitInfo { +pub struct TimelineSemaphoreSubmitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub wait_semaphore_value_count: u32, pub p_wait_semaphore_values: *const u64, pub signal_semaphore_value_count: u32, pub p_signal_semaphore_values: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for TimelineSemaphoreSubmitInfo { +impl ::std::default::Default for TimelineSemaphoreSubmitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO, @@ -28209,68 +18627,40 @@ impl ::std::default::Default for TimelineSemaphoreSubmitInfo { p_wait_semaphore_values: ::std::ptr::null(), signal_semaphore_value_count: u32::default(), p_signal_semaphore_values: ::std::ptr::null(), + _marker: PhantomData, } } } -impl TimelineSemaphoreSubmitInfo { - pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> { - TimelineSemaphoreSubmitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct TimelineSemaphoreSubmitInfoBuilder<'a> { - inner: TimelineSemaphoreSubmitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {} -unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {} -unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {} -impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> { - type Target = TimelineSemaphoreSubmitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> { +unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo<'_> {} +unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo<'_> {} +impl<'a> TimelineSemaphoreSubmitInfo<'a> { + #[inline] pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self { - self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _; - self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self.wait_semaphore_value_count = wait_semaphore_values.len() as _; + self.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); self } + #[inline] pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self { - self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _; - self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self.signal_semaphore_value_count = signal_semaphore_values.len() as _; + self.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> TimelineSemaphoreSubmitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreWaitInfo { +pub struct SemaphoreWaitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SemaphoreWaitFlags, pub semaphore_count: u32, pub p_semaphores: *const Semaphore, pub p_values: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreWaitInfo { +impl ::std::default::Default for SemaphoreWaitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_WAIT_INFO, @@ -28279,114 +18669,62 @@ impl ::std::default::Default for SemaphoreWaitInfo { semaphore_count: u32::default(), p_semaphores: ::std::ptr::null(), p_values: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SemaphoreWaitInfo { - pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> { - SemaphoreWaitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreWaitInfoBuilder<'a> { - inner: SemaphoreWaitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> { - type Target = SemaphoreWaitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreWaitInfoBuilder<'a> { +impl<'a> SemaphoreWaitInfo<'a> { + #[inline] pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self { - self.inner.semaphore_count = semaphores.len() as _; - self.inner.p_semaphores = semaphores.as_ptr(); + self.semaphore_count = semaphores.len() as _; + self.p_semaphores = semaphores.as_ptr(); self } + #[inline] pub fn values(mut self, values: &'a [u64]) -> Self { - self.inner.semaphore_count = values.len() as _; - self.inner.p_values = values.as_ptr(); + self.semaphore_count = values.len() as _; + self.p_values = values.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreWaitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreSignalInfo { +pub struct SemaphoreSignalInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub value: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreSignalInfo { +impl ::std::default::Default for SemaphoreSignalInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_SIGNAL_INFO, p_next: ::std::ptr::null(), semaphore: Semaphore::default(), value: u64::default(), + _marker: PhantomData, } } } -impl SemaphoreSignalInfo { - pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> { - SemaphoreSignalInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreSignalInfoBuilder<'a> { - inner: SemaphoreSignalInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> { - type Target = SemaphoreSignalInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreSignalInfoBuilder<'a> { +impl<'a> SemaphoreSignalInfo<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn value(mut self, value: u64) -> Self { - self.inner.value = value; + self.value = value; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreSignalInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -28397,185 +18735,99 @@ pub struct VertexInputBindingDivisorDescriptionEXT { pub divisor: u32, } impl VertexInputBindingDivisorDescriptionEXT { - pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { - VertexInputBindingDivisorDescriptionEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> { - inner: VertexInputBindingDivisorDescriptionEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { - type Target = VertexInputBindingDivisorDescriptionEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } + #[inline] pub fn divisor(mut self, divisor: u32) -> Self { - self.inner.divisor = divisor; + self.divisor = divisor; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineVertexInputDivisorStateCreateInfoEXT { +pub struct PipelineVertexInputDivisorStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vertex_binding_divisor_count: u32, pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { +impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), vertex_binding_divisor_count: u32::default(), p_vertex_binding_divisors: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineVertexInputDivisorStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { - PipelineVertexInputDivisorStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { - inner: PipelineVertexInputDivisorStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineVertexInputStateCreateInfo - for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_> + for PipelineVertexInputDivisorStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineVertexInputStateCreateInfo - for PipelineVertexInputDivisorStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { - type Target = PipelineVertexInputDivisorStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineVertexInputDivisorStateCreateInfoEXT<'a> { + #[inline] pub fn vertex_binding_divisors( mut self, vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], ) -> Self { - self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _; - self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr(); + self.vertex_binding_divisor_count = vertex_binding_divisors.len() as _; + self.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_vertex_attrib_divisor: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), max_vertex_attrib_divisor: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { - PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_> + for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { +impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> { + #[inline] pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self { - self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self.max_vertex_attrib_divisor = max_vertex_attrib_divisor; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePCIBusInfoPropertiesEXT { +pub struct PhysicalDevicePCIBusInfoPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub pci_domain: u32, pub pci_bus: u32, pub pci_device: u32, pub pci_function: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT { +impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, @@ -28584,229 +18836,127 @@ impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT { pci_bus: u32::default(), pci_device: u32::default(), pci_function: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePCIBusInfoPropertiesEXT { - pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { - PhysicalDevicePCIBusInfoPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { - inner: PhysicalDevicePCIBusInfoPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { - type Target = PhysicalDevicePCIBusInfoPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT<'_> {} +impl<'a> PhysicalDevicePCIBusInfoPropertiesEXT<'a> { + #[inline] pub fn pci_domain(mut self, pci_domain: u32) -> Self { - self.inner.pci_domain = pci_domain; + self.pci_domain = pci_domain; self } + #[inline] pub fn pci_bus(mut self, pci_bus: u32) -> Self { - self.inner.pci_bus = pci_bus; + self.pci_bus = pci_bus; self } + #[inline] pub fn pci_device(mut self, pci_device: u32) -> Self { - self.inner.pci_device = pci_device; + self.pci_device = pci_device; self } + #[inline] pub fn pci_function(mut self, pci_function: u32) -> Self { - self.inner.pci_function = pci_function; + self.pci_function = pci_function; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportAndroidHardwareBufferInfoANDROID { +pub struct ImportAndroidHardwareBufferInfoANDROID<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: *mut AHardwareBuffer, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { +impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, p_next: ::std::ptr::null(), buffer: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl ImportAndroidHardwareBufferInfoANDROID { - pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { - ImportAndroidHardwareBufferInfoANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { - inner: ImportAndroidHardwareBufferInfoANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {} -impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { - type Target = ImportAndroidHardwareBufferInfoANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID<'_> {} +impl<'a> ImportAndroidHardwareBufferInfoANDROID<'a> { + #[inline] pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AndroidHardwareBufferUsageANDROID { +pub struct AndroidHardwareBufferUsageANDROID<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub android_hardware_buffer_usage: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { +impl ::std::default::Default for AndroidHardwareBufferUsageANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, p_next: ::std::ptr::null_mut(), android_hardware_buffer_usage: u64::default(), + _marker: PhantomData, } } } -impl AndroidHardwareBufferUsageANDROID { - pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> { - AndroidHardwareBufferUsageANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> { - inner: AndroidHardwareBufferUsageANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {} -unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {} -impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> { - type Target = AndroidHardwareBufferUsageANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> { +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID<'_> {} +impl<'a> AndroidHardwareBufferUsageANDROID<'a> { + #[inline] pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self { - self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage; + self.android_hardware_buffer_usage = android_hardware_buffer_usage; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AndroidHardwareBufferUsageANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AndroidHardwareBufferPropertiesANDROID { +pub struct AndroidHardwareBufferPropertiesANDROID<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub allocation_size: DeviceSize, pub memory_type_bits: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { +impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, p_next: ::std::ptr::null_mut(), allocation_size: DeviceSize::default(), memory_type_bits: u32::default(), + _marker: PhantomData, } } } -impl AndroidHardwareBufferPropertiesANDROID { - pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { - AndroidHardwareBufferPropertiesANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { - inner: AndroidHardwareBufferPropertiesANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {} -impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { - type Target = AndroidHardwareBufferPropertiesANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { +impl<'a> AndroidHardwareBufferPropertiesANDROID<'a> { + #[inline] pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { - self.inner.allocation_size = allocation_size; + self.allocation_size = allocation_size; self } + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -28815,77 +18965,44 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryGetAndroidHardwareBufferInfoANDROID { +pub struct MemoryGetAndroidHardwareBufferInfoANDROID<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { +impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, p_next: ::std::ptr::null(), memory: DeviceMemory::default(), + _marker: PhantomData, } } } -impl MemoryGetAndroidHardwareBufferInfoANDROID { - pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { - MemoryGetAndroidHardwareBufferInfoANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { - inner: MemoryGetAndroidHardwareBufferInfoANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { - type Target = MemoryGetAndroidHardwareBufferInfoANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { +impl<'a> MemoryGetAndroidHardwareBufferInfoANDROID<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AndroidHardwareBufferFormatPropertiesANDROID { +pub struct AndroidHardwareBufferFormatPropertiesANDROID<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub format: Format, @@ -28896,8 +19013,9 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROID { pub suggested_ycbcr_range: SamplerYcbcrRange, pub suggested_x_chroma_offset: ChromaLocation, pub suggested_y_chroma_offset: ChromaLocation, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { +impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, @@ -28910,219 +19028,135 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { suggested_ycbcr_range: SamplerYcbcrRange::default(), suggested_x_chroma_offset: ChromaLocation::default(), suggested_y_chroma_offset: ChromaLocation::default(), + _marker: PhantomData, } } } -impl AndroidHardwareBufferFormatPropertiesANDROID { - pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { - AndroidHardwareBufferFormatPropertiesANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { - inner: AndroidHardwareBufferFormatPropertiesANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID - for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_> + for AndroidHardwareBufferFormatPropertiesANDROID<'_> { } -unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID - for AndroidHardwareBufferFormatPropertiesANDROID -{ -} -impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { - type Target = AndroidHardwareBufferFormatPropertiesANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { +impl<'a> AndroidHardwareBufferFormatPropertiesANDROID<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn external_format(mut self, external_format: u64) -> Self { - self.inner.external_format = external_format; + self.external_format = external_format; self } + #[inline] pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { - self.inner.format_features = format_features; + self.format_features = format_features; self } + #[inline] pub fn sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> Self { - self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; self } + #[inline] pub fn suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> Self { - self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self.suggested_ycbcr_model = suggested_ycbcr_model; self } + #[inline] pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { - self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self.suggested_ycbcr_range = suggested_ycbcr_range; self } + #[inline] pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { - self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self.suggested_x_chroma_offset = suggested_x_chroma_offset; self } + #[inline] pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { - self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self.suggested_y_chroma_offset = suggested_y_chroma_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferInheritanceConditionalRenderingInfoEXT { +pub struct CommandBufferInheritanceConditionalRenderingInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub conditional_rendering_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT { +impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, p_next: ::std::ptr::null(), conditional_rendering_enable: Bool32::default(), + _marker: PhantomData, } } } -impl CommandBufferInheritanceConditionalRenderingInfoEXT { - pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { - CommandBufferInheritanceConditionalRenderingInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { - inner: CommandBufferInheritanceConditionalRenderingInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsCommandBufferInheritanceInfo - for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_> + for CommandBufferInheritanceConditionalRenderingInfoEXT<'_> { } -unsafe impl ExtendsCommandBufferInheritanceInfo - for CommandBufferInheritanceConditionalRenderingInfoEXT -{ -} -impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { - type Target = CommandBufferInheritanceConditionalRenderingInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { +impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXT<'a> { + #[inline] pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self { - self.inner.conditional_rendering_enable = conditional_rendering_enable.into(); + self.conditional_rendering_enable = conditional_rendering_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ExternalFormatANDROID { +pub struct ExternalFormatANDROID<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub external_format: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExternalFormatANDROID { +impl ::std::default::Default for ExternalFormatANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::EXTERNAL_FORMAT_ANDROID, p_next: ::std::ptr::null_mut(), external_format: u64::default(), + _marker: PhantomData, } } } -impl ExternalFormatANDROID { - pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> { - ExternalFormatANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ExternalFormatANDROIDBuilder<'a> { - inner: ExternalFormatANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {} -unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {} -unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {} -impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { - type Target = ExternalFormatANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ExternalFormatANDROIDBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID<'_> {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID<'_> {} +impl<'a> ExternalFormatANDROID<'a> { + #[inline] pub fn external_format(mut self, external_format: u64) -> Self { - self.inner.external_format = external_format; + self.external_format = external_format; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ExternalFormatANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevice8BitStorageFeatures { +pub struct PhysicalDevice8BitStorageFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub storage_buffer8_bit_access: Bool32, pub uniform_and_storage_buffer8_bit_access: Bool32, pub storage_push_constant8: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevice8BitStorageFeatures { +impl ::std::default::Default for PhysicalDevice8BitStorageFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, @@ -29130,143 +19164,84 @@ impl ::std::default::Default for PhysicalDevice8BitStorageFeatures { storage_buffer8_bit_access: Bool32::default(), uniform_and_storage_buffer8_bit_access: Bool32::default(), storage_push_constant8: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevice8BitStorageFeatures { - pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> { - PhysicalDevice8BitStorageFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> { - inner: PhysicalDevice8BitStorageFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> { - type Target = PhysicalDevice8BitStorageFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures<'_> {} +impl<'a> PhysicalDevice8BitStorageFeatures<'a> { + #[inline] pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self { - self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); self } + #[inline] pub fn uniform_and_storage_buffer8_bit_access( mut self, uniform_and_storage_buffer8_bit_access: bool, ) -> Self { - self.inner.uniform_and_storage_buffer8_bit_access = - uniform_and_storage_buffer8_bit_access.into(); + self.uniform_and_storage_buffer8_bit_access = uniform_and_storage_buffer8_bit_access.into(); self } + #[inline] pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { - self.inner.storage_push_constant8 = storage_push_constant8.into(); + self.storage_push_constant8 = storage_push_constant8.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevice8BitStorageFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceConditionalRenderingFeaturesEXT { +pub struct PhysicalDeviceConditionalRenderingFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub conditional_rendering: Bool32, pub inherited_conditional_rendering: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, p_next: ::std::ptr::null_mut(), conditional_rendering: Bool32::default(), inherited_conditional_rendering: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceConditionalRenderingFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { - PhysicalDeviceConditionalRenderingFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceConditionalRenderingFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceConditionalRenderingFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXT<'a> { + #[inline] pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self { - self.inner.conditional_rendering = conditional_rendering.into(); + self.conditional_rendering = conditional_rendering.into(); self } + #[inline] pub fn inherited_conditional_rendering( mut self, inherited_conditional_rendering: bool, ) -> Self { - self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into(); + self.inherited_conditional_rendering = inherited_conditional_rendering.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkanMemoryModelFeatures { +pub struct PhysicalDeviceVulkanMemoryModelFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub vulkan_memory_model: Bool32, pub vulkan_memory_model_device_scope: Bool32, pub vulkan_memory_model_availability_visibility_chains: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures { +impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, @@ -29274,134 +19249,77 @@ impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures { vulkan_memory_model: Bool32::default(), vulkan_memory_model_device_scope: Bool32::default(), vulkan_memory_model_availability_visibility_chains: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVulkanMemoryModelFeatures { - pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { - PhysicalDeviceVulkanMemoryModelFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { - inner: PhysicalDeviceVulkanMemoryModelFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { - type Target = PhysicalDeviceVulkanMemoryModelFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures<'_> {} +impl<'a> PhysicalDeviceVulkanMemoryModelFeatures<'a> { + #[inline] pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { - self.inner.vulkan_memory_model = vulkan_memory_model.into(); + self.vulkan_memory_model = vulkan_memory_model.into(); self } + #[inline] pub fn vulkan_memory_model_device_scope( mut self, vulkan_memory_model_device_scope: bool, ) -> Self { - self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); + self.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); self } + #[inline] pub fn vulkan_memory_model_availability_visibility_chains( mut self, vulkan_memory_model_availability_visibility_chains: bool, ) -> Self { - self.inner - .vulkan_memory_model_availability_visibility_chains = + self.vulkan_memory_model_availability_visibility_chains = vulkan_memory_model_availability_visibility_chains.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderAtomicInt64Features { +pub struct PhysicalDeviceShaderAtomicInt64Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_buffer_int64_atomics: Bool32, pub shader_shared_int64_atomics: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features { +impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, p_next: ::std::ptr::null_mut(), shader_buffer_int64_atomics: Bool32::default(), shader_shared_int64_atomics: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderAtomicInt64Features { - pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { - PhysicalDeviceShaderAtomicInt64FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { - inner: PhysicalDeviceShaderAtomicInt64Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderAtomicInt64Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features<'_> {} +impl<'a> PhysicalDeviceShaderAtomicInt64Features<'a> { + #[inline] pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self { - self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); self } + #[inline] pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self { - self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT { +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_buffer_float32_atomics: Bool32, @@ -29416,8 +19334,9 @@ pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT { pub shader_image_float32_atomic_add: Bool32, pub sparse_image_float32_atomics: Bool32, pub sparse_image_float32_atomic_add: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, @@ -29434,119 +19353,97 @@ impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT { shader_image_float32_atomic_add: Bool32::default(), sparse_image_float32_atomics: Bool32::default(), sparse_image_float32_atomic_add: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderAtomicFloatFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { - PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> { + #[inline] pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self { - self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into(); + self.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into(); self } + #[inline] pub fn shader_buffer_float32_atomic_add( mut self, shader_buffer_float32_atomic_add: bool, ) -> Self { - self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into(); + self.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into(); self } + #[inline] pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self { - self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into(); + self.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into(); self } + #[inline] pub fn shader_buffer_float64_atomic_add( mut self, shader_buffer_float64_atomic_add: bool, ) -> Self { - self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into(); + self.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into(); self } + #[inline] pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self { - self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into(); + self.shader_shared_float32_atomics = shader_shared_float32_atomics.into(); self } + #[inline] pub fn shader_shared_float32_atomic_add( mut self, shader_shared_float32_atomic_add: bool, ) -> Self { - self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into(); + self.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into(); self } + #[inline] pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self { - self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into(); + self.shader_shared_float64_atomics = shader_shared_float64_atomics.into(); self } + #[inline] pub fn shader_shared_float64_atomic_add( mut self, shader_shared_float64_atomic_add: bool, ) -> Self { - self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into(); + self.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into(); self } + #[inline] pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self { - self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into(); + self.shader_image_float32_atomics = shader_image_float32_atomics.into(); self } + #[inline] pub fn shader_image_float32_atomic_add( mut self, shader_image_float32_atomic_add: bool, ) -> Self { - self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into(); + self.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into(); self } + #[inline] pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self { - self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into(); + self.sparse_image_float32_atomics = sparse_image_float32_atomics.into(); self } + #[inline] pub fn sparse_image_float32_atomic_add( mut self, sparse_image_float32_atomic_add: bool, ) -> Self { - self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into(); + self.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_buffer_float16_atomics: Bool32, @@ -29561,8 +19458,9 @@ pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { pub shader_shared_float64_atomic_min_max: Bool32, pub shader_image_float32_atomic_min_max: Bool32, pub sparse_image_float32_atomic_min_max: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, @@ -29579,339 +19477,226 @@ impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { shader_shared_float64_atomic_min_max: Bool32::default(), shader_image_float32_atomic_min_max: Bool32::default(), sparse_image_float32_atomic_min_max: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { - PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { - inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> { + #[inline] pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self { - self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into(); + self.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into(); self } + #[inline] pub fn shader_buffer_float16_atomic_add( mut self, shader_buffer_float16_atomic_add: bool, ) -> Self { - self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into(); + self.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into(); self } + #[inline] pub fn shader_buffer_float16_atomic_min_max( mut self, shader_buffer_float16_atomic_min_max: bool, ) -> Self { - self.inner.shader_buffer_float16_atomic_min_max = - shader_buffer_float16_atomic_min_max.into(); + self.shader_buffer_float16_atomic_min_max = shader_buffer_float16_atomic_min_max.into(); self } + #[inline] pub fn shader_buffer_float32_atomic_min_max( mut self, shader_buffer_float32_atomic_min_max: bool, ) -> Self { - self.inner.shader_buffer_float32_atomic_min_max = - shader_buffer_float32_atomic_min_max.into(); + self.shader_buffer_float32_atomic_min_max = shader_buffer_float32_atomic_min_max.into(); self } + #[inline] pub fn shader_buffer_float64_atomic_min_max( mut self, shader_buffer_float64_atomic_min_max: bool, ) -> Self { - self.inner.shader_buffer_float64_atomic_min_max = - shader_buffer_float64_atomic_min_max.into(); + self.shader_buffer_float64_atomic_min_max = shader_buffer_float64_atomic_min_max.into(); self } + #[inline] pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self { - self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into(); + self.shader_shared_float16_atomics = shader_shared_float16_atomics.into(); self } + #[inline] pub fn shader_shared_float16_atomic_add( mut self, shader_shared_float16_atomic_add: bool, ) -> Self { - self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into(); + self.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into(); self } + #[inline] pub fn shader_shared_float16_atomic_min_max( mut self, shader_shared_float16_atomic_min_max: bool, ) -> Self { - self.inner.shader_shared_float16_atomic_min_max = - shader_shared_float16_atomic_min_max.into(); + self.shader_shared_float16_atomic_min_max = shader_shared_float16_atomic_min_max.into(); self } + #[inline] pub fn shader_shared_float32_atomic_min_max( mut self, shader_shared_float32_atomic_min_max: bool, ) -> Self { - self.inner.shader_shared_float32_atomic_min_max = - shader_shared_float32_atomic_min_max.into(); + self.shader_shared_float32_atomic_min_max = shader_shared_float32_atomic_min_max.into(); self } + #[inline] pub fn shader_shared_float64_atomic_min_max( mut self, shader_shared_float64_atomic_min_max: bool, ) -> Self { - self.inner.shader_shared_float64_atomic_min_max = - shader_shared_float64_atomic_min_max.into(); + self.shader_shared_float64_atomic_min_max = shader_shared_float64_atomic_min_max.into(); self } + #[inline] pub fn shader_image_float32_atomic_min_max( mut self, shader_image_float32_atomic_min_max: bool, ) -> Self { - self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into(); + self.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into(); self } + #[inline] pub fn sparse_image_float32_atomic_min_max( mut self, sparse_image_float32_atomic_min_max: bool, ) -> Self { - self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into(); + self.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { +pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub vertex_attribute_instance_rate_divisor: Bool32, pub vertex_attribute_instance_rate_zero_divisor: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, p_next: ::std::ptr::null_mut(), vertex_attribute_instance_rate_divisor: Bool32::default(), vertex_attribute_instance_rate_zero_divisor: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { - PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXT<'a> { + #[inline] pub fn vertex_attribute_instance_rate_divisor( mut self, vertex_attribute_instance_rate_divisor: bool, ) -> Self { - self.inner.vertex_attribute_instance_rate_divisor = - vertex_attribute_instance_rate_divisor.into(); + self.vertex_attribute_instance_rate_divisor = vertex_attribute_instance_rate_divisor.into(); self } + #[inline] pub fn vertex_attribute_instance_rate_zero_divisor( mut self, vertex_attribute_instance_rate_zero_divisor: bool, ) -> Self { - self.inner.vertex_attribute_instance_rate_zero_divisor = + self.vertex_attribute_instance_rate_zero_divisor = vertex_attribute_instance_rate_zero_divisor.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueueFamilyCheckpointPropertiesNV { +pub struct QueueFamilyCheckpointPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub checkpoint_execution_stage_mask: PipelineStageFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV { +impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, p_next: ::std::ptr::null_mut(), checkpoint_execution_stage_mask: PipelineStageFlags::default(), + _marker: PhantomData, } } } -impl QueueFamilyCheckpointPropertiesNV { - pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> { - QueueFamilyCheckpointPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> { - inner: QueueFamilyCheckpointPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {} -impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> { - type Target = QueueFamilyCheckpointPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> { +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV<'_> {} +impl<'a> QueueFamilyCheckpointPropertiesNV<'a> { + #[inline] pub fn checkpoint_execution_stage_mask( mut self, checkpoint_execution_stage_mask: PipelineStageFlags, ) -> Self { - self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueueFamilyCheckpointPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CheckpointDataNV { +pub struct CheckpointDataNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub stage: PipelineStageFlags, pub p_checkpoint_marker: *mut c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CheckpointDataNV { +impl ::std::default::Default for CheckpointDataNV<'_> { fn default() -> Self { Self { s_type: StructureType::CHECKPOINT_DATA_NV, p_next: ::std::ptr::null_mut(), stage: PipelineStageFlags::default(), p_checkpoint_marker: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl CheckpointDataNV { - pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> { - CheckpointDataNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CheckpointDataNVBuilder<'a> { - inner: CheckpointDataNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> { - type Target = CheckpointDataNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CheckpointDataNVBuilder<'a> { +impl<'a> CheckpointDataNV<'a> { + #[inline] pub fn stage(mut self, stage: PipelineStageFlags) -> Self { - self.inner.stage = stage; + self.stage = stage; self } + #[inline] pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self { - self.inner.p_checkpoint_marker = checkpoint_marker; + self.p_checkpoint_marker = checkpoint_marker; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CheckpointDataNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDepthStencilResolveProperties { +pub struct PhysicalDeviceDepthStencilResolveProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub supported_depth_resolve_modes: ResolveModeFlags, pub supported_stencil_resolve_modes: ResolveModeFlags, pub independent_resolve_none: Bool32, pub independent_resolve: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties { +impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, @@ -29920,80 +19705,52 @@ impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties { supported_stencil_resolve_modes: ResolveModeFlags::default(), independent_resolve_none: Bool32::default(), independent_resolve: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDepthStencilResolveProperties { - pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { - PhysicalDeviceDepthStencilResolvePropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { - inner: PhysicalDeviceDepthStencilResolveProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { - type Target = PhysicalDeviceDepthStencilResolveProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties<'_> {} +impl<'a> PhysicalDeviceDepthStencilResolveProperties<'a> { + #[inline] pub fn supported_depth_resolve_modes( mut self, supported_depth_resolve_modes: ResolveModeFlags, ) -> Self { - self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self.supported_depth_resolve_modes = supported_depth_resolve_modes; self } + #[inline] pub fn supported_stencil_resolve_modes( mut self, supported_stencil_resolve_modes: ResolveModeFlags, ) -> Self { - self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self.supported_stencil_resolve_modes = supported_stencil_resolve_modes; self } + #[inline] pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self { - self.inner.independent_resolve_none = independent_resolve_none.into(); + self.independent_resolve_none = independent_resolve_none.into(); self } + #[inline] pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { - self.inner.independent_resolve = independent_resolve.into(); + self.independent_resolve = independent_resolve.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassDescriptionDepthStencilResolve { +pub struct SubpassDescriptionDepthStencilResolve<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub depth_resolve_mode: ResolveModeFlags, pub stencil_resolve_mode: ResolveModeFlags, - pub p_depth_stencil_resolve_attachment: *const AttachmentReference2, + pub p_depth_stencil_resolve_attachment: *const AttachmentReference2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassDescriptionDepthStencilResolve { +impl ::std::default::Default for SubpassDescriptionDepthStencilResolve<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, @@ -30001,244 +19758,129 @@ impl ::std::default::Default for SubpassDescriptionDepthStencilResolve { depth_resolve_mode: ResolveModeFlags::default(), stencil_resolve_mode: ResolveModeFlags::default(), p_depth_stencil_resolve_attachment: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubpassDescriptionDepthStencilResolve { - pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> { - SubpassDescriptionDepthStencilResolveBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> { - inner: SubpassDescriptionDepthStencilResolve, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {} -unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {} -impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> { - type Target = SubpassDescriptionDepthStencilResolve; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> { +unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve<'_> {} +impl<'a> SubpassDescriptionDepthStencilResolve<'a> { + #[inline] pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self { - self.inner.depth_resolve_mode = depth_resolve_mode; + self.depth_resolve_mode = depth_resolve_mode; self } + #[inline] pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self { - self.inner.stencil_resolve_mode = stencil_resolve_mode; + self.stencil_resolve_mode = stencil_resolve_mode; self } + #[inline] pub fn depth_stencil_resolve_attachment( mut self, - depth_stencil_resolve_attachment: &'a AttachmentReference2, + depth_stencil_resolve_attachment: &'a AttachmentReference2<'a>, ) -> Self { - self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; + self.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassDescriptionDepthStencilResolve { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageViewASTCDecodeModeEXT { +pub struct ImageViewASTCDecodeModeEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub decode_mode: Format, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageViewASTCDecodeModeEXT { +impl ::std::default::Default for ImageViewASTCDecodeModeEXT<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT, p_next: ::std::ptr::null(), decode_mode: Format::default(), + _marker: PhantomData, } } } -impl ImageViewASTCDecodeModeEXT { - pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> { - ImageViewASTCDecodeModeEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageViewASTCDecodeModeEXTBuilder<'a> { - inner: ImageViewASTCDecodeModeEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {} -impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> { - type Target = ImageViewASTCDecodeModeEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> { +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT<'_> {} +impl<'a> ImageViewASTCDecodeModeEXT<'a> { + #[inline] pub fn decode_mode(mut self, decode_mode: Format) -> Self { - self.inner.decode_mode = decode_mode; + self.decode_mode = decode_mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageViewASTCDecodeModeEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceASTCDecodeFeaturesEXT { +pub struct PhysicalDeviceASTCDecodeFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub decode_mode_shared_exponent: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, p_next: ::std::ptr::null_mut(), decode_mode_shared_exponent: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceASTCDecodeFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { - PhysicalDeviceASTCDecodeFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceASTCDecodeFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceASTCDecodeFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceASTCDecodeFeaturesEXT<'a> { + #[inline] pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self { - self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into(); + self.decode_mode_shared_exponent = decode_mode_shared_exponent.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTransformFeedbackFeaturesEXT { +pub struct PhysicalDeviceTransformFeedbackFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub transform_feedback: Bool32, pub geometry_streams: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, p_next: ::std::ptr::null_mut(), transform_feedback: Bool32::default(), geometry_streams: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTransformFeedbackFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { - PhysicalDeviceTransformFeedbackFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceTransformFeedbackFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceTransformFeedbackFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXT<'a> { + #[inline] pub fn transform_feedback(mut self, transform_feedback: bool) -> Self { - self.inner.transform_feedback = transform_feedback.into(); + self.transform_feedback = transform_feedback.into(); self } + #[inline] pub fn geometry_streams(mut self, geometry_streams: bool) -> Self { - self.inner.geometry_streams = geometry_streams.into(); + self.geometry_streams = geometry_streams.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTransformFeedbackPropertiesEXT { +pub struct PhysicalDeviceTransformFeedbackPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_transform_feedback_streams: u32, @@ -30251,8 +19893,9 @@ pub struct PhysicalDeviceTransformFeedbackPropertiesEXT { pub transform_feedback_streams_lines_triangles: Bool32, pub transform_feedback_rasterization_stream_select: Bool32, pub transform_feedback_draw: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, @@ -30267,828 +19910,462 @@ impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT { transform_feedback_streams_lines_triangles: Bool32::default(), transform_feedback_rasterization_stream_select: Bool32::default(), transform_feedback_draw: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTransformFeedbackPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { - PhysicalDeviceTransformFeedbackPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceTransformFeedbackPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceTransformFeedbackPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXT<'a> { + #[inline] pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self { - self.inner.max_transform_feedback_streams = max_transform_feedback_streams; + self.max_transform_feedback_streams = max_transform_feedback_streams; self } + #[inline] pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self { - self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers; + self.max_transform_feedback_buffers = max_transform_feedback_buffers; self } + #[inline] pub fn max_transform_feedback_buffer_size( mut self, max_transform_feedback_buffer_size: DeviceSize, ) -> Self { - self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size; + self.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size; self } + #[inline] pub fn max_transform_feedback_stream_data_size( mut self, max_transform_feedback_stream_data_size: u32, ) -> Self { - self.inner.max_transform_feedback_stream_data_size = - max_transform_feedback_stream_data_size; + self.max_transform_feedback_stream_data_size = max_transform_feedback_stream_data_size; self } + #[inline] pub fn max_transform_feedback_buffer_data_size( mut self, max_transform_feedback_buffer_data_size: u32, ) -> Self { - self.inner.max_transform_feedback_buffer_data_size = - max_transform_feedback_buffer_data_size; + self.max_transform_feedback_buffer_data_size = max_transform_feedback_buffer_data_size; self } + #[inline] pub fn max_transform_feedback_buffer_data_stride( mut self, max_transform_feedback_buffer_data_stride: u32, ) -> Self { - self.inner.max_transform_feedback_buffer_data_stride = - max_transform_feedback_buffer_data_stride; + self.max_transform_feedback_buffer_data_stride = max_transform_feedback_buffer_data_stride; self } + #[inline] pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self { - self.inner.transform_feedback_queries = transform_feedback_queries.into(); + self.transform_feedback_queries = transform_feedback_queries.into(); self } + #[inline] pub fn transform_feedback_streams_lines_triangles( mut self, transform_feedback_streams_lines_triangles: bool, ) -> Self { - self.inner.transform_feedback_streams_lines_triangles = + self.transform_feedback_streams_lines_triangles = transform_feedback_streams_lines_triangles.into(); self } + #[inline] pub fn transform_feedback_rasterization_stream_select( mut self, transform_feedback_rasterization_stream_select: bool, ) -> Self { - self.inner.transform_feedback_rasterization_stream_select = + self.transform_feedback_rasterization_stream_select = transform_feedback_rasterization_stream_select.into(); self } + #[inline] pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self { - self.inner.transform_feedback_draw = transform_feedback_draw.into(); + self.transform_feedback_draw = transform_feedback_draw.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationStateStreamCreateInfoEXT { +pub struct PipelineRasterizationStateStreamCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineRasterizationStateStreamCreateFlagsEXT, pub rasterization_stream: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT { +impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, p_next: ::std::ptr::null(), flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(), rasterization_stream: u32::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationStateStreamCreateInfoEXT { - pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { - PipelineRasterizationStateStreamCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { - inner: PipelineRasterizationStateStreamCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_> + for PipelineRasterizationStateStreamCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationStateStreamCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { - type Target = PipelineRasterizationStateStreamCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { +impl<'a> PipelineRasterizationStateStreamCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self { - self.inner.rasterization_stream = rasterization_stream; + self.rasterization_stream = rasterization_stream; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { +pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub representative_fragment_test: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { +impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, p_next: ::std::ptr::null_mut(), representative_fragment_test: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { - PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { - inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> + for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'_> {} +impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> { + #[inline] pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self { - self.inner.representative_fragment_test = representative_fragment_test.into(); + self.representative_fragment_test = representative_fragment_test.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV { +pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub representative_fragment_test_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV { +impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, p_next: ::std::ptr::null(), representative_fragment_test_enable: Bool32::default(), + _marker: PhantomData, } } } -impl PipelineRepresentativeFragmentTestStateCreateInfoNV { - pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { - PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { - inner: PipelineRepresentativeFragmentTestStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsGraphicsPipelineCreateInfo - for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_> + for PipelineRepresentativeFragmentTestStateCreateInfoNV<'_> { } -unsafe impl ExtendsGraphicsPipelineCreateInfo - for PipelineRepresentativeFragmentTestStateCreateInfoNV -{ -} -impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { - type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { + #[inline] pub fn representative_fragment_test_enable( mut self, representative_fragment_test_enable: bool, ) -> Self { - self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into(); + self.representative_fragment_test_enable = representative_fragment_test_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExclusiveScissorFeaturesNV { +pub struct PhysicalDeviceExclusiveScissorFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub exclusive_scissor: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV { +impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, p_next: ::std::ptr::null_mut(), exclusive_scissor: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExclusiveScissorFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { - PhysicalDeviceExclusiveScissorFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { - inner: PhysicalDeviceExclusiveScissorFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceExclusiveScissorFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV<'_> {} +impl<'a> PhysicalDeviceExclusiveScissorFeaturesNV<'a> { + #[inline] pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self { - self.inner.exclusive_scissor = exclusive_scissor.into(); + self.exclusive_scissor = exclusive_scissor.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportExclusiveScissorStateCreateInfoNV { +pub struct PipelineViewportExclusiveScissorStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub exclusive_scissor_count: u32, pub p_exclusive_scissors: *const Rect2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV { +impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, p_next: ::std::ptr::null(), exclusive_scissor_count: u32::default(), p_exclusive_scissors: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineViewportExclusiveScissorStateCreateInfoNV { - pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { - PipelineViewportExclusiveScissorStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { - inner: PipelineViewportExclusiveScissorStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_> + for PipelineViewportExclusiveScissorStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportExclusiveScissorStateCreateInfoNV -{ -} -impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { - type Target = PipelineViewportExclusiveScissorStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNV<'a> { + #[inline] pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self { - self.inner.exclusive_scissor_count = exclusive_scissors.len() as _; - self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr(); + self.exclusive_scissor_count = exclusive_scissors.len() as _; + self.p_exclusive_scissors = exclusive_scissors.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCornerSampledImageFeaturesNV { +pub struct PhysicalDeviceCornerSampledImageFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub corner_sampled_image: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV { +impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, p_next: ::std::ptr::null_mut(), corner_sampled_image: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCornerSampledImageFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { - PhysicalDeviceCornerSampledImageFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { - inner: PhysicalDeviceCornerSampledImageFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceCornerSampledImageFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV<'_> {} +impl<'a> PhysicalDeviceCornerSampledImageFeaturesNV<'a> { + #[inline] pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self { - self.inner.corner_sampled_image = corner_sampled_image.into(); + self.corner_sampled_image = corner_sampled_image.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { +pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub compute_derivative_group_quads: Bool32, pub compute_derivative_group_linear: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV { +impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, p_next: ::std::ptr::null_mut(), compute_derivative_group_quads: Bool32::default(), compute_derivative_group_linear: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceComputeShaderDerivativesFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { - PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { - inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> + for PhysicalDeviceComputeShaderDerivativesFeaturesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV<'_> {} +impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNV<'a> { + #[inline] pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self { - self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into(); + self.compute_derivative_group_quads = compute_derivative_group_quads.into(); self } + #[inline] pub fn compute_derivative_group_linear( mut self, compute_derivative_group_linear: bool, ) -> Self { - self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into(); + self.compute_derivative_group_linear = compute_derivative_group_linear.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV { +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_shader_barycentric: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV { +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, p_next: ::std::ptr::null_mut(), fragment_shader_barycentric: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> + for PhysicalDeviceFragmentShaderBarycentricFeaturesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV<'_> {} +impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNV<'a> { + #[inline] pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { - self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into(); + self.fragment_shader_barycentric = fragment_shader_barycentric.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderImageFootprintFeaturesNV { +pub struct PhysicalDeviceShaderImageFootprintFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub image_footprint: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV { +impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, p_next: ::std::ptr::null_mut(), image_footprint: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderImageFootprintFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { - PhysicalDeviceShaderImageFootprintFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { - inner: PhysicalDeviceShaderImageFootprintFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceShaderImageFootprintFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV<'_> {} +impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNV<'a> { + #[inline] pub fn image_footprint(mut self, image_footprint: bool) -> Self { - self.inner.image_footprint = image_footprint.into(); + self.image_footprint = image_footprint.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { +pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub dedicated_allocation_image_aliasing: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { +impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, p_next: ::std::ptr::null_mut(), dedicated_allocation_image_aliasing: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { - inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'_> { } unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'_> { } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut - for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> -{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { +impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { + #[inline] pub fn dedicated_allocation_image_aliasing( mut self, dedicated_allocation_image_aliasing: bool, ) -> Self { - self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into(); + self.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ShadingRatePaletteNV { +pub struct ShadingRatePaletteNV<'a> { pub shading_rate_palette_entry_count: u32, pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ShadingRatePaletteNV { +impl ::std::default::Default for ShadingRatePaletteNV<'_> { fn default() -> Self { Self { shading_rate_palette_entry_count: u32::default(), p_shading_rate_palette_entries: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ShadingRatePaletteNV { - pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> { - ShadingRatePaletteNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ShadingRatePaletteNVBuilder<'a> { - inner: ShadingRatePaletteNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> { - type Target = ShadingRatePaletteNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ShadingRatePaletteNVBuilder<'a> { +impl<'a> ShadingRatePaletteNV<'a> { + #[inline] pub fn shading_rate_palette_entries( mut self, shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV], ) -> Self { - self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _; - self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr(); + self.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _; + self.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ShadingRatePaletteNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportShadingRateImageStateCreateInfoNV { +pub struct PipelineViewportShadingRateImageStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub shading_rate_image_enable: Bool32, pub viewport_count: u32, - pub p_shading_rate_palettes: *const ShadingRatePaletteNV, + pub p_shading_rate_palettes: *const ShadingRatePaletteNV<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV { +impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV, @@ -31096,140 +20373,82 @@ impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfo shading_rate_image_enable: Bool32::default(), viewport_count: u32::default(), p_shading_rate_palettes: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineViewportShadingRateImageStateCreateInfoNV { - pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { - PipelineViewportShadingRateImageStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { - inner: PipelineViewportShadingRateImageStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_> + for PipelineViewportShadingRateImageStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportShadingRateImageStateCreateInfoNV -{ -} -impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { - type Target = PipelineViewportShadingRateImageStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineViewportShadingRateImageStateCreateInfoNV<'a> { + #[inline] pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self { - self.inner.shading_rate_image_enable = shading_rate_image_enable.into(); + self.shading_rate_image_enable = shading_rate_image_enable.into(); self } + #[inline] pub fn shading_rate_palettes( mut self, shading_rate_palettes: &'a [ShadingRatePaletteNV], ) -> Self { - self.inner.viewport_count = shading_rate_palettes.len() as _; - self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr(); + self.viewport_count = shading_rate_palettes.len() as _; + self.p_shading_rate_palettes = shading_rate_palettes.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShadingRateImageFeaturesNV { +pub struct PhysicalDeviceShadingRateImageFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shading_rate_image: Bool32, pub shading_rate_coarse_sample_order: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV { +impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, p_next: ::std::ptr::null_mut(), shading_rate_image: Bool32::default(), shading_rate_coarse_sample_order: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShadingRateImageFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { - PhysicalDeviceShadingRateImageFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { - inner: PhysicalDeviceShadingRateImageFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceShadingRateImageFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV<'_> {} +impl<'a> PhysicalDeviceShadingRateImageFeaturesNV<'a> { + #[inline] pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self { - self.inner.shading_rate_image = shading_rate_image.into(); + self.shading_rate_image = shading_rate_image.into(); self } + #[inline] pub fn shading_rate_coarse_sample_order( mut self, shading_rate_coarse_sample_order: bool, ) -> Self { - self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into(); + self.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShadingRateImagePropertiesNV { +pub struct PhysicalDeviceShadingRateImagePropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shading_rate_texel_size: Extent2D, pub shading_rate_palette_size: u32, pub shading_rate_max_coarse_samples: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV { +impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, @@ -31237,118 +20456,56 @@ impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV { shading_rate_texel_size: Extent2D::default(), shading_rate_palette_size: u32::default(), shading_rate_max_coarse_samples: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShadingRateImagePropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { - PhysicalDeviceShadingRateImagePropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { - inner: PhysicalDeviceShadingRateImagePropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { - type Target = PhysicalDeviceShadingRateImagePropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV<'_> {} +impl<'a> PhysicalDeviceShadingRateImagePropertiesNV<'a> { + #[inline] pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self { - self.inner.shading_rate_texel_size = shading_rate_texel_size; + self.shading_rate_texel_size = shading_rate_texel_size; self } + #[inline] pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self { - self.inner.shading_rate_palette_size = shading_rate_palette_size; + self.shading_rate_palette_size = shading_rate_palette_size; self } + #[inline] pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self { - self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples; + self.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI { +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub invocation_mask: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI { +impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, p_next: ::std::ptr::null_mut(), invocation_mask: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceInvocationMaskFeaturesHUAWEI { - pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { - PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { - inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} -impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { - type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'_> {} +impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> { + #[inline] pub fn invocation_mask(mut self, invocation_mask: bool) -> Self { - self.inner.invocation_mask = invocation_mask.into(); + self.invocation_mask = invocation_mask.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -31360,126 +20517,75 @@ pub struct CoarseSampleLocationNV { pub sample: u32, } impl CoarseSampleLocationNV { - pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> { - CoarseSampleLocationNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CoarseSampleLocationNVBuilder<'a> { - inner: CoarseSampleLocationNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> { - type Target = CoarseSampleLocationNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CoarseSampleLocationNVBuilder<'a> { + #[inline] pub fn pixel_x(mut self, pixel_x: u32) -> Self { - self.inner.pixel_x = pixel_x; + self.pixel_x = pixel_x; self } + #[inline] pub fn pixel_y(mut self, pixel_y: u32) -> Self { - self.inner.pixel_y = pixel_y; + self.pixel_y = pixel_y; self } + #[inline] pub fn sample(mut self, sample: u32) -> Self { - self.inner.sample = sample; + self.sample = sample; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CoarseSampleLocationNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CoarseSampleOrderCustomNV { +pub struct CoarseSampleOrderCustomNV<'a> { pub shading_rate: ShadingRatePaletteEntryNV, pub sample_count: u32, pub sample_location_count: u32, pub p_sample_locations: *const CoarseSampleLocationNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CoarseSampleOrderCustomNV { +impl ::std::default::Default for CoarseSampleOrderCustomNV<'_> { fn default() -> Self { Self { shading_rate: ShadingRatePaletteEntryNV::default(), sample_count: u32::default(), sample_location_count: u32::default(), p_sample_locations: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CoarseSampleOrderCustomNV { - pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> { - CoarseSampleOrderCustomNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CoarseSampleOrderCustomNVBuilder<'a> { - inner: CoarseSampleOrderCustomNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> { - type Target = CoarseSampleOrderCustomNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CoarseSampleOrderCustomNVBuilder<'a> { +impl<'a> CoarseSampleOrderCustomNV<'a> { + #[inline] pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self { - self.inner.shading_rate = shading_rate; + self.shading_rate = shading_rate; self } + #[inline] pub fn sample_count(mut self, sample_count: u32) -> Self { - self.inner.sample_count = sample_count; + self.sample_count = sample_count; self } + #[inline] pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self { - self.inner.sample_location_count = sample_locations.len() as _; - self.inner.p_sample_locations = sample_locations.as_ptr(); + self.sample_location_count = sample_locations.len() as _; + self.p_sample_locations = sample_locations.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CoarseSampleOrderCustomNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { +pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub sample_order_type: CoarseSampleOrderTypeNV, pub custom_sample_order_count: u32, - pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV, + pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV { +impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, @@ -31487,130 +20593,71 @@ impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInf sample_order_type: CoarseSampleOrderTypeNV::default(), custom_sample_order_count: u32::default(), p_custom_sample_orders: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineViewportCoarseSampleOrderStateCreateInfoNV { - pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { - PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { - inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_> + for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportCoarseSampleOrderStateCreateInfoNV -{ -} -impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { - type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> { + #[inline] pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self { - self.inner.sample_order_type = sample_order_type; + self.sample_order_type = sample_order_type; self } + #[inline] pub fn custom_sample_orders( mut self, custom_sample_orders: &'a [CoarseSampleOrderCustomNV], ) -> Self { - self.inner.custom_sample_order_count = custom_sample_orders.len() as _; - self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr(); + self.custom_sample_order_count = custom_sample_orders.len() as _; + self.p_custom_sample_orders = custom_sample_orders.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMeshShaderFeaturesNV { +pub struct PhysicalDeviceMeshShaderFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub task_shader: Bool32, pub mesh_shader: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV { +impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, p_next: ::std::ptr::null_mut(), task_shader: Bool32::default(), mesh_shader: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMeshShaderFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { - PhysicalDeviceMeshShaderFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { - inner: PhysicalDeviceMeshShaderFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceMeshShaderFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV<'_> {} +impl<'a> PhysicalDeviceMeshShaderFeaturesNV<'a> { + #[inline] pub fn task_shader(mut self, task_shader: bool) -> Self { - self.inner.task_shader = task_shader.into(); + self.task_shader = task_shader.into(); self } + #[inline] pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { - self.inner.mesh_shader = mesh_shader.into(); + self.mesh_shader = mesh_shader.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMeshShaderPropertiesNV { +pub struct PhysicalDeviceMeshShaderPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_draw_mesh_tasks_count: u32, @@ -31626,8 +20673,9 @@ pub struct PhysicalDeviceMeshShaderPropertiesNV { pub max_mesh_multiview_view_count: u32, pub mesh_output_per_vertex_granularity: u32, pub mesh_output_per_primitive_granularity: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV { +impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, @@ -31645,100 +20693,83 @@ impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV { max_mesh_multiview_view_count: u32::default(), mesh_output_per_vertex_granularity: u32::default(), mesh_output_per_primitive_granularity: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMeshShaderPropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { - PhysicalDeviceMeshShaderPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { - inner: PhysicalDeviceMeshShaderPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { - type Target = PhysicalDeviceMeshShaderPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV<'_> {} +impl<'a> PhysicalDeviceMeshShaderPropertiesNV<'a> { + #[inline] pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self { - self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count; + self.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count; self } + #[inline] pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self { - self.inner.max_task_work_group_invocations = max_task_work_group_invocations; + self.max_task_work_group_invocations = max_task_work_group_invocations; self } + #[inline] pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self { - self.inner.max_task_work_group_size = max_task_work_group_size; + self.max_task_work_group_size = max_task_work_group_size; self } + #[inline] pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self { - self.inner.max_task_total_memory_size = max_task_total_memory_size; + self.max_task_total_memory_size = max_task_total_memory_size; self } + #[inline] pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self { - self.inner.max_task_output_count = max_task_output_count; + self.max_task_output_count = max_task_output_count; self } + #[inline] pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self { - self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self.max_mesh_work_group_invocations = max_mesh_work_group_invocations; self } + #[inline] pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self { - self.inner.max_mesh_work_group_size = max_mesh_work_group_size; + self.max_mesh_work_group_size = max_mesh_work_group_size; self } + #[inline] pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self { - self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size; + self.max_mesh_total_memory_size = max_mesh_total_memory_size; self } + #[inline] pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self { - self.inner.max_mesh_output_vertices = max_mesh_output_vertices; + self.max_mesh_output_vertices = max_mesh_output_vertices; self } + #[inline] pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self { - self.inner.max_mesh_output_primitives = max_mesh_output_primitives; + self.max_mesh_output_primitives = max_mesh_output_primitives; self } + #[inline] pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self { - self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self.max_mesh_multiview_view_count = max_mesh_multiview_view_count; self } + #[inline] pub fn mesh_output_per_vertex_granularity( mut self, mesh_output_per_vertex_granularity: u32, ) -> Self { - self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; self } + #[inline] pub fn mesh_output_per_primitive_granularity( mut self, mesh_output_per_primitive_granularity: u32, ) -> Self { - self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -31749,50 +20780,22 @@ pub struct DrawMeshTasksIndirectCommandNV { pub first_task: u32, } impl DrawMeshTasksIndirectCommandNV { - pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> { - DrawMeshTasksIndirectCommandNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> { - inner: DrawMeshTasksIndirectCommandNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> { - type Target = DrawMeshTasksIndirectCommandNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> { + #[inline] pub fn task_count(mut self, task_count: u32) -> Self { - self.inner.task_count = task_count; + self.task_count = task_count; self } + #[inline] pub fn first_task(mut self, first_task: u32) -> Self { - self.inner.first_task = first_task; + self.first_task = first_task; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrawMeshTasksIndirectCommandNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RayTracingShaderGroupCreateInfoNV { +pub struct RayTracingShaderGroupCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: RayTracingShaderGroupTypeKHR, @@ -31800,8 +20803,9 @@ pub struct RayTracingShaderGroupCreateInfoNV { pub closest_hit_shader: u32, pub any_hit_shader: u32, pub intersection_shader: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV { +impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, @@ -31811,66 +20815,42 @@ impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV { closest_hit_shader: u32::default(), any_hit_shader: u32::default(), intersection_shader: u32::default(), + _marker: PhantomData, } } } -impl RayTracingShaderGroupCreateInfoNV { - pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> { - RayTracingShaderGroupCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> { - inner: RayTracingShaderGroupCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> { - type Target = RayTracingShaderGroupCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { +impl<'a> RayTracingShaderGroupCreateInfoNV<'a> { + #[inline] pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn general_shader(mut self, general_shader: u32) -> Self { - self.inner.general_shader = general_shader; + self.general_shader = general_shader; self } + #[inline] pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { - self.inner.closest_hit_shader = closest_hit_shader; + self.closest_hit_shader = closest_hit_shader; self } + #[inline] pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { - self.inner.any_hit_shader = any_hit_shader; + self.any_hit_shader = any_hit_shader; self } + #[inline] pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { - self.inner.intersection_shader = intersection_shader; + self.intersection_shader = intersection_shader; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RayTracingShaderGroupCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RayTracingShaderGroupCreateInfoKHR { +pub struct RayTracingShaderGroupCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: RayTracingShaderGroupTypeKHR, @@ -31879,8 +20859,9 @@ pub struct RayTracingShaderGroupCreateInfoKHR { pub any_hit_shader: u32, pub intersection_shader: u32, pub p_shader_group_capture_replay_handle: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR { +impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR, @@ -31891,86 +20872,64 @@ impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR { any_hit_shader: u32::default(), intersection_shader: u32::default(), p_shader_group_capture_replay_handle: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RayTracingShaderGroupCreateInfoKHR { - pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { - RayTracingShaderGroupCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> { - inner: RayTracingShaderGroupCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { - type Target = RayTracingShaderGroupCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { +impl<'a> RayTracingShaderGroupCreateInfoKHR<'a> { + #[inline] pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn general_shader(mut self, general_shader: u32) -> Self { - self.inner.general_shader = general_shader; + self.general_shader = general_shader; self } + #[inline] pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { - self.inner.closest_hit_shader = closest_hit_shader; + self.closest_hit_shader = closest_hit_shader; self } + #[inline] pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { - self.inner.any_hit_shader = any_hit_shader; + self.any_hit_shader = any_hit_shader; self } + #[inline] pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { - self.inner.intersection_shader = intersection_shader; + self.intersection_shader = intersection_shader; self } + #[inline] pub fn shader_group_capture_replay_handle( mut self, shader_group_capture_replay_handle: *const c_void, ) -> Self { - self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle; + self.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RayTracingPipelineCreateInfoNV { +pub struct RayTracingPipelineCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCreateFlags, pub stage_count: u32, - pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_stages: *const PipelineShaderStageCreateInfo<'a>, pub group_count: u32, - pub p_groups: *const RayTracingShaderGroupCreateInfoNV, + pub p_groups: *const RayTracingShaderGroupCreateInfoNV<'a>, pub max_recursion_depth: u32, pub layout: PipelineLayout, pub base_pipeline_handle: Pipeline, pub base_pipeline_index: i32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RayTracingPipelineCreateInfoNV { +impl ::std::default::Default for RayTracingPipelineCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV, @@ -31984,107 +20943,86 @@ impl ::std::default::Default for RayTracingPipelineCreateInfoNV { layout: PipelineLayout::default(), base_pipeline_handle: Pipeline::default(), base_pipeline_index: i32::default(), + _marker: PhantomData, } } } -impl RayTracingPipelineCreateInfoNV { - pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> { - RayTracingPipelineCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RayTracingPipelineCreateInfoNVBuilder<'a> { - inner: RayTracingPipelineCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {} -impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> { - type Target = RayTracingPipelineCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { +impl<'a> RayTracingPipelineCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { - self.inner.stage_count = stages.len() as _; - self.inner.p_stages = stages.as_ptr(); + self.stage_count = stages.len() as _; + self.p_stages = stages.as_ptr(); self } + #[inline] pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self { - self.inner.group_count = groups.len() as _; - self.inner.p_groups = groups.as_ptr(); + self.group_count = groups.len() as _; + self.p_groups = groups.as_ptr(); self } + #[inline] pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { - self.inner.max_recursion_depth = max_recursion_depth; + self.max_recursion_depth = max_recursion_depth; self } + #[inline] pub fn layout(mut self, layout: PipelineLayout) -> Self { - self.inner.layout = layout; + self.layout = layout; self } + #[inline] pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { - self.inner.base_pipeline_handle = base_pipeline_handle; + self.base_pipeline_handle = base_pipeline_handle; self } + #[inline] pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { - self.inner.base_pipeline_index = base_pipeline_index; + self.base_pipeline_index = base_pipeline_index; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RayTracingPipelineCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RayTracingPipelineCreateInfoKHR { +pub struct RayTracingPipelineCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCreateFlags, pub stage_count: u32, - pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_stages: *const PipelineShaderStageCreateInfo<'a>, pub group_count: u32, - pub p_groups: *const RayTracingShaderGroupCreateInfoKHR, + pub p_groups: *const RayTracingShaderGroupCreateInfoKHR<'a>, pub max_pipeline_ray_recursion_depth: u32, - pub p_library_info: *const PipelineLibraryCreateInfoKHR, - pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR, - pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub p_library_info: *const PipelineLibraryCreateInfoKHR<'a>, + pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR<'a>, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo<'a>, pub layout: PipelineLayout, pub base_pipeline_handle: Pipeline, pub base_pipeline_index: i32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RayTracingPipelineCreateInfoKHR { +impl ::std::default::Default for RayTracingPipelineCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR, @@ -32101,109 +21039,90 @@ impl ::std::default::Default for RayTracingPipelineCreateInfoKHR { layout: PipelineLayout::default(), base_pipeline_handle: Pipeline::default(), base_pipeline_index: i32::default(), + _marker: PhantomData, } } } -impl RayTracingPipelineCreateInfoKHR { - pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> { - RayTracingPipelineCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> { - inner: RayTracingPipelineCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {} -impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> { - type Target = RayTracingPipelineCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> { +impl<'a> RayTracingPipelineCreateInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { - self.inner.stage_count = stages.len() as _; - self.inner.p_stages = stages.as_ptr(); + self.stage_count = stages.len() as _; + self.p_stages = stages.as_ptr(); self } + #[inline] pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self { - self.inner.group_count = groups.len() as _; - self.inner.p_groups = groups.as_ptr(); + self.group_count = groups.len() as _; + self.p_groups = groups.as_ptr(); self } + #[inline] pub fn max_pipeline_ray_recursion_depth( mut self, max_pipeline_ray_recursion_depth: u32, ) -> Self { - self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth; + self.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth; self } - pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self { - self.inner.p_library_info = library_info; + #[inline] + pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR<'a>) -> Self { + self.p_library_info = library_info; self } + #[inline] pub fn library_interface( mut self, - library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR, + library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR<'a>, ) -> Self { - self.inner.p_library_interface = library_interface; + self.p_library_interface = library_interface; self } - pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self { - self.inner.p_dynamic_state = dynamic_state; + #[inline] + pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo<'a>) -> Self { + self.p_dynamic_state = dynamic_state; self } + #[inline] pub fn layout(mut self, layout: PipelineLayout) -> Self { - self.inner.layout = layout; + self.layout = layout; self } + #[inline] pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { - self.inner.base_pipeline_handle = base_pipeline_handle; + self.base_pipeline_handle = base_pipeline_handle; self } + #[inline] pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { - self.inner.base_pipeline_index = base_pipeline_index; + self.base_pipeline_index = base_pipeline_index; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RayTracingPipelineCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GeometryTrianglesNV { +pub struct GeometryTrianglesNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vertex_data: Buffer, @@ -32217,8 +21136,9 @@ pub struct GeometryTrianglesNV { pub index_type: IndexType, pub transform_data: Buffer, pub transform_offset: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GeometryTrianglesNV { +impl ::std::default::Default for GeometryTrianglesNV<'_> { fn default() -> Self { Self { s_type: StructureType::GEOMETRY_TRIANGLES_NV, @@ -32234,98 +21154,81 @@ impl ::std::default::Default for GeometryTrianglesNV { index_type: IndexType::default(), transform_data: Buffer::default(), transform_offset: DeviceSize::default(), + _marker: PhantomData, } } } -impl GeometryTrianglesNV { - pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> { - GeometryTrianglesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GeometryTrianglesNVBuilder<'a> { - inner: GeometryTrianglesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> { - type Target = GeometryTrianglesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GeometryTrianglesNVBuilder<'a> { +impl<'a> GeometryTrianglesNV<'a> { + #[inline] pub fn vertex_data(mut self, vertex_data: Buffer) -> Self { - self.inner.vertex_data = vertex_data; + self.vertex_data = vertex_data; self } + #[inline] pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self { - self.inner.vertex_offset = vertex_offset; + self.vertex_offset = vertex_offset; self } + #[inline] pub fn vertex_count(mut self, vertex_count: u32) -> Self { - self.inner.vertex_count = vertex_count; + self.vertex_count = vertex_count; self } + #[inline] pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self { - self.inner.vertex_stride = vertex_stride; + self.vertex_stride = vertex_stride; self } + #[inline] pub fn vertex_format(mut self, vertex_format: Format) -> Self { - self.inner.vertex_format = vertex_format; + self.vertex_format = vertex_format; self } + #[inline] pub fn index_data(mut self, index_data: Buffer) -> Self { - self.inner.index_data = index_data; + self.index_data = index_data; self } + #[inline] pub fn index_offset(mut self, index_offset: DeviceSize) -> Self { - self.inner.index_offset = index_offset; + self.index_offset = index_offset; self } + #[inline] pub fn index_count(mut self, index_count: u32) -> Self { - self.inner.index_count = index_count; + self.index_count = index_count; self } + #[inline] pub fn index_type(mut self, index_type: IndexType) -> Self { - self.inner.index_type = index_type; + self.index_type = index_type; self } + #[inline] pub fn transform_data(mut self, transform_data: Buffer) -> Self { - self.inner.transform_data = transform_data; + self.transform_data = transform_data; self } + #[inline] pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self { - self.inner.transform_offset = transform_offset; + self.transform_offset = transform_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GeometryTrianglesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GeometryAABBNV { +pub struct GeometryAABBNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub aabb_data: Buffer, pub num_aab_bs: u32, pub stride: u32, pub offset: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GeometryAABBNV { +impl ::std::default::Default for GeometryAABBNV<'_> { fn default() -> Self { Self { s_type: StructureType::GEOMETRY_AABB_NV, @@ -32334,117 +21237,66 @@ impl ::std::default::Default for GeometryAABBNV { num_aab_bs: u32::default(), stride: u32::default(), offset: DeviceSize::default(), + _marker: PhantomData, } } } -impl GeometryAABBNV { - pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> { - GeometryAABBNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GeometryAABBNVBuilder<'a> { - inner: GeometryAABBNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> { - type Target = GeometryAABBNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GeometryAABBNVBuilder<'a> { +impl<'a> GeometryAABBNV<'a> { + #[inline] pub fn aabb_data(mut self, aabb_data: Buffer) -> Self { - self.inner.aabb_data = aabb_data; + self.aabb_data = aabb_data; self } + #[inline] pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self { - self.inner.num_aab_bs = num_aab_bs; + self.num_aab_bs = num_aab_bs; self } + #[inline] pub fn stride(mut self, stride: u32) -> Self { - self.inner.stride = stride; + self.stride = stride; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GeometryAABBNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] #[doc = ""] -pub struct GeometryDataNV { - pub triangles: GeometryTrianglesNV, - pub aabbs: GeometryAABBNV, +pub struct GeometryDataNV<'a> { + pub triangles: GeometryTrianglesNV<'a>, + pub aabbs: GeometryAABBNV<'a>, + pub _marker: PhantomData<&'a ()>, } -impl GeometryDataNV { - pub fn builder<'a>() -> GeometryDataNVBuilder<'a> { - GeometryDataNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GeometryDataNVBuilder<'a> { - inner: GeometryDataNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> { - type Target = GeometryDataNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GeometryDataNVBuilder<'a> { - pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self { - self.inner.triangles = triangles; +impl<'a> GeometryDataNV<'a> { + #[inline] + pub fn triangles(mut self, triangles: GeometryTrianglesNV<'a>) -> Self { + self.triangles = triangles; self } - pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self { - self.inner.aabbs = aabbs; + #[inline] + pub fn aabbs(mut self, aabbs: GeometryAABBNV<'a>) -> Self { + self.aabbs = aabbs; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GeometryDataNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct GeometryNV { +pub struct GeometryNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub geometry_type: GeometryTypeKHR, - pub geometry: GeometryDataNV, + pub geometry: GeometryDataNV<'a>, pub flags: GeometryFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GeometryNV { +impl ::std::default::Default for GeometryNV<'_> { fn default() -> Self { Self { s_type: StructureType::GEOMETRY_NV, @@ -32452,67 +21304,42 @@ impl ::std::default::Default for GeometryNV { geometry_type: GeometryTypeKHR::default(), geometry: GeometryDataNV::default(), flags: GeometryFlagsKHR::default(), + _marker: PhantomData, } } } -impl GeometryNV { - pub fn builder<'a>() -> GeometryNVBuilder<'a> { - GeometryNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct GeometryNVBuilder<'a> { - inner: GeometryNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> { - type Target = GeometryNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> GeometryNVBuilder<'a> { +impl<'a> GeometryNV<'a> { + #[inline] pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self { - self.inner.geometry_type = geometry_type; + self.geometry_type = geometry_type; self } - pub fn geometry(mut self, geometry: GeometryDataNV) -> Self { - self.inner.geometry = geometry; + #[inline] + pub fn geometry(mut self, geometry: GeometryDataNV<'a>) -> Self { + self.geometry = geometry; self } + #[inline] pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> GeometryNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureInfoNV { +pub struct AccelerationStructureInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: AccelerationStructureTypeNV, pub flags: BuildAccelerationStructureFlagsNV, pub instance_count: u32, pub geometry_count: u32, - pub p_geometries: *const GeometryNV, + pub p_geometries: *const GeometryNV<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureInfoNV { +impl ::std::default::Default for AccelerationStructureInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV, @@ -32522,123 +21349,72 @@ impl ::std::default::Default for AccelerationStructureInfoNV { instance_count: u32::default(), geometry_count: u32::default(), p_geometries: ::std::ptr::null(), + _marker: PhantomData, } } } -impl AccelerationStructureInfoNV { - pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> { - AccelerationStructureInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureInfoNVBuilder<'a> { - inner: AccelerationStructureInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> { - type Target = AccelerationStructureInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureInfoNVBuilder<'a> { +impl<'a> AccelerationStructureInfoNV<'a> { + #[inline] pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn instance_count(mut self, instance_count: u32) -> Self { - self.inner.instance_count = instance_count; + self.instance_count = instance_count; self } + #[inline] pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self { - self.inner.geometry_count = geometries.len() as _; - self.inner.p_geometries = geometries.as_ptr(); + self.geometry_count = geometries.len() as _; + self.p_geometries = geometries.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureCreateInfoNV { +pub struct AccelerationStructureCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub compacted_size: DeviceSize, - pub info: AccelerationStructureInfoNV, + pub info: AccelerationStructureInfoNV<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureCreateInfoNV { +impl ::std::default::Default for AccelerationStructureCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV, p_next: ::std::ptr::null(), compacted_size: DeviceSize::default(), info: AccelerationStructureInfoNV::default(), + _marker: PhantomData, } } } -impl AccelerationStructureCreateInfoNV { - pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> { - AccelerationStructureCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureCreateInfoNVBuilder<'a> { - inner: AccelerationStructureCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> { - type Target = AccelerationStructureCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { +impl<'a> AccelerationStructureCreateInfoNV<'a> { + #[inline] pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self { - self.inner.compacted_size = compacted_size; + self.compacted_size = compacted_size; self } - pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self { - self.inner.info = info; + #[inline] + pub fn info(mut self, info: AccelerationStructureInfoNV<'a>) -> Self { + self.info = info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BindAccelerationStructureMemoryInfoNV { +pub struct BindAccelerationStructureMemoryInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acceleration_structure: AccelerationStructureNV, @@ -32646,8 +21422,9 @@ pub struct BindAccelerationStructureMemoryInfoNV { pub memory_offset: DeviceSize, pub device_index_count: u32, pub p_device_indices: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV { +impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, @@ -32657,253 +21434,146 @@ impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV { memory_offset: DeviceSize::default(), device_index_count: u32::default(), p_device_indices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl BindAccelerationStructureMemoryInfoNV { - pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { - BindAccelerationStructureMemoryInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { - inner: BindAccelerationStructureMemoryInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { - type Target = BindAccelerationStructureMemoryInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { +impl<'a> BindAccelerationStructureMemoryInfoNV<'a> { + #[inline] pub fn acceleration_structure( mut self, acceleration_structure: AccelerationStructureNV, ) -> Self { - self.inner.acceleration_structure = acceleration_structure; + self.acceleration_structure = acceleration_structure; self } + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { - self.inner.memory_offset = memory_offset; + self.memory_offset = memory_offset; self } + #[inline] pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { - self.inner.device_index_count = device_indices.len() as _; - self.inner.p_device_indices = device_indices.as_ptr(); + self.device_index_count = device_indices.len() as _; + self.p_device_indices = device_indices.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindAccelerationStructureMemoryInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct WriteDescriptorSetAccelerationStructureKHR { +pub struct WriteDescriptorSetAccelerationStructureKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acceleration_structure_count: u32, pub p_acceleration_structures: *const AccelerationStructureKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR { +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR<'_> { fn default() -> Self { Self { s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, p_next: ::std::ptr::null(), acceleration_structure_count: u32::default(), p_acceleration_structures: ::std::ptr::null(), + _marker: PhantomData, } } } -impl WriteDescriptorSetAccelerationStructureKHR { - pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { - WriteDescriptorSetAccelerationStructureKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { - inner: WriteDescriptorSetAccelerationStructureKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {} -impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { - type Target = WriteDescriptorSetAccelerationStructureKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR<'_> {} +impl<'a> WriteDescriptorSetAccelerationStructureKHR<'a> { + #[inline] pub fn acceleration_structures( mut self, acceleration_structures: &'a [AccelerationStructureKHR], ) -> Self { - self.inner.acceleration_structure_count = acceleration_structures.len() as _; - self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); + self.acceleration_structure_count = acceleration_structures.len() as _; + self.p_acceleration_structures = acceleration_structures.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct WriteDescriptorSetAccelerationStructureNV { +pub struct WriteDescriptorSetAccelerationStructureNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acceleration_structure_count: u32, pub p_acceleration_structures: *const AccelerationStructureNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV { +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV<'_> { fn default() -> Self { Self { s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, p_next: ::std::ptr::null(), acceleration_structure_count: u32::default(), p_acceleration_structures: ::std::ptr::null(), + _marker: PhantomData, } } } -impl WriteDescriptorSetAccelerationStructureNV { - pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { - WriteDescriptorSetAccelerationStructureNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> { - inner: WriteDescriptorSetAccelerationStructureNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {} -unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {} -impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { - type Target = WriteDescriptorSetAccelerationStructureNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV<'_> {} +impl<'a> WriteDescriptorSetAccelerationStructureNV<'a> { + #[inline] pub fn acceleration_structures( mut self, acceleration_structures: &'a [AccelerationStructureNV], ) -> Self { - self.inner.acceleration_structure_count = acceleration_structures.len() as _; - self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); + self.acceleration_structure_count = acceleration_structures.len() as _; + self.p_acceleration_structures = acceleration_structures.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureMemoryRequirementsInfoNV { +pub struct AccelerationStructureMemoryRequirementsInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: AccelerationStructureMemoryRequirementsTypeNV, pub acceleration_structure: AccelerationStructureNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV { +impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, p_next: ::std::ptr::null(), ty: AccelerationStructureMemoryRequirementsTypeNV::default(), acceleration_structure: AccelerationStructureNV::default(), + _marker: PhantomData, } } } -impl AccelerationStructureMemoryRequirementsInfoNV { - pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { - AccelerationStructureMemoryRequirementsInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { - inner: AccelerationStructureMemoryRequirementsInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { - type Target = AccelerationStructureMemoryRequirementsInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { +impl<'a> AccelerationStructureMemoryRequirementsInfoNV<'a> { + #[inline] pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn acceleration_structure( mut self, acceleration_structure: AccelerationStructureNV, ) -> Self { - self.inner.acceleration_structure = acceleration_structure; + self.acceleration_structure = acceleration_structure; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceAccelerationStructureFeaturesKHR { +pub struct PhysicalDeviceAccelerationStructureFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub acceleration_structure: Bool32, @@ -32911,8 +21581,9 @@ pub struct PhysicalDeviceAccelerationStructureFeaturesKHR { pub acceleration_structure_indirect_build: Bool32, pub acceleration_structure_host_commands: Bool32, pub descriptor_binding_acceleration_structure_update_after_bind: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, @@ -32922,90 +21593,57 @@ impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR acceleration_structure_indirect_build: Bool32::default(), acceleration_structure_host_commands: Bool32::default(), descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceAccelerationStructureFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { - PhysicalDeviceAccelerationStructureFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceAccelerationStructureFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceAccelerationStructureFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHR<'a> { + #[inline] pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self { - self.inner.acceleration_structure = acceleration_structure.into(); + self.acceleration_structure = acceleration_structure.into(); self } + #[inline] pub fn acceleration_structure_capture_replay( mut self, acceleration_structure_capture_replay: bool, ) -> Self { - self.inner.acceleration_structure_capture_replay = - acceleration_structure_capture_replay.into(); + self.acceleration_structure_capture_replay = acceleration_structure_capture_replay.into(); self } + #[inline] pub fn acceleration_structure_indirect_build( mut self, acceleration_structure_indirect_build: bool, ) -> Self { - self.inner.acceleration_structure_indirect_build = - acceleration_structure_indirect_build.into(); + self.acceleration_structure_indirect_build = acceleration_structure_indirect_build.into(); self } + #[inline] pub fn acceleration_structure_host_commands( mut self, acceleration_structure_host_commands: bool, ) -> Self { - self.inner.acceleration_structure_host_commands = - acceleration_structure_host_commands.into(); + self.acceleration_structure_host_commands = acceleration_structure_host_commands.into(); self } + #[inline] pub fn descriptor_binding_acceleration_structure_update_after_bind( mut self, descriptor_binding_acceleration_structure_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_acceleration_structure_update_after_bind = + self.descriptor_binding_acceleration_structure_update_after_bind = descriptor_binding_acceleration_structure_update_after_bind.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR { +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub ray_tracing_pipeline: Bool32, @@ -33013,8 +21651,9 @@ pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR { pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32, pub ray_tracing_pipeline_trace_rays_indirect: Bool32, pub ray_traversal_primitive_culling: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, @@ -33024,148 +21663,88 @@ impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR { ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(), ray_tracing_pipeline_trace_rays_indirect: Bool32::default(), ray_traversal_primitive_culling: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRayTracingPipelineFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { - PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceRayTracingPipelineFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> { + #[inline] pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self { - self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into(); + self.ray_tracing_pipeline = ray_tracing_pipeline.into(); self } + #[inline] pub fn ray_tracing_pipeline_shader_group_handle_capture_replay( mut self, ray_tracing_pipeline_shader_group_handle_capture_replay: bool, ) -> Self { - self.inner - .ray_tracing_pipeline_shader_group_handle_capture_replay = + self.ray_tracing_pipeline_shader_group_handle_capture_replay = ray_tracing_pipeline_shader_group_handle_capture_replay.into(); self } + #[inline] pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( mut self, ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, ) -> Self { - self.inner - .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = + self.ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into(); self } + #[inline] pub fn ray_tracing_pipeline_trace_rays_indirect( mut self, ray_tracing_pipeline_trace_rays_indirect: bool, ) -> Self { - self.inner.ray_tracing_pipeline_trace_rays_indirect = + self.ray_tracing_pipeline_trace_rays_indirect = ray_tracing_pipeline_trace_rays_indirect.into(); self } + #[inline] pub fn ray_traversal_primitive_culling( mut self, ray_traversal_primitive_culling: bool, ) -> Self { - self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into(); + self.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRayQueryFeaturesKHR { +pub struct PhysicalDeviceRayQueryFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub ray_query: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, p_next: ::std::ptr::null_mut(), ray_query: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRayQueryFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { - PhysicalDeviceRayQueryFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceRayQueryFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceRayQueryFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceRayQueryFeaturesKHR<'a> { + #[inline] pub fn ray_query(mut self, ray_query: bool) -> Self { - self.inner.ray_query = ray_query.into(); + self.ray_query = ray_query.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceAccelerationStructurePropertiesKHR { +pub struct PhysicalDeviceAccelerationStructurePropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_geometry_count: u64, @@ -33176,8 +21755,9 @@ pub struct PhysicalDeviceAccelerationStructurePropertiesKHR { pub max_descriptor_set_acceleration_structures: u32, pub max_descriptor_set_update_after_bind_acceleration_structures: u32, pub min_acceleration_structure_scratch_offset_alignment: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR { +impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, @@ -33190,106 +21770,81 @@ impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKH max_descriptor_set_acceleration_structures: u32::default(), max_descriptor_set_update_after_bind_acceleration_structures: u32::default(), min_acceleration_structure_scratch_offset_alignment: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceAccelerationStructurePropertiesKHR { - pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { - PhysicalDeviceAccelerationStructurePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { - inner: PhysicalDeviceAccelerationStructurePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_> + for PhysicalDeviceAccelerationStructurePropertiesKHR<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { - type Target = PhysicalDeviceAccelerationStructurePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { +impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHR<'a> { + #[inline] pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { - self.inner.max_geometry_count = max_geometry_count; + self.max_geometry_count = max_geometry_count; self } + #[inline] pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { - self.inner.max_instance_count = max_instance_count; + self.max_instance_count = max_instance_count; self } + #[inline] pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self { - self.inner.max_primitive_count = max_primitive_count; + self.max_primitive_count = max_primitive_count; self } + #[inline] pub fn max_per_stage_descriptor_acceleration_structures( mut self, max_per_stage_descriptor_acceleration_structures: u32, ) -> Self { - self.inner.max_per_stage_descriptor_acceleration_structures = + self.max_per_stage_descriptor_acceleration_structures = max_per_stage_descriptor_acceleration_structures; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures( mut self, max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_acceleration_structures = + self.max_per_stage_descriptor_update_after_bind_acceleration_structures = max_per_stage_descriptor_update_after_bind_acceleration_structures; self } + #[inline] pub fn max_descriptor_set_acceleration_structures( mut self, max_descriptor_set_acceleration_structures: u32, ) -> Self { - self.inner.max_descriptor_set_acceleration_structures = + self.max_descriptor_set_acceleration_structures = max_descriptor_set_acceleration_structures; self } + #[inline] pub fn max_descriptor_set_update_after_bind_acceleration_structures( mut self, max_descriptor_set_update_after_bind_acceleration_structures: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_acceleration_structures = + self.max_descriptor_set_update_after_bind_acceleration_structures = max_descriptor_set_update_after_bind_acceleration_structures; self } + #[inline] pub fn min_acceleration_structure_scratch_offset_alignment( mut self, min_acceleration_structure_scratch_offset_alignment: u32, ) -> Self { - self.inner - .min_acceleration_structure_scratch_offset_alignment = + self.min_acceleration_structure_scratch_offset_alignment = min_acceleration_structure_scratch_offset_alignment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR { +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_group_handle_size: u32, @@ -33300,8 +21855,9 @@ pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR { pub max_ray_dispatch_invocation_count: u32, pub shader_group_handle_alignment: u32, pub max_ray_hit_attribute_size: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR { +impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, @@ -33314,90 +21870,64 @@ impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR { max_ray_dispatch_invocation_count: u32::default(), shader_group_handle_alignment: u32::default(), max_ray_hit_attribute_size: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRayTracingPipelinePropertiesKHR { - pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { - PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { - inner: PhysicalDeviceRayTracingPipelinePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { - type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR<'_> {} +impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> { + #[inline] pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self { - self.inner.shader_group_handle_size = shader_group_handle_size; + self.shader_group_handle_size = shader_group_handle_size; self } + #[inline] pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self { - self.inner.max_ray_recursion_depth = max_ray_recursion_depth; + self.max_ray_recursion_depth = max_ray_recursion_depth; self } + #[inline] pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { - self.inner.max_shader_group_stride = max_shader_group_stride; + self.max_shader_group_stride = max_shader_group_stride; self } + #[inline] pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self { - self.inner.shader_group_base_alignment = shader_group_base_alignment; + self.shader_group_base_alignment = shader_group_base_alignment; self } + #[inline] pub fn shader_group_handle_capture_replay_size( mut self, shader_group_handle_capture_replay_size: u32, ) -> Self { - self.inner.shader_group_handle_capture_replay_size = - shader_group_handle_capture_replay_size; + self.shader_group_handle_capture_replay_size = shader_group_handle_capture_replay_size; self } + #[inline] pub fn max_ray_dispatch_invocation_count( mut self, max_ray_dispatch_invocation_count: u32, ) -> Self { - self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count; + self.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count; self } + #[inline] pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self { - self.inner.shader_group_handle_alignment = shader_group_handle_alignment; + self.shader_group_handle_alignment = shader_group_handle_alignment; self } + #[inline] pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self { - self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size; + self.max_ray_hit_attribute_size = max_ray_hit_attribute_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRayTracingPropertiesNV { +pub struct PhysicalDeviceRayTracingPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_group_handle_size: u32, @@ -33408,8 +21938,9 @@ pub struct PhysicalDeviceRayTracingPropertiesNV { pub max_instance_count: u64, pub max_triangle_count: u64, pub max_descriptor_set_acceleration_structures: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV { +impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, @@ -33422,78 +21953,56 @@ impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV { max_instance_count: u64::default(), max_triangle_count: u64::default(), max_descriptor_set_acceleration_structures: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRayTracingPropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { - PhysicalDeviceRayTracingPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { - inner: PhysicalDeviceRayTracingPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { - type Target = PhysicalDeviceRayTracingPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV<'_> {} +impl<'a> PhysicalDeviceRayTracingPropertiesNV<'a> { + #[inline] pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self { - self.inner.shader_group_handle_size = shader_group_handle_size; + self.shader_group_handle_size = shader_group_handle_size; self } + #[inline] pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { - self.inner.max_recursion_depth = max_recursion_depth; + self.max_recursion_depth = max_recursion_depth; self } + #[inline] pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { - self.inner.max_shader_group_stride = max_shader_group_stride; + self.max_shader_group_stride = max_shader_group_stride; self } + #[inline] pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self { - self.inner.shader_group_base_alignment = shader_group_base_alignment; + self.shader_group_base_alignment = shader_group_base_alignment; self } + #[inline] pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { - self.inner.max_geometry_count = max_geometry_count; + self.max_geometry_count = max_geometry_count; self } + #[inline] pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { - self.inner.max_instance_count = max_instance_count; + self.max_instance_count = max_instance_count; self } + #[inline] pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self { - self.inner.max_triangle_count = max_triangle_count; + self.max_triangle_count = max_triangle_count; self } + #[inline] pub fn max_descriptor_set_acceleration_structures( mut self, max_descriptor_set_acceleration_structures: u32, ) -> Self { - self.inner.max_descriptor_set_acceleration_structures = + self.max_descriptor_set_acceleration_structures = max_descriptor_set_acceleration_structures; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -33505,48 +22014,21 @@ pub struct StridedDeviceAddressRegionKHR { pub size: DeviceSize, } impl StridedDeviceAddressRegionKHR { - pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> { - StridedDeviceAddressRegionKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct StridedDeviceAddressRegionKHRBuilder<'a> { - inner: StridedDeviceAddressRegionKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> { - type Target = StridedDeviceAddressRegionKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> { + #[inline] pub fn device_address(mut self, device_address: DeviceAddress) -> Self { - self.inner.device_address = device_address; + self.device_address = device_address; self } + #[inline] pub fn stride(mut self, stride: DeviceSize) -> Self { - self.inner.stride = stride; + self.stride = stride; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> StridedDeviceAddressRegionKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -33558,110 +22040,55 @@ pub struct TraceRaysIndirectCommandKHR { pub depth: u32, } impl TraceRaysIndirectCommandKHR { - pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> { - TraceRaysIndirectCommandKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct TraceRaysIndirectCommandKHRBuilder<'a> { - inner: TraceRaysIndirectCommandKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> { - type Target = TraceRaysIndirectCommandKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> { + #[inline] pub fn width(mut self, width: u32) -> Self { - self.inner.width = width; + self.width = width; self } + #[inline] pub fn height(mut self, height: u32) -> Self { - self.inner.height = height; + self.height = height; self } + #[inline] pub fn depth(mut self, depth: u32) -> Self { - self.inner.depth = depth; + self.depth = depth; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> TraceRaysIndirectCommandKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DrmFormatModifierPropertiesListEXT { +pub struct DrmFormatModifierPropertiesListEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub drm_format_modifier_count: u32, pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DrmFormatModifierPropertiesListEXT { +impl ::std::default::Default for DrmFormatModifierPropertiesListEXT<'_> { fn default() -> Self { Self { s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, p_next: ::std::ptr::null_mut(), drm_format_modifier_count: u32::default(), p_drm_format_modifier_properties: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl DrmFormatModifierPropertiesListEXT { - pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> { - DrmFormatModifierPropertiesListEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> { - inner: DrmFormatModifierPropertiesListEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {} -impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> { - type Target = DrmFormatModifierPropertiesListEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> { +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT<'_> {} +impl<'a> DrmFormatModifierPropertiesListEXT<'a> { + #[inline] pub fn drm_format_modifier_properties( mut self, drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT], ) -> Self { - self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _; - self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrmFormatModifierPropertiesListEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -33673,65 +22100,39 @@ pub struct DrmFormatModifierPropertiesEXT { pub drm_format_modifier_tiling_features: FormatFeatureFlags, } impl DrmFormatModifierPropertiesEXT { - pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> { - DrmFormatModifierPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrmFormatModifierPropertiesEXTBuilder<'a> { - inner: DrmFormatModifierPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> { - type Target = DrmFormatModifierPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> { + #[inline] pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { - self.inner.drm_format_modifier = drm_format_modifier; + self.drm_format_modifier = drm_format_modifier; self } + #[inline] pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { - self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; self } + #[inline] pub fn drm_format_modifier_tiling_features( mut self, drm_format_modifier_tiling_features: FormatFeatureFlags, ) -> Self { - self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrmFormatModifierPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT { +pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub drm_format_modifier: u64, pub sharing_mode: SharingMode, pub queue_family_index_count: u32, pub p_queue_family_indices: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT { +impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, @@ -33740,130 +22141,76 @@ impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT { sharing_mode: SharingMode::default(), queue_family_index_count: u32::default(), p_queue_family_indices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PhysicalDeviceImageDrmFormatModifierInfoEXT { - pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { - PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { - inner: PhysicalDeviceImageDrmFormatModifierInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 - for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_> + for PhysicalDeviceImageDrmFormatModifierInfoEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { - type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { +impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> { + #[inline] pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { - self.inner.drm_format_modifier = drm_format_modifier; + self.drm_format_modifier = drm_format_modifier; self } + #[inline] pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { - self.inner.sharing_mode = sharing_mode; + self.sharing_mode = sharing_mode; self } + #[inline] pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { - self.inner.queue_family_index_count = queue_family_indices.len() as _; - self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self.queue_family_index_count = queue_family_indices.len() as _; + self.p_queue_family_indices = queue_family_indices.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageDrmFormatModifierListCreateInfoEXT { +pub struct ImageDrmFormatModifierListCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub drm_format_modifier_count: u32, pub p_drm_format_modifiers: *const u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT { +impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, p_next: ::std::ptr::null(), drm_format_modifier_count: u32::default(), p_drm_format_modifiers: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ImageDrmFormatModifierListCreateInfoEXT { - pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { - ImageDrmFormatModifierListCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { - inner: ImageDrmFormatModifierListCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {} -impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { - type Target = ImageDrmFormatModifierListCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT<'_> {} +impl<'a> ImageDrmFormatModifierListCreateInfoEXT<'a> { + #[inline] pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self { - self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _; - self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr(); + self.drm_format_modifier_count = drm_format_modifiers.len() as _; + self.p_drm_format_modifiers = drm_format_modifiers.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageDrmFormatModifierExplicitCreateInfoEXT { +pub struct ImageDrmFormatModifierExplicitCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub drm_format_modifier: u64, pub drm_format_modifier_plane_count: u32, pub p_plane_layouts: *const SubresourceLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT { +impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, @@ -33871,235 +22218,124 @@ impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT { drm_format_modifier: u64::default(), drm_format_modifier_plane_count: u32::default(), p_plane_layouts: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ImageDrmFormatModifierExplicitCreateInfoEXT { - pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { - ImageDrmFormatModifierExplicitCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { - inner: ImageDrmFormatModifierExplicitCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {} -impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { - type Target = ImageDrmFormatModifierExplicitCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT<'_> {} +impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXT<'a> { + #[inline] pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { - self.inner.drm_format_modifier = drm_format_modifier; + self.drm_format_modifier = drm_format_modifier; self } + #[inline] pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self { - self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _; - self.inner.p_plane_layouts = plane_layouts.as_ptr(); + self.drm_format_modifier_plane_count = plane_layouts.len() as _; + self.p_plane_layouts = plane_layouts.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageDrmFormatModifierPropertiesEXT { +pub struct ImageDrmFormatModifierPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub drm_format_modifier: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT { +impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), drm_format_modifier: u64::default(), + _marker: PhantomData, } } } -impl ImageDrmFormatModifierPropertiesEXT { - pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { - ImageDrmFormatModifierPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> { - inner: ImageDrmFormatModifierPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { - type Target = ImageDrmFormatModifierPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { +impl<'a> ImageDrmFormatModifierPropertiesEXT<'a> { + #[inline] pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { - self.inner.drm_format_modifier = drm_format_modifier; + self.drm_format_modifier = drm_format_modifier; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageStencilUsageCreateInfo { +pub struct ImageStencilUsageCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub stencil_usage: ImageUsageFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageStencilUsageCreateInfo { +impl ::std::default::Default for ImageStencilUsageCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO, p_next: ::std::ptr::null(), stencil_usage: ImageUsageFlags::default(), + _marker: PhantomData, } } } -impl ImageStencilUsageCreateInfo { - pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> { - ImageStencilUsageCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageStencilUsageCreateInfoBuilder<'a> { - inner: ImageStencilUsageCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {} -impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> { - type Target = ImageStencilUsageCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageStencilUsageCreateInfoBuilder<'a> { +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo<'_> {} +impl<'a> ImageStencilUsageCreateInfo<'a> { + #[inline] pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self { - self.inner.stencil_usage = stencil_usage; + self.stencil_usage = stencil_usage; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageStencilUsageCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceMemoryOverallocationCreateInfoAMD { +pub struct DeviceMemoryOverallocationCreateInfoAMD<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub overallocation_behavior: MemoryOverallocationBehaviorAMD, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD { +impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, p_next: ::std::ptr::null(), overallocation_behavior: MemoryOverallocationBehaviorAMD::default(), + _marker: PhantomData, } } } -impl DeviceMemoryOverallocationCreateInfoAMD { - pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { - DeviceMemoryOverallocationCreateInfoAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { - inner: DeviceMemoryOverallocationCreateInfoAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {} -impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { - type Target = DeviceMemoryOverallocationCreateInfoAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD<'_> {} +impl<'a> DeviceMemoryOverallocationCreateInfoAMD<'a> { + #[inline] pub fn overallocation_behavior( mut self, overallocation_behavior: MemoryOverallocationBehaviorAMD, ) -> Self { - self.inner.overallocation_behavior = overallocation_behavior; + self.overallocation_behavior = overallocation_behavior; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT { +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_density_map: Bool32, pub fragment_density_map_dynamic: Bool32, pub fragment_density_map_non_subsampled_images: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, @@ -34107,201 +22343,107 @@ impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { fragment_density_map: Bool32::default(), fragment_density_map_dynamic: Bool32::default(), fragment_density_map_non_subsampled_images: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentDensityMapFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> { + #[inline] pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self { - self.inner.fragment_density_map = fragment_density_map.into(); + self.fragment_density_map = fragment_density_map.into(); self } + #[inline] pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self { - self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); + self.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); self } + #[inline] pub fn fragment_density_map_non_subsampled_images( mut self, fragment_density_map_non_subsampled_images: bool, ) -> Self { - self.inner.fragment_density_map_non_subsampled_images = + self.fragment_density_map_non_subsampled_images = fragment_density_map_non_subsampled_images.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT { +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_density_map_deferred: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT { +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, p_next: ::std::ptr::null_mut(), fragment_density_map_deferred: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentDensityMap2FeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { - PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> { + #[inline] pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self { - self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into(); + self.fragment_density_map_deferred = fragment_density_map_deferred.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_density_map_offset: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, p_next: ::std::ptr::null_mut(), fragment_density_map_offset: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { - PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM<'a> { + #[inline] pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self { - self.inner.fragment_density_map_offset = fragment_density_map_offset.into(); + self.fragment_density_map_offset = fragment_density_map_offset.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_fragment_density_texel_size: Extent2D, pub max_fragment_density_texel_size: Extent2D, pub fragment_density_invocations: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, @@ -34309,77 +22451,48 @@ impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { min_fragment_density_texel_size: Extent2D::default(), max_fragment_density_texel_size: Extent2D::default(), fragment_density_invocations: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentDensityMapPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { + #[inline] pub fn min_fragment_density_texel_size( mut self, min_fragment_density_texel_size: Extent2D, ) -> Self { - self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size; + self.min_fragment_density_texel_size = min_fragment_density_texel_size; self } + #[inline] pub fn max_fragment_density_texel_size( mut self, max_fragment_density_texel_size: Extent2D, ) -> Self { - self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size; + self.max_fragment_density_texel_size = max_fragment_density_texel_size; self } + #[inline] pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self { - self.inner.fragment_density_invocations = fragment_density_invocations.into(); + self.fragment_density_invocations = fragment_density_invocations.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT { +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub subsampled_loads: Bool32, pub subsampled_coarse_reconstruction_early_access: Bool32, pub max_subsampled_array_layers: u32, pub max_descriptor_set_subsampled_samplers: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT { +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, @@ -34388,813 +22501,433 @@ impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT subsampled_coarse_reconstruction_early_access: Bool32::default(), max_subsampled_array_layers: u32::default(), max_descriptor_set_subsampled_samplers: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentDensityMap2PropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { - PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_> + for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { +impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { + #[inline] pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self { - self.inner.subsampled_loads = subsampled_loads.into(); + self.subsampled_loads = subsampled_loads.into(); self } + #[inline] pub fn subsampled_coarse_reconstruction_early_access( mut self, subsampled_coarse_reconstruction_early_access: bool, ) -> Self { - self.inner.subsampled_coarse_reconstruction_early_access = + self.subsampled_coarse_reconstruction_early_access = subsampled_coarse_reconstruction_early_access.into(); self } + #[inline] pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self { - self.inner.max_subsampled_array_layers = max_subsampled_array_layers; + self.max_subsampled_array_layers = max_subsampled_array_layers; self } + #[inline] pub fn max_descriptor_set_subsampled_samplers( mut self, max_descriptor_set_subsampled_samplers: u32, ) -> Self { - self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers; + self.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_density_offset_granularity: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, p_next: ::std::ptr::null_mut(), fragment_density_offset_granularity: Extent2D::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { - pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { - PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { - inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_> + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM -{ -} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { - type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { +impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM<'a> { + #[inline] pub fn fragment_density_offset_granularity( mut self, fragment_density_offset_granularity: Extent2D, ) -> Self { - self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity; + self.fragment_density_offset_granularity = fragment_density_offset_granularity; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassFragmentDensityMapCreateInfoEXT { +pub struct RenderPassFragmentDensityMapCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fragment_density_map_attachment: AttachmentReference, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT { +impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, p_next: ::std::ptr::null(), fragment_density_map_attachment: AttachmentReference::default(), + _marker: PhantomData, } } } -impl RenderPassFragmentDensityMapCreateInfoEXT { - pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - RenderPassFragmentDensityMapCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - inner: RenderPassFragmentDensityMapCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} -unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {} -impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - type Target = RenderPassFragmentDensityMapCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT<'_> {} +impl<'a> RenderPassFragmentDensityMapCreateInfoEXT<'a> { + #[inline] pub fn fragment_density_map_attachment( mut self, fragment_density_map_attachment: AttachmentReference, ) -> Self { - self.inner.fragment_density_map_attachment = fragment_density_map_attachment; + self.fragment_density_map_attachment = fragment_density_map_attachment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM { +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fragment_density_offset_count: u32, pub p_fragment_density_offsets: *const Offset2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM { +impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, p_next: ::std::ptr::null(), fragment_density_offset_count: u32::default(), p_fragment_density_offsets: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubpassFragmentDensityMapOffsetEndInfoQCOM { - pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { - SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { - inner: SubpassFragmentDensityMapOffsetEndInfoQCOM, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {} -unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {} -impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { - type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM<'_> {} +impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOM<'a> { + #[inline] pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self { - self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _; - self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr(); + self.fragment_density_offset_count = fragment_density_offsets.len() as _; + self.p_fragment_density_offsets = fragment_density_offsets.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceScalarBlockLayoutFeatures { +pub struct PhysicalDeviceScalarBlockLayoutFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub scalar_block_layout: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures { +impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, p_next: ::std::ptr::null_mut(), scalar_block_layout: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceScalarBlockLayoutFeatures { - pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { - PhysicalDeviceScalarBlockLayoutFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { - inner: PhysicalDeviceScalarBlockLayoutFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { - type Target = PhysicalDeviceScalarBlockLayoutFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures<'_> {} +impl<'a> PhysicalDeviceScalarBlockLayoutFeatures<'a> { + #[inline] pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { - self.inner.scalar_block_layout = scalar_block_layout.into(); + self.scalar_block_layout = scalar_block_layout.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceProtectedCapabilitiesKHR { +pub struct SurfaceProtectedCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub supports_protected: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR { +impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR, p_next: ::std::ptr::null(), supports_protected: Bool32::default(), + _marker: PhantomData, } } } -impl SurfaceProtectedCapabilitiesKHR { - pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> { - SurfaceProtectedCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> { - inner: SurfaceProtectedCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {} -unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {} -impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> { - type Target = SurfaceProtectedCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> { +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR<'_> {} +impl<'a> SurfaceProtectedCapabilitiesKHR<'a> { + #[inline] pub fn supports_protected(mut self, supports_protected: bool) -> Self { - self.inner.supports_protected = supports_protected.into(); + self.supports_protected = supports_protected.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceProtectedCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures { +pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub uniform_buffer_standard_layout: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures { +impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, p_next: ::std::ptr::null_mut(), uniform_buffer_standard_layout: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceUniformBufferStandardLayoutFeatures { - pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { - PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { - inner: PhysicalDeviceUniformBufferStandardLayoutFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> + for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { - type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures<'_> {} +impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> { + #[inline] pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self { - self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDepthClipEnableFeaturesEXT { +pub struct PhysicalDeviceDepthClipEnableFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub depth_clip_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, p_next: ::std::ptr::null_mut(), depth_clip_enable: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDepthClipEnableFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { - PhysicalDeviceDepthClipEnableFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceDepthClipEnableFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceDepthClipEnableFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXT<'a> { + #[inline] pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { - self.inner.depth_clip_enable = depth_clip_enable.into(); + self.depth_clip_enable = depth_clip_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationDepthClipStateCreateInfoEXT { +pub struct PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT, pub depth_clip_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT { +impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(), depth_clip_enable: Bool32::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationDepthClipStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { - PipelineRasterizationDepthClipStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { - inner: PipelineRasterizationDepthClipStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_> + for PipelineRasterizationDepthClipStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationDepthClipStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { - type Target = PipelineRasterizationDepthClipStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { - self.inner.depth_clip_enable = depth_clip_enable.into(); + self.depth_clip_enable = depth_clip_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMemoryBudgetPropertiesEXT { +pub struct PhysicalDeviceMemoryBudgetPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), heap_budget: unsafe { ::std::mem::zeroed() }, heap_usage: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PhysicalDeviceMemoryBudgetPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - PhysicalDeviceMemoryBudgetPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceMemoryBudgetPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceMemoryProperties2 - for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXT<'a> { + #[inline] pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self { - self.inner.heap_budget = heap_budget; + self.heap_budget = heap_budget; self } + #[inline] pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self { - self.inner.heap_usage = heap_usage; + self.heap_usage = heap_usage; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMemoryPriorityFeaturesEXT { +pub struct PhysicalDeviceMemoryPriorityFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_priority: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, p_next: ::std::ptr::null_mut(), memory_priority: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMemoryPriorityFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - PhysicalDeviceMemoryPriorityFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceMemoryPriorityFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXT<'a> { + #[inline] pub fn memory_priority(mut self, memory_priority: bool) -> Self { - self.inner.memory_priority = memory_priority.into(); + self.memory_priority = memory_priority.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryPriorityAllocateInfoEXT { +pub struct MemoryPriorityAllocateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub priority: f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryPriorityAllocateInfoEXT { +impl ::std::default::Default for MemoryPriorityAllocateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT, p_next: ::std::ptr::null(), priority: f32::default(), + _marker: PhantomData, } } } -impl MemoryPriorityAllocateInfoEXT { - pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> { - MemoryPriorityAllocateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { - inner: MemoryPriorityAllocateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} -impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { - type Target = MemoryPriorityAllocateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT<'_> {} +impl<'a> MemoryPriorityAllocateInfoEXT<'a> { + #[inline] pub fn priority(mut self, priority: f32) -> Self { - self.inner.priority = priority; + self.priority = priority; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryPriorityAllocateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { +pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub pageable_device_local_memory: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { +impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, p_next: ::std::ptr::null_mut(), pageable_device_local_memory: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { - pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { - PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { - inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_> + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { - type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'_> {} +impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> { + #[inline] pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self { - self.inner.pageable_device_local_memory = pageable_device_local_memory.into(); + self.pageable_device_local_memory = pageable_device_local_memory.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceBufferDeviceAddressFeatures { +pub struct PhysicalDeviceBufferDeviceAddressFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub buffer_device_address: Bool32, pub buffer_device_address_capture_replay: Bool32, pub buffer_device_address_multi_device: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures { +impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, @@ -35202,79 +22935,48 @@ impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures { buffer_device_address: Bool32::default(), buffer_device_address_capture_replay: Bool32::default(), buffer_device_address_multi_device: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceBufferDeviceAddressFeatures { - pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { - PhysicalDeviceBufferDeviceAddressFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { - inner: PhysicalDeviceBufferDeviceAddressFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { - type Target = PhysicalDeviceBufferDeviceAddressFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures<'_> {} +impl<'a> PhysicalDeviceBufferDeviceAddressFeatures<'a> { + #[inline] pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { - self.inner.buffer_device_address = buffer_device_address.into(); + self.buffer_device_address = buffer_device_address.into(); self } + #[inline] pub fn buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> Self { - self.inner.buffer_device_address_capture_replay = - buffer_device_address_capture_replay.into(); + self.buffer_device_address_capture_replay = buffer_device_address_capture_replay.into(); self } + #[inline] pub fn buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> Self { - self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { +pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub buffer_device_address: Bool32, pub buffer_device_address_capture_replay: Bool32, pub buffer_device_address_multi_device: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, @@ -35282,485 +22984,252 @@ impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT { buffer_device_address: Bool32::default(), buffer_device_address_capture_replay: Bool32::default(), buffer_device_address_multi_device: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceBufferDeviceAddressFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { - PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> { + #[inline] pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { - self.inner.buffer_device_address = buffer_device_address.into(); + self.buffer_device_address = buffer_device_address.into(); self } + #[inline] pub fn buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> Self { - self.inner.buffer_device_address_capture_replay = - buffer_device_address_capture_replay.into(); + self.buffer_device_address_capture_replay = buffer_device_address_capture_replay.into(); self } + #[inline] pub fn buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> Self { - self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferDeviceAddressInfo { +pub struct BufferDeviceAddressInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferDeviceAddressInfo { +impl ::std::default::Default for BufferDeviceAddressInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO, p_next: ::std::ptr::null(), buffer: Buffer::default(), + _marker: PhantomData, } } } -impl BufferDeviceAddressInfo { - pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> { - BufferDeviceAddressInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferDeviceAddressInfoBuilder<'a> { - inner: BufferDeviceAddressInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> { - type Target = BufferDeviceAddressInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferDeviceAddressInfoBuilder<'a> { +impl<'a> BufferDeviceAddressInfo<'a> { + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferDeviceAddressInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferOpaqueCaptureAddressCreateInfo { +pub struct BufferOpaqueCaptureAddressCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub opaque_capture_address: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo { +impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, p_next: ::std::ptr::null(), opaque_capture_address: u64::default(), + _marker: PhantomData, } } } -impl BufferOpaqueCaptureAddressCreateInfo { - pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { - BufferOpaqueCaptureAddressCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { - inner: BufferOpaqueCaptureAddressCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {} -impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { - type Target = BufferOpaqueCaptureAddressCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { +unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo<'_> {} +impl<'a> BufferOpaqueCaptureAddressCreateInfo<'a> { + #[inline] pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { - self.inner.opaque_capture_address = opaque_capture_address; + self.opaque_capture_address = opaque_capture_address; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferDeviceAddressCreateInfoEXT { +pub struct BufferDeviceAddressCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub device_address: DeviceAddress, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT { +impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, p_next: ::std::ptr::null(), device_address: DeviceAddress::default(), + _marker: PhantomData, } } } -impl BufferDeviceAddressCreateInfoEXT { - pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { - BufferDeviceAddressCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { - inner: BufferDeviceAddressCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} -impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { - type Target = BufferDeviceAddressCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT<'_> {} +impl<'a> BufferDeviceAddressCreateInfoEXT<'a> { + #[inline] pub fn device_address(mut self, device_address: DeviceAddress) -> Self { - self.inner.device_address = device_address; + self.device_address = device_address; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceImageViewImageFormatInfoEXT { +pub struct PhysicalDeviceImageViewImageFormatInfoEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub image_view_type: ImageViewType, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT { +impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, p_next: ::std::ptr::null_mut(), image_view_type: ImageViewType::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceImageViewImageFormatInfoEXT { - pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { - PhysicalDeviceImageViewImageFormatInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { - inner: PhysicalDeviceImageViewImageFormatInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 - for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_> + for PhysicalDeviceImageViewImageFormatInfoEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { - type Target = PhysicalDeviceImageViewImageFormatInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { +impl<'a> PhysicalDeviceImageViewImageFormatInfoEXT<'a> { + #[inline] pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self { - self.inner.image_view_type = image_view_type; + self.image_view_type = image_view_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FilterCubicImageViewImageFormatPropertiesEXT { +pub struct FilterCubicImageViewImageFormatPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub filter_cubic: Bool32, pub filter_cubic_minmax: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT { +impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), filter_cubic: Bool32::default(), filter_cubic_minmax: Bool32::default(), + _marker: PhantomData, } } } -impl FilterCubicImageViewImageFormatPropertiesEXT { - pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { - FilterCubicImageViewImageFormatPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { - inner: FilterCubicImageViewImageFormatPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageFormatProperties2 - for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {} -impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { - type Target = FilterCubicImageViewImageFormatPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { +unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT<'_> {} +impl<'a> FilterCubicImageViewImageFormatPropertiesEXT<'a> { + #[inline] pub fn filter_cubic(mut self, filter_cubic: bool) -> Self { - self.inner.filter_cubic = filter_cubic.into(); + self.filter_cubic = filter_cubic.into(); self } + #[inline] pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self { - self.inner.filter_cubic_minmax = filter_cubic_minmax.into(); + self.filter_cubic_minmax = filter_cubic_minmax.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceImagelessFramebufferFeatures { +pub struct PhysicalDeviceImagelessFramebufferFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub imageless_framebuffer: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures { +impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, p_next: ::std::ptr::null_mut(), imageless_framebuffer: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceImagelessFramebufferFeatures { - pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { - PhysicalDeviceImagelessFramebufferFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { - inner: PhysicalDeviceImagelessFramebufferFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { - type Target = PhysicalDeviceImagelessFramebufferFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures<'_> {} +impl<'a> PhysicalDeviceImagelessFramebufferFeatures<'a> { + #[inline] pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { - self.inner.imageless_framebuffer = imageless_framebuffer.into(); + self.imageless_framebuffer = imageless_framebuffer.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FramebufferAttachmentsCreateInfo { +pub struct FramebufferAttachmentsCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub attachment_image_info_count: u32, - pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo, + pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FramebufferAttachmentsCreateInfo { +impl ::std::default::Default for FramebufferAttachmentsCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, p_next: ::std::ptr::null(), attachment_image_info_count: u32::default(), p_attachment_image_infos: ::std::ptr::null(), + _marker: PhantomData, } } } -impl FramebufferAttachmentsCreateInfo { - pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> { - FramebufferAttachmentsCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FramebufferAttachmentsCreateInfoBuilder<'a> { - inner: FramebufferAttachmentsCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {} -unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {} -impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> { - type Target = FramebufferAttachmentsCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> { +unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo<'_> {} +impl<'a> FramebufferAttachmentsCreateInfo<'a> { + #[inline] pub fn attachment_image_infos( mut self, attachment_image_infos: &'a [FramebufferAttachmentImageInfo], ) -> Self { - self.inner.attachment_image_info_count = attachment_image_infos.len() as _; - self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr(); + self.attachment_image_info_count = attachment_image_infos.len() as _; + self.p_attachment_image_infos = attachment_image_infos.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FramebufferAttachmentsCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FramebufferAttachmentImageInfo { +pub struct FramebufferAttachmentImageInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: ImageCreateFlags, @@ -35770,8 +23239,9 @@ pub struct FramebufferAttachmentImageInfo { pub layer_count: u32, pub view_format_count: u32, pub p_view_formats: *const Format, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FramebufferAttachmentImageInfo { +impl ::std::default::Default for FramebufferAttachmentImageInfo<'_> { fn default() -> Self { Self { s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, @@ -35783,324 +23253,179 @@ impl ::std::default::Default for FramebufferAttachmentImageInfo { layer_count: u32::default(), view_format_count: u32::default(), p_view_formats: ::std::ptr::null(), + _marker: PhantomData, } } } -impl FramebufferAttachmentImageInfo { - pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> { - FramebufferAttachmentImageInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FramebufferAttachmentImageInfoBuilder<'a> { - inner: FramebufferAttachmentImageInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> { - type Target = FramebufferAttachmentImageInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FramebufferAttachmentImageInfoBuilder<'a> { +impl<'a> FramebufferAttachmentImageInfo<'a> { + #[inline] pub fn flags(mut self, flags: ImageCreateFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn usage(mut self, usage: ImageUsageFlags) -> Self { - self.inner.usage = usage; + self.usage = usage; self } + #[inline] pub fn width(mut self, width: u32) -> Self { - self.inner.width = width; + self.width = width; self } + #[inline] pub fn height(mut self, height: u32) -> Self { - self.inner.height = height; + self.height = height; self } + #[inline] pub fn layer_count(mut self, layer_count: u32) -> Self { - self.inner.layer_count = layer_count; + self.layer_count = layer_count; self } + #[inline] pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self { - self.inner.view_format_count = view_formats.len() as _; - self.inner.p_view_formats = view_formats.as_ptr(); + self.view_format_count = view_formats.len() as _; + self.p_view_formats = view_formats.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FramebufferAttachmentImageInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassAttachmentBeginInfo { +pub struct RenderPassAttachmentBeginInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub attachment_count: u32, pub p_attachments: *const ImageView, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassAttachmentBeginInfo { +impl ::std::default::Default for RenderPassAttachmentBeginInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO, p_next: ::std::ptr::null(), attachment_count: u32::default(), p_attachments: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderPassAttachmentBeginInfo { - pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> { - RenderPassAttachmentBeginInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassAttachmentBeginInfoBuilder<'a> { - inner: RenderPassAttachmentBeginInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {} -impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> { - type Target = RenderPassAttachmentBeginInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> { +unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo<'_> {} +impl<'a> RenderPassAttachmentBeginInfo<'a> { + #[inline] pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self { - self.inner.attachment_count = attachments.len() as _; - self.inner.p_attachments = attachments.as_ptr(); + self.attachment_count = attachments.len() as _; + self.p_attachments = attachments.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassAttachmentBeginInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures { +pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub texture_compression_astc_hdr: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures { +impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, p_next: ::std::ptr::null_mut(), texture_compression_astc_hdr: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTextureCompressionASTCHDRFeatures { - pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { - PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { - inner: PhysicalDeviceTextureCompressionASTCHDRFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { - type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures<'_> {} +impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> { + #[inline] pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self { - self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCooperativeMatrixFeaturesNV { +pub struct PhysicalDeviceCooperativeMatrixFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub cooperative_matrix: Bool32, pub cooperative_matrix_robust_buffer_access: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV { +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, p_next: ::std::ptr::null_mut(), cooperative_matrix: Bool32::default(), cooperative_matrix_robust_buffer_access: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCooperativeMatrixFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { - PhysicalDeviceCooperativeMatrixFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { - inner: PhysicalDeviceCooperativeMatrixFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceCooperativeMatrixFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV<'_> {} +impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNV<'a> { + #[inline] pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self { - self.inner.cooperative_matrix = cooperative_matrix.into(); + self.cooperative_matrix = cooperative_matrix.into(); self } + #[inline] pub fn cooperative_matrix_robust_buffer_access( mut self, cooperative_matrix_robust_buffer_access: bool, ) -> Self { - self.inner.cooperative_matrix_robust_buffer_access = + self.cooperative_matrix_robust_buffer_access = cooperative_matrix_robust_buffer_access.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCooperativeMatrixPropertiesNV { +pub struct PhysicalDeviceCooperativeMatrixPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub cooperative_matrix_supported_stages: ShaderStageFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV { +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, p_next: ::std::ptr::null_mut(), cooperative_matrix_supported_stages: ShaderStageFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCooperativeMatrixPropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { - PhysicalDeviceCooperativeMatrixPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { - inner: PhysicalDeviceCooperativeMatrixPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { - type Target = PhysicalDeviceCooperativeMatrixPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV<'_> {} +impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNV<'a> { + #[inline] pub fn cooperative_matrix_supported_stages( mut self, cooperative_matrix_supported_stages: ShaderStageFlags, ) -> Self { - self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; + self.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CooperativeMatrixPropertiesNV { +pub struct CooperativeMatrixPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub m_size: u32, @@ -36111,8 +23436,9 @@ pub struct CooperativeMatrixPropertiesNV { pub c_type: ComponentTypeNV, pub d_type: ComponentTypeNV, pub scope: ScopeNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CooperativeMatrixPropertiesNV { +impl ::std::default::Default for CooperativeMatrixPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV, @@ -36125,146 +23451,94 @@ impl ::std::default::Default for CooperativeMatrixPropertiesNV { c_type: ComponentTypeNV::default(), d_type: ComponentTypeNV::default(), scope: ScopeNV::default(), + _marker: PhantomData, } } } -impl CooperativeMatrixPropertiesNV { - pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> { - CooperativeMatrixPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CooperativeMatrixPropertiesNVBuilder<'a> { - inner: CooperativeMatrixPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> { - type Target = CooperativeMatrixPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> { +impl<'a> CooperativeMatrixPropertiesNV<'a> { + #[inline] pub fn m_size(mut self, m_size: u32) -> Self { - self.inner.m_size = m_size; + self.m_size = m_size; self } + #[inline] pub fn n_size(mut self, n_size: u32) -> Self { - self.inner.n_size = n_size; + self.n_size = n_size; self } + #[inline] pub fn k_size(mut self, k_size: u32) -> Self { - self.inner.k_size = k_size; + self.k_size = k_size; self } + #[inline] pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self { - self.inner.a_type = a_type; + self.a_type = a_type; self } + #[inline] pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self { - self.inner.b_type = b_type; + self.b_type = b_type; self } + #[inline] pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self { - self.inner.c_type = c_type; + self.c_type = c_type; self } + #[inline] pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self { - self.inner.d_type = d_type; + self.d_type = d_type; self } + #[inline] pub fn scope(mut self, scope: ScopeNV) -> Self { - self.inner.scope = scope; + self.scope = scope; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CooperativeMatrixPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { +pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub ycbcr_image_arrays: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, p_next: ::std::ptr::null_mut(), ycbcr_image_arrays: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceYcbcrImageArraysFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { - PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> { + #[inline] pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self { - self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into(); + self.ycbcr_image_arrays = ycbcr_image_arrays.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageViewHandleInfoNVX { +pub struct ImageViewHandleInfoNVX<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image_view: ImageView, pub descriptor_type: DescriptorType, pub sampler: Sampler, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageViewHandleInfoNVX { +impl ::std::default::Default for ImageViewHandleInfoNVX<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX, @@ -36272,168 +23546,88 @@ impl ::std::default::Default for ImageViewHandleInfoNVX { image_view: ImageView::default(), descriptor_type: DescriptorType::default(), sampler: Sampler::default(), + _marker: PhantomData, } } } -impl ImageViewHandleInfoNVX { - pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> { - ImageViewHandleInfoNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageViewHandleInfoNVXBuilder<'a> { - inner: ImageViewHandleInfoNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> { - type Target = ImageViewHandleInfoNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageViewHandleInfoNVXBuilder<'a> { +impl<'a> ImageViewHandleInfoNVX<'a> { + #[inline] pub fn image_view(mut self, image_view: ImageView) -> Self { - self.inner.image_view = image_view; + self.image_view = image_view; self } + #[inline] pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { - self.inner.descriptor_type = descriptor_type; + self.descriptor_type = descriptor_type; self } + #[inline] pub fn sampler(mut self, sampler: Sampler) -> Self { - self.inner.sampler = sampler; + self.sampler = sampler; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageViewHandleInfoNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageViewAddressPropertiesNVX { +pub struct ImageViewAddressPropertiesNVX<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub device_address: DeviceAddress, pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageViewAddressPropertiesNVX { +impl ::std::default::Default for ImageViewAddressPropertiesNVX<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, p_next: ::std::ptr::null_mut(), device_address: DeviceAddress::default(), size: DeviceSize::default(), + _marker: PhantomData, } } } -impl ImageViewAddressPropertiesNVX { - pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> { - ImageViewAddressPropertiesNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageViewAddressPropertiesNVXBuilder<'a> { - inner: ImageViewAddressPropertiesNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> { - type Target = ImageViewAddressPropertiesNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> { +impl<'a> ImageViewAddressPropertiesNVX<'a> { + #[inline] pub fn device_address(mut self, device_address: DeviceAddress) -> Self { - self.inner.device_address = device_address; + self.device_address = device_address; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageViewAddressPropertiesNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PresentFrameTokenGGP { +pub struct PresentFrameTokenGGP<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub frame_token: GgpFrameToken, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PresentFrameTokenGGP { +impl ::std::default::Default for PresentFrameTokenGGP<'_> { fn default() -> Self { Self { s_type: StructureType::PRESENT_FRAME_TOKEN_GGP, p_next: ::std::ptr::null(), frame_token: GgpFrameToken::default(), + _marker: PhantomData, } } } -impl PresentFrameTokenGGP { - pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> { - PresentFrameTokenGGPBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PresentFrameTokenGGPBuilder<'a> { - inner: PresentFrameTokenGGP, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {} -unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {} -impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> { - type Target = PresentFrameTokenGGP; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PresentFrameTokenGGPBuilder<'a> { +unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP<'_> {} +impl<'a> PresentFrameTokenGGP<'a> { + #[inline] pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self { - self.inner.frame_token = frame_token; + self.frame_token = frame_token; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PresentFrameTokenGGP { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -36444,57 +23638,30 @@ pub struct PipelineCreationFeedback { pub duration: u64, } impl PipelineCreationFeedback { - pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> { - PipelineCreationFeedbackBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCreationFeedbackBuilder<'a> { - inner: PipelineCreationFeedback, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> { - type Target = PipelineCreationFeedback; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCreationFeedbackBuilder<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn duration(mut self, duration: u64) -> Self { - self.inner.duration = duration; + self.duration = duration; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCreationFeedback { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineCreationFeedbackCreateInfo { +pub struct PipelineCreationFeedbackCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback, pub pipeline_stage_creation_feedback_count: u32, pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineCreationFeedbackCreateInfo { +impl ::std::default::Default for PipelineCreationFeedbackCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO, @@ -36502,402 +23669,210 @@ impl ::std::default::Default for PipelineCreationFeedbackCreateInfo { p_pipeline_creation_feedback: ::std::ptr::null_mut(), pipeline_stage_creation_feedback_count: u32::default(), p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl PipelineCreationFeedbackCreateInfo { - pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> { - PipelineCreationFeedbackCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> { - inner: PipelineCreationFeedbackCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {} -unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {} -unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {} -unsafe impl ExtendsRayTracingPipelineCreateInfoNV - for PipelineCreationFeedbackCreateInfoBuilder<'_> -{ -} -unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {} -unsafe impl ExtendsRayTracingPipelineCreateInfoKHR - for PipelineCreationFeedbackCreateInfoBuilder<'_> -{ -} -unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> { - type Target = PipelineCreationFeedbackCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> { +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo<'_> {} +impl<'a> PipelineCreationFeedbackCreateInfo<'a> { + #[inline] pub fn pipeline_creation_feedback( mut self, pipeline_creation_feedback: &'a mut PipelineCreationFeedback, ) -> Self { - self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback; + self.p_pipeline_creation_feedback = pipeline_creation_feedback; self } + #[inline] pub fn pipeline_stage_creation_feedbacks( mut self, pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback], ) -> Self { - self.inner.pipeline_stage_creation_feedback_count = - pipeline_stage_creation_feedbacks.len() as _; - self.inner.p_pipeline_stage_creation_feedbacks = - pipeline_stage_creation_feedbacks.as_mut_ptr(); + self.pipeline_stage_creation_feedback_count = pipeline_stage_creation_feedbacks.len() as _; + self.p_pipeline_stage_creation_feedbacks = pipeline_stage_creation_feedbacks.as_mut_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCreationFeedbackCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceFullScreenExclusiveInfoEXT { +pub struct SurfaceFullScreenExclusiveInfoEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub full_screen_exclusive: FullScreenExclusiveEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT { +impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, p_next: ::std::ptr::null_mut(), full_screen_exclusive: FullScreenExclusiveEXT::default(), + _marker: PhantomData, } } } -impl SurfaceFullScreenExclusiveInfoEXT { - pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { - SurfaceFullScreenExclusiveInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { - inner: SurfaceFullScreenExclusiveInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {} -impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { - type Target = SurfaceFullScreenExclusiveInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT<'_> {} +impl<'a> SurfaceFullScreenExclusiveInfoEXT<'a> { + #[inline] pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self { - self.inner.full_screen_exclusive = full_screen_exclusive; + self.full_screen_exclusive = full_screen_exclusive; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceFullScreenExclusiveWin32InfoEXT { +pub struct SurfaceFullScreenExclusiveWin32InfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub hmonitor: HMONITOR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT { +impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, p_next: ::std::ptr::null(), hmonitor: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl SurfaceFullScreenExclusiveWin32InfoEXT { - pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { - SurfaceFullScreenExclusiveWin32InfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { - inner: SurfaceFullScreenExclusiveWin32InfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR - for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {} -impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { - type Target = SurfaceFullScreenExclusiveWin32InfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT<'_> {} +impl<'a> SurfaceFullScreenExclusiveWin32InfoEXT<'a> { + #[inline] pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self { - self.inner.hmonitor = hmonitor; + self.hmonitor = hmonitor; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SurfaceCapabilitiesFullScreenExclusiveEXT { +pub struct SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub full_screen_exclusive_supported: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT { +impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, p_next: ::std::ptr::null_mut(), full_screen_exclusive_supported: Bool32::default(), + _marker: PhantomData, } } } -impl SurfaceCapabilitiesFullScreenExclusiveEXT { - pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { - SurfaceCapabilitiesFullScreenExclusiveEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { - inner: SurfaceCapabilitiesFullScreenExclusiveEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSurfaceCapabilities2KHR - for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_> -{ -} -unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {} -impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { - type Target = SurfaceCapabilitiesFullScreenExclusiveEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT<'_> {} +impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { + #[inline] pub fn full_screen_exclusive_supported( mut self, full_screen_exclusive_supported: bool, ) -> Self { - self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into(); + self.full_screen_exclusive_supported = full_screen_exclusive_supported.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePerformanceQueryFeaturesKHR { +pub struct PhysicalDevicePerformanceQueryFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub performance_counter_query_pools: Bool32, pub performance_counter_multiple_query_pools: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR { +impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, p_next: ::std::ptr::null_mut(), performance_counter_query_pools: Bool32::default(), performance_counter_multiple_query_pools: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePerformanceQueryFeaturesKHR { - pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { - PhysicalDevicePerformanceQueryFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { - inner: PhysicalDevicePerformanceQueryFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { - type Target = PhysicalDevicePerformanceQueryFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR<'_> {} +impl<'a> PhysicalDevicePerformanceQueryFeaturesKHR<'a> { + #[inline] pub fn performance_counter_query_pools( mut self, performance_counter_query_pools: bool, ) -> Self { - self.inner.performance_counter_query_pools = performance_counter_query_pools.into(); + self.performance_counter_query_pools = performance_counter_query_pools.into(); self } + #[inline] pub fn performance_counter_multiple_query_pools( mut self, performance_counter_multiple_query_pools: bool, ) -> Self { - self.inner.performance_counter_multiple_query_pools = + self.performance_counter_multiple_query_pools = performance_counter_multiple_query_pools.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePerformanceQueryPropertiesKHR { +pub struct PhysicalDevicePerformanceQueryPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub allow_command_buffer_query_copies: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR { +impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), allow_command_buffer_query_copies: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePerformanceQueryPropertiesKHR { - pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { - PhysicalDevicePerformanceQueryPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { - inner: PhysicalDevicePerformanceQueryPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { - type Target = PhysicalDevicePerformanceQueryPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR<'_> {} +impl<'a> PhysicalDevicePerformanceQueryPropertiesKHR<'a> { + #[inline] pub fn allow_command_buffer_query_copies( mut self, allow_command_buffer_query_copies: bool, ) -> Self { - self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into(); + self.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceCounterKHR { +pub struct PerformanceCounterKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub unit: PerformanceCounterUnitKHR, pub scope: PerformanceCounterScopeKHR, pub storage: PerformanceCounterStorageKHR, pub uuid: [u8; UUID_SIZE], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PerformanceCounterKHR { +impl ::std::default::Default for PerformanceCounterKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_COUNTER_KHR, @@ -36906,70 +23881,46 @@ impl ::std::default::Default for PerformanceCounterKHR { scope: PerformanceCounterScopeKHR::default(), storage: PerformanceCounterStorageKHR::default(), uuid: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PerformanceCounterKHR { - pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> { - PerformanceCounterKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceCounterKHRBuilder<'a> { - inner: PerformanceCounterKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> { - type Target = PerformanceCounterKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceCounterKHRBuilder<'a> { +impl<'a> PerformanceCounterKHR<'a> { + #[inline] pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self { - self.inner.unit = unit; + self.unit = unit; self } + #[inline] pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self { - self.inner.scope = scope; + self.scope = scope; self } + #[inline] pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self { - self.inner.storage = storage; + self.storage = storage; self } + #[inline] pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self { - self.inner.uuid = uuid; + self.uuid = uuid; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceCounterKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceCounterDescriptionKHR { +pub struct PerformanceCounterDescriptionKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: PerformanceCounterDescriptionFlagsKHR, pub name: [c_char; MAX_DESCRIPTION_SIZE], pub category: [c_char; MAX_DESCRIPTION_SIZE], pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PerformanceCounterDescriptionKHR { +impl fmt::Debug for PerformanceCounterDescriptionKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PerformanceCounterDescriptionKHR") .field("s_type", &self.s_type) @@ -36987,7 +23938,7 @@ impl fmt::Debug for PerformanceCounterDescriptionKHR { .finish() } } -impl ::std::default::Default for PerformanceCounterDescriptionKHR { +impl ::std::default::Default for PerformanceCounterDescriptionKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR, @@ -36996,69 +23947,45 @@ impl ::std::default::Default for PerformanceCounterDescriptionKHR { name: unsafe { ::std::mem::zeroed() }, category: unsafe { ::std::mem::zeroed() }, description: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PerformanceCounterDescriptionKHR { - pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> { - PerformanceCounterDescriptionKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceCounterDescriptionKHRBuilder<'a> { - inner: PerformanceCounterDescriptionKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> { - type Target = PerformanceCounterDescriptionKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> { +impl<'a> PerformanceCounterDescriptionKHR<'a> { + #[inline] pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.name = name; + self.name = name; self } + #[inline] pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.category = category; + self.category = category; self } + #[inline] pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.description = description; + self.description = description; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceCounterDescriptionKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueryPoolPerformanceCreateInfoKHR { +pub struct QueryPoolPerformanceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub queue_family_index: u32, pub counter_index_count: u32, pub p_counter_indices: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR { +impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, @@ -37066,51 +23993,23 @@ impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR { queue_family_index: u32::default(), counter_index_count: u32::default(), p_counter_indices: ::std::ptr::null(), + _marker: PhantomData, } } } -impl QueryPoolPerformanceCreateInfoKHR { - pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> { - QueryPoolPerformanceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> { - inner: QueryPoolPerformanceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {} -impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> { - type Target = QueryPoolPerformanceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> { +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR<'_> {} +impl<'a> QueryPoolPerformanceCreateInfoKHR<'a> { + #[inline] pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { - self.inner.queue_family_index = queue_family_index; + self.queue_family_index = queue_family_index; self } + #[inline] pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self { - self.inner.counter_index_count = counter_indices.len() as _; - self.inner.p_counter_indices = counter_indices.as_ptr(); + self.counter_index_count = counter_indices.len() as _; + self.p_counter_indices = counter_indices.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -37132,319 +24031,176 @@ impl ::std::default::Default for PerformanceCounterResultKHR { #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AcquireProfilingLockInfoKHR { +pub struct AcquireProfilingLockInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: AcquireProfilingLockFlagsKHR, pub timeout: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AcquireProfilingLockInfoKHR { +impl ::std::default::Default for AcquireProfilingLockInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR, p_next: ::std::ptr::null(), flags: AcquireProfilingLockFlagsKHR::default(), timeout: u64::default(), + _marker: PhantomData, } } } -impl AcquireProfilingLockInfoKHR { - pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> { - AcquireProfilingLockInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AcquireProfilingLockInfoKHRBuilder<'a> { - inner: AcquireProfilingLockInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> { - type Target = AcquireProfilingLockInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> { +impl<'a> AcquireProfilingLockInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn timeout(mut self, timeout: u64) -> Self { - self.inner.timeout = timeout; + self.timeout = timeout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AcquireProfilingLockInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceQuerySubmitInfoKHR { +pub struct PerformanceQuerySubmitInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub counter_pass_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PerformanceQuerySubmitInfoKHR { +impl ::std::default::Default for PerformanceQuerySubmitInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR, p_next: ::std::ptr::null(), counter_pass_index: u32::default(), + _marker: PhantomData, } } } -impl PerformanceQuerySubmitInfoKHR { - pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> { - PerformanceQuerySubmitInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> { - inner: PerformanceQuerySubmitInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {} -unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {} -unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {} -unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {} -impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> { - type Target = PerformanceQuerySubmitInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> { +unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR<'_> {} +unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR<'_> {} +impl<'a> PerformanceQuerySubmitInfoKHR<'a> { + #[inline] pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self { - self.inner.counter_pass_index = counter_pass_index; + self.counter_pass_index = counter_pass_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceQuerySubmitInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct HeadlessSurfaceCreateInfoEXT { +pub struct HeadlessSurfaceCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: HeadlessSurfaceCreateFlagsEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT { +impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), flags: HeadlessSurfaceCreateFlagsEXT::default(), + _marker: PhantomData, } } } -impl HeadlessSurfaceCreateInfoEXT { - pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> { - HeadlessSurfaceCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> { - inner: HeadlessSurfaceCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> { - type Target = HeadlessSurfaceCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> { +impl<'a> HeadlessSurfaceCreateInfoEXT<'a> { + #[inline] pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> HeadlessSurfaceCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCoverageReductionModeFeaturesNV { +pub struct PhysicalDeviceCoverageReductionModeFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub coverage_reduction_mode: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV { +impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, p_next: ::std::ptr::null_mut(), coverage_reduction_mode: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCoverageReductionModeFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { - PhysicalDeviceCoverageReductionModeFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { - inner: PhysicalDeviceCoverageReductionModeFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceCoverageReductionModeFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV<'_> {} +impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNV<'a> { + #[inline] pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self { - self.inner.coverage_reduction_mode = coverage_reduction_mode.into(); + self.coverage_reduction_mode = coverage_reduction_mode.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineCoverageReductionStateCreateInfoNV { +pub struct PipelineCoverageReductionStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: PipelineCoverageReductionStateCreateFlagsNV, pub coverage_reduction_mode: CoverageReductionModeNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV { +impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, p_next: ::std::ptr::null(), flags: PipelineCoverageReductionStateCreateFlagsNV::default(), coverage_reduction_mode: CoverageReductionModeNV::default(), + _marker: PhantomData, } } } -impl PipelineCoverageReductionStateCreateInfoNV { - pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { - PipelineCoverageReductionStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { - inner: PipelineCoverageReductionStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineCoverageReductionStateCreateInfoNVBuilder<'_> + for PipelineCoverageReductionStateCreateInfoNV<'_> { } -unsafe impl ExtendsPipelineMultisampleStateCreateInfo - for PipelineCoverageReductionStateCreateInfoNV -{ -} -impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { - type Target = PipelineCoverageReductionStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineCoverageReductionStateCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn coverage_reduction_mode( mut self, coverage_reduction_mode: CoverageReductionModeNV, ) -> Self { - self.inner.coverage_reduction_mode = coverage_reduction_mode; + self.coverage_reduction_mode = coverage_reduction_mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FramebufferMixedSamplesCombinationNV { +pub struct FramebufferMixedSamplesCombinationNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub coverage_reduction_mode: CoverageReductionModeNV, pub rasterization_samples: SampleCountFlags, pub depth_stencil_samples: SampleCountFlags, pub color_samples: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FramebufferMixedSamplesCombinationNV { +impl ::std::default::Default for FramebufferMixedSamplesCombinationNV<'_> { fn default() -> Self { Self { s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV, @@ -37453,123 +24209,66 @@ impl ::std::default::Default for FramebufferMixedSamplesCombinationNV { rasterization_samples: SampleCountFlags::default(), depth_stencil_samples: SampleCountFlags::default(), color_samples: SampleCountFlags::default(), + _marker: PhantomData, } } } -impl FramebufferMixedSamplesCombinationNV { - pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> { - FramebufferMixedSamplesCombinationNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> { - inner: FramebufferMixedSamplesCombinationNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> { - type Target = FramebufferMixedSamplesCombinationNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> { +impl<'a> FramebufferMixedSamplesCombinationNV<'a> { + #[inline] pub fn coverage_reduction_mode( mut self, coverage_reduction_mode: CoverageReductionModeNV, ) -> Self { - self.inner.coverage_reduction_mode = coverage_reduction_mode; + self.coverage_reduction_mode = coverage_reduction_mode; self } + #[inline] pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { - self.inner.rasterization_samples = rasterization_samples; + self.rasterization_samples = rasterization_samples; self } + #[inline] pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self { - self.inner.depth_stencil_samples = depth_stencil_samples; + self.depth_stencil_samples = depth_stencil_samples; self } + #[inline] pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self { - self.inner.color_samples = color_samples; + self.color_samples = color_samples; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FramebufferMixedSamplesCombinationNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { +pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_integer_functions2: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { +impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, p_next: ::std::ptr::null_mut(), shader_integer_functions2: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { - pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { - PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { - inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> + for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { - type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'_> {} +impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> { + #[inline] pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self { - self.inner.shader_integer_functions2 = shader_integer_functions2.into(); + self.shader_integer_functions2 = shader_integer_functions2.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -37603,278 +24302,142 @@ impl fmt::Debug for PerformanceValueINTEL { } } impl PerformanceValueINTEL { - pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> { - PerformanceValueINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceValueINTELBuilder<'a> { - inner: PerformanceValueINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> { - type Target = PerformanceValueINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceValueINTELBuilder<'a> { + #[inline] pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self { - self.inner.data = data; + self.data = data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceValueINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct InitializePerformanceApiInfoINTEL { +pub struct InitializePerformanceApiInfoINTEL<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_user_data: *mut c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for InitializePerformanceApiInfoINTEL { +impl ::std::default::Default for InitializePerformanceApiInfoINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL, p_next: ::std::ptr::null(), p_user_data: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl InitializePerformanceApiInfoINTEL { - pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> { - InitializePerformanceApiInfoINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct InitializePerformanceApiInfoINTELBuilder<'a> { - inner: InitializePerformanceApiInfoINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> { - type Target = InitializePerformanceApiInfoINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> { +impl<'a> InitializePerformanceApiInfoINTEL<'a> { + #[inline] pub fn user_data(mut self, user_data: *mut c_void) -> Self { - self.inner.p_user_data = user_data; + self.p_user_data = user_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> InitializePerformanceApiInfoINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueryPoolPerformanceQueryCreateInfoINTEL { +pub struct QueryPoolPerformanceQueryCreateInfoINTEL<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub performance_counters_sampling: QueryPoolSamplingModeINTEL, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL { +impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, p_next: ::std::ptr::null(), performance_counters_sampling: QueryPoolSamplingModeINTEL::default(), + _marker: PhantomData, } } } -impl QueryPoolPerformanceQueryCreateInfoINTEL { - pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { - QueryPoolPerformanceQueryCreateInfoINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { - inner: QueryPoolPerformanceQueryCreateInfoINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {} -impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { - type Target = QueryPoolPerformanceQueryCreateInfoINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL<'_> {} +impl<'a> QueryPoolPerformanceQueryCreateInfoINTEL<'a> { + #[inline] pub fn performance_counters_sampling( mut self, performance_counters_sampling: QueryPoolSamplingModeINTEL, ) -> Self { - self.inner.performance_counters_sampling = performance_counters_sampling; + self.performance_counters_sampling = performance_counters_sampling; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceMarkerInfoINTEL { +pub struct PerformanceMarkerInfoINTEL<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub marker: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PerformanceMarkerInfoINTEL { +impl ::std::default::Default for PerformanceMarkerInfoINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL, p_next: ::std::ptr::null(), marker: u64::default(), + _marker: PhantomData, } } } -impl PerformanceMarkerInfoINTEL { - pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> { - PerformanceMarkerInfoINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceMarkerInfoINTELBuilder<'a> { - inner: PerformanceMarkerInfoINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> { - type Target = PerformanceMarkerInfoINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceMarkerInfoINTELBuilder<'a> { +impl<'a> PerformanceMarkerInfoINTEL<'a> { + #[inline] pub fn marker(mut self, marker: u64) -> Self { - self.inner.marker = marker; + self.marker = marker; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceMarkerInfoINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceStreamMarkerInfoINTEL { +pub struct PerformanceStreamMarkerInfoINTEL<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub marker: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL { +impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL, p_next: ::std::ptr::null(), marker: u32::default(), + _marker: PhantomData, } } } -impl PerformanceStreamMarkerInfoINTEL { - pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> { - PerformanceStreamMarkerInfoINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> { - inner: PerformanceStreamMarkerInfoINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> { - type Target = PerformanceStreamMarkerInfoINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> { +impl<'a> PerformanceStreamMarkerInfoINTEL<'a> { + #[inline] pub fn marker(mut self, marker: u32) -> Self { - self.inner.marker = marker; + self.marker = marker; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceStreamMarkerInfoINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceOverrideInfoINTEL { +pub struct PerformanceOverrideInfoINTEL<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: PerformanceOverrideTypeINTEL, pub enable: Bool32, pub parameter: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PerformanceOverrideInfoINTEL { +impl ::std::default::Default for PerformanceOverrideInfoINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL, @@ -37882,364 +24445,196 @@ impl ::std::default::Default for PerformanceOverrideInfoINTEL { ty: PerformanceOverrideTypeINTEL::default(), enable: Bool32::default(), parameter: u64::default(), + _marker: PhantomData, } } } -impl PerformanceOverrideInfoINTEL { - pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> { - PerformanceOverrideInfoINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceOverrideInfoINTELBuilder<'a> { - inner: PerformanceOverrideInfoINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> { - type Target = PerformanceOverrideInfoINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceOverrideInfoINTELBuilder<'a> { +impl<'a> PerformanceOverrideInfoINTEL<'a> { + #[inline] pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn enable(mut self, enable: bool) -> Self { - self.inner.enable = enable.into(); + self.enable = enable.into(); self } + #[inline] pub fn parameter(mut self, parameter: u64) -> Self { - self.inner.parameter = parameter; + self.parameter = parameter; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceOverrideInfoINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PerformanceConfigurationAcquireInfoINTEL { +pub struct PerformanceConfigurationAcquireInfoINTEL<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: PerformanceConfigurationTypeINTEL, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL { +impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL<'_> { fn default() -> Self { Self { s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL, p_next: ::std::ptr::null(), ty: PerformanceConfigurationTypeINTEL::default(), + _marker: PhantomData, } } } -impl PerformanceConfigurationAcquireInfoINTEL { - pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { - PerformanceConfigurationAcquireInfoINTELBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> { - inner: PerformanceConfigurationAcquireInfoINTEL, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { - type Target = PerformanceConfigurationAcquireInfoINTEL; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { +impl<'a> PerformanceConfigurationAcquireInfoINTEL<'a> { + #[inline] pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self { - self.inner.ty = ty; + self.ty = ty; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderClockFeaturesKHR { +pub struct PhysicalDeviceShaderClockFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_subgroup_clock: Bool32, pub shader_device_clock: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, p_next: ::std::ptr::null_mut(), shader_subgroup_clock: Bool32::default(), shader_device_clock: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderClockFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { - PhysicalDeviceShaderClockFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceShaderClockFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceShaderClockFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceShaderClockFeaturesKHR<'a> { + #[inline] pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self { - self.inner.shader_subgroup_clock = shader_subgroup_clock.into(); + self.shader_subgroup_clock = shader_subgroup_clock.into(); self } + #[inline] pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self { - self.inner.shader_device_clock = shader_device_clock.into(); + self.shader_device_clock = shader_device_clock.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT { +pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub index_type_uint8: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT { +impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, p_next: ::std::ptr::null_mut(), index_type_uint8: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceIndexTypeUint8FeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { - PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { - inner: PhysicalDeviceIndexTypeUint8FeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXT<'a> { + #[inline] pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self { - self.inner.index_type_uint8 = index_type_uint8.into(); + self.index_type_uint8 = index_type_uint8.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { +pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_sm_count: u32, pub shader_warps_per_sm: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV { +impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV, p_next: ::std::ptr::null_mut(), shader_sm_count: u32::default(), shader_warps_per_sm: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderSMBuiltinsPropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { - PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { - inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { - type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'_> {} +impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> { + #[inline] pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self { - self.inner.shader_sm_count = shader_sm_count; + self.shader_sm_count = shader_sm_count; self } + #[inline] pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self { - self.inner.shader_warps_per_sm = shader_warps_per_sm; + self.shader_warps_per_sm = shader_warps_per_sm; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { +pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_sm_builtins: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV { +impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, p_next: ::std::ptr::null_mut(), shader_sm_builtins: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderSMBuiltinsFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { - PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { - inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'_> {} +impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { + #[inline] pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self { - self.inner.shader_sm_builtins = shader_sm_builtins.into(); + self.shader_sm_builtins = shader_sm_builtins.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { +pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_shader_sample_interlock: Bool32, pub fragment_shader_pixel_interlock: Bool32, pub fragment_shader_shading_rate_interlock: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, @@ -38247,469 +24642,254 @@ impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEX fragment_shader_sample_interlock: Bool32::default(), fragment_shader_pixel_interlock: Bool32::default(), fragment_shader_shading_rate_interlock: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { - PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> + for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> { + #[inline] pub fn fragment_shader_sample_interlock( mut self, fragment_shader_sample_interlock: bool, ) -> Self { - self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into(); + self.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into(); self } + #[inline] pub fn fragment_shader_pixel_interlock( mut self, fragment_shader_pixel_interlock: bool, ) -> Self { - self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into(); + self.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into(); self } + #[inline] pub fn fragment_shader_shading_rate_interlock( mut self, fragment_shader_shading_rate_interlock: bool, ) -> Self { - self.inner.fragment_shader_shading_rate_interlock = - fragment_shader_shading_rate_interlock.into(); + self.fragment_shader_shading_rate_interlock = fragment_shader_shading_rate_interlock.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures { +pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub separate_depth_stencil_layouts: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures { +impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, p_next: ::std::ptr::null_mut(), separate_depth_stencil_layouts: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures { - pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { - PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { - inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> + for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { - type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'_> {} +impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> { + #[inline] pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self { - self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AttachmentReferenceStencilLayout { +pub struct AttachmentReferenceStencilLayout<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub stencil_layout: ImageLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AttachmentReferenceStencilLayout { +impl ::std::default::Default for AttachmentReferenceStencilLayout<'_> { fn default() -> Self { Self { s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT, p_next: ::std::ptr::null_mut(), stencil_layout: ImageLayout::default(), + _marker: PhantomData, } } } -impl AttachmentReferenceStencilLayout { - pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> { - AttachmentReferenceStencilLayoutBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentReferenceStencilLayoutBuilder<'a> { - inner: AttachmentReferenceStencilLayout, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {} -unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {} -impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> { - type Target = AttachmentReferenceStencilLayout; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> { +unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout<'_> {} +impl<'a> AttachmentReferenceStencilLayout<'a> { + #[inline] pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self { - self.inner.stencil_layout = stencil_layout; + self.stencil_layout = stencil_layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentReferenceStencilLayout { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { +pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub primitive_topology_list_restart: Bool32, pub primitive_topology_patch_list_restart: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { +impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, p_next: ::std::ptr::null_mut(), primitive_topology_list_restart: Bool32::default(), primitive_topology_patch_list_restart: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { - pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { - PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { - inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_> + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT -{ -} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { - type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'_> {} +impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> { + #[inline] pub fn primitive_topology_list_restart( mut self, primitive_topology_list_restart: bool, ) -> Self { - self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into(); + self.primitive_topology_list_restart = primitive_topology_list_restart.into(); self } + #[inline] pub fn primitive_topology_patch_list_restart( mut self, primitive_topology_patch_list_restart: bool, ) -> Self { - self.inner.primitive_topology_patch_list_restart = - primitive_topology_patch_list_restart.into(); + self.primitive_topology_patch_list_restart = primitive_topology_patch_list_restart.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AttachmentDescriptionStencilLayout { +pub struct AttachmentDescriptionStencilLayout<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub stencil_initial_layout: ImageLayout, pub stencil_final_layout: ImageLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AttachmentDescriptionStencilLayout { +impl ::std::default::Default for AttachmentDescriptionStencilLayout<'_> { fn default() -> Self { Self { s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, p_next: ::std::ptr::null_mut(), stencil_initial_layout: ImageLayout::default(), stencil_final_layout: ImageLayout::default(), + _marker: PhantomData, } } } -impl AttachmentDescriptionStencilLayout { - pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> { - AttachmentDescriptionStencilLayoutBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentDescriptionStencilLayoutBuilder<'a> { - inner: AttachmentDescriptionStencilLayout, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {} -unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {} -impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> { - type Target = AttachmentDescriptionStencilLayout; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> { +unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout<'_> {} +impl<'a> AttachmentDescriptionStencilLayout<'a> { + #[inline] pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self { - self.inner.stencil_initial_layout = stencil_initial_layout; + self.stencil_initial_layout = stencil_initial_layout; self } + #[inline] pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self { - self.inner.stencil_final_layout = stencil_final_layout; + self.stencil_final_layout = stencil_final_layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentDescriptionStencilLayout { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { +pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub pipeline_executable_info: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { +impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, p_next: ::std::ptr::null_mut(), pipeline_executable_info: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { - pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { - PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { - inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR -{ -} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { - type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'_> {} +impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> { + #[inline] pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self { - self.inner.pipeline_executable_info = pipeline_executable_info.into(); + self.pipeline_executable_info = pipeline_executable_info.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineInfoKHR { +pub struct PipelineInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub pipeline: Pipeline, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineInfoKHR { +impl ::std::default::Default for PipelineInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_INFO_KHR, p_next: ::std::ptr::null(), pipeline: Pipeline::default(), + _marker: PhantomData, } } } -impl PipelineInfoKHR { - pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> { - PipelineInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineInfoKHRBuilder<'a> { - inner: PipelineInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> { - type Target = PipelineInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineInfoKHRBuilder<'a> { +impl<'a> PipelineInfoKHR<'a> { + #[inline] pub fn pipeline(mut self, pipeline: Pipeline) -> Self { - self.inner.pipeline = pipeline; + self.pipeline = pipeline; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineInfoKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineExecutablePropertiesKHR { +pub struct PipelineExecutablePropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub stages: ShaderStageFlags, pub name: [c_char; MAX_DESCRIPTION_SIZE], pub description: [c_char; MAX_DESCRIPTION_SIZE], pub subgroup_size: u32, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PipelineExecutablePropertiesKHR { +impl fmt::Debug for PipelineExecutablePropertiesKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PipelineExecutablePropertiesKHR") .field("s_type", &self.s_type) @@ -38725,7 +24905,7 @@ impl fmt::Debug for PipelineExecutablePropertiesKHR { .finish() } } -impl ::std::default::Default for PipelineExecutablePropertiesKHR { +impl ::std::default::Default for PipelineExecutablePropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR, @@ -38734,116 +24914,65 @@ impl ::std::default::Default for PipelineExecutablePropertiesKHR { name: unsafe { ::std::mem::zeroed() }, description: unsafe { ::std::mem::zeroed() }, subgroup_size: u32::default(), + _marker: PhantomData, } } } -impl PipelineExecutablePropertiesKHR { - pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> { - PipelineExecutablePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineExecutablePropertiesKHRBuilder<'a> { - inner: PipelineExecutablePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> { - type Target = PipelineExecutablePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> { +impl<'a> PipelineExecutablePropertiesKHR<'a> { + #[inline] pub fn stages(mut self, stages: ShaderStageFlags) -> Self { - self.inner.stages = stages; + self.stages = stages; self } + #[inline] pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.name = name; + self.name = name; self } + #[inline] pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.description = description; + self.description = description; self } + #[inline] pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { - self.inner.subgroup_size = subgroup_size; + self.subgroup_size = subgroup_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineExecutablePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineExecutableInfoKHR { +pub struct PipelineExecutableInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub pipeline: Pipeline, pub executable_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineExecutableInfoKHR { +impl ::std::default::Default for PipelineExecutableInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR, p_next: ::std::ptr::null(), pipeline: Pipeline::default(), executable_index: u32::default(), + _marker: PhantomData, } } } -impl PipelineExecutableInfoKHR { - pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> { - PipelineExecutableInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineExecutableInfoKHRBuilder<'a> { - inner: PipelineExecutableInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> { - type Target = PipelineExecutableInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineExecutableInfoKHRBuilder<'a> { +impl<'a> PipelineExecutableInfoKHR<'a> { + #[inline] pub fn pipeline(mut self, pipeline: Pipeline) -> Self { - self.inner.pipeline = pipeline; + self.pipeline = pipeline; self } + #[inline] pub fn executable_index(mut self, executable_index: u32) -> Self { - self.inner.executable_index = executable_index; + self.executable_index = executable_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineExecutableInfoKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -38862,16 +24991,17 @@ impl ::std::default::Default for PipelineExecutableStatisticValueKHR { #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineExecutableStatisticKHR { +pub struct PipelineExecutableStatisticKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub name: [c_char; MAX_DESCRIPTION_SIZE], pub description: [c_char; MAX_DESCRIPTION_SIZE], pub format: PipelineExecutableStatisticFormatKHR, pub value: PipelineExecutableStatisticValueKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PipelineExecutableStatisticKHR { +impl fmt::Debug for PipelineExecutableStatisticKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PipelineExecutableStatisticKHR") .field("s_type", &self.s_type) @@ -38887,7 +25017,7 @@ impl fmt::Debug for PipelineExecutableStatisticKHR { .finish() } } -impl ::std::default::Default for PipelineExecutableStatisticKHR { +impl ::std::default::Default for PipelineExecutableStatisticKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR, @@ -38896,61 +25026,36 @@ impl ::std::default::Default for PipelineExecutableStatisticKHR { description: unsafe { ::std::mem::zeroed() }, format: PipelineExecutableStatisticFormatKHR::default(), value: PipelineExecutableStatisticValueKHR::default(), + _marker: PhantomData, } } } -impl PipelineExecutableStatisticKHR { - pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> { - PipelineExecutableStatisticKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineExecutableStatisticKHRBuilder<'a> { - inner: PipelineExecutableStatisticKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> { - type Target = PipelineExecutableStatisticKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineExecutableStatisticKHRBuilder<'a> { +impl<'a> PipelineExecutableStatisticKHR<'a> { + #[inline] pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.name = name; + self.name = name; self } + #[inline] pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.description = description; + self.description = description; self } + #[inline] pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self { - self.inner.value = value; + self.value = value; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineExecutableStatisticKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineExecutableInternalRepresentationKHR { +pub struct PipelineExecutableInternalRepresentationKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub name: [c_char; MAX_DESCRIPTION_SIZE], @@ -38958,9 +25063,10 @@ pub struct PipelineExecutableInternalRepresentationKHR { pub is_text: Bool32, pub data_size: usize, pub p_data: *mut c_void, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PipelineExecutableInternalRepresentationKHR { +impl fmt::Debug for PipelineExecutableInternalRepresentationKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PipelineExecutableInternalRepresentationKHR") .field("s_type", &self.s_type) @@ -38977,7 +25083,7 @@ impl fmt::Debug for PipelineExecutableInternalRepresentationKHR { .finish() } } -impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR { +impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, @@ -38987,202 +25093,111 @@ impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR { is_text: Bool32::default(), data_size: usize::default(), p_data: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl PipelineExecutableInternalRepresentationKHR { - pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> { - PipelineExecutableInternalRepresentationKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> { - inner: PipelineExecutableInternalRepresentationKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> { - type Target = PipelineExecutableInternalRepresentationKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> { +impl<'a> PipelineExecutableInternalRepresentationKHR<'a> { + #[inline] pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.name = name; + self.name = name; self } + #[inline] pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.description = description; + self.description = description; self } + #[inline] pub fn is_text(mut self, is_text: bool) -> Self { - self.inner.is_text = is_text.into(); + self.is_text = is_text.into(); self } + #[inline] pub fn data(mut self, data: &'a mut [u8]) -> Self { - self.inner.data_size = data.len(); - self.inner.p_data = data.as_mut_ptr() as *mut c_void; + self.data_size = data.len(); + self.p_data = data.as_mut_ptr() as *mut c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineExecutableInternalRepresentationKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures { +pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_demote_to_helper_invocation: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures { +impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, p_next: ::std::ptr::null_mut(), shader_demote_to_helper_invocation: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures { - pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { - PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { - inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_> + for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderDemoteToHelperInvocationFeatures -{ -} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'_> {} +impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> { + #[inline] pub fn shader_demote_to_helper_invocation( mut self, shader_demote_to_helper_invocation: bool, ) -> Self { - self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); + self.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { +pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub texel_buffer_alignment: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, p_next: ::std::ptr::null_mut(), texel_buffer_alignment: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { - PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> { + #[inline] pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self { - self.inner.texel_buffer_alignment = texel_buffer_alignment.into(); + self.texel_buffer_alignment = texel_buffer_alignment.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceTexelBufferAlignmentProperties { +pub struct PhysicalDeviceTexelBufferAlignmentProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub storage_texel_buffer_offset_alignment_bytes: DeviceSize, pub storage_texel_buffer_offset_single_texel_alignment: Bool32, pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize, pub uniform_texel_buffer_offset_single_texel_alignment: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties { +impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, @@ -39191,160 +25206,99 @@ impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties { storage_texel_buffer_offset_single_texel_alignment: Bool32::default(), uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(), uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceTexelBufferAlignmentProperties { - pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { - PhysicalDeviceTexelBufferAlignmentPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { - inner: PhysicalDeviceTexelBufferAlignmentProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { - type Target = PhysicalDeviceTexelBufferAlignmentProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties<'_> {} +impl<'a> PhysicalDeviceTexelBufferAlignmentProperties<'a> { + #[inline] pub fn storage_texel_buffer_offset_alignment_bytes( mut self, storage_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self { - self.inner.storage_texel_buffer_offset_alignment_bytes = + self.storage_texel_buffer_offset_alignment_bytes = storage_texel_buffer_offset_alignment_bytes; self } + #[inline] pub fn storage_texel_buffer_offset_single_texel_alignment( mut self, storage_texel_buffer_offset_single_texel_alignment: bool, ) -> Self { - self.inner - .storage_texel_buffer_offset_single_texel_alignment = + self.storage_texel_buffer_offset_single_texel_alignment = storage_texel_buffer_offset_single_texel_alignment.into(); self } + #[inline] pub fn uniform_texel_buffer_offset_alignment_bytes( mut self, uniform_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self { - self.inner.uniform_texel_buffer_offset_alignment_bytes = + self.uniform_texel_buffer_offset_alignment_bytes = uniform_texel_buffer_offset_alignment_bytes; self } + #[inline] pub fn uniform_texel_buffer_offset_single_texel_alignment( mut self, uniform_texel_buffer_offset_single_texel_alignment: bool, ) -> Self { - self.inner - .uniform_texel_buffer_offset_single_texel_alignment = + self.uniform_texel_buffer_offset_single_texel_alignment = uniform_texel_buffer_offset_single_texel_alignment.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSubgroupSizeControlFeatures { +pub struct PhysicalDeviceSubgroupSizeControlFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub subgroup_size_control: Bool32, pub compute_full_subgroups: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures { +impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, p_next: ::std::ptr::null_mut(), subgroup_size_control: Bool32::default(), compute_full_subgroups: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSubgroupSizeControlFeatures { - pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { - PhysicalDeviceSubgroupSizeControlFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { - inner: PhysicalDeviceSubgroupSizeControlFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { - type Target = PhysicalDeviceSubgroupSizeControlFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures<'_> {} +impl<'a> PhysicalDeviceSubgroupSizeControlFeatures<'a> { + #[inline] pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { - self.inner.subgroup_size_control = subgroup_size_control.into(); + self.subgroup_size_control = subgroup_size_control.into(); self } + #[inline] pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { - self.inner.compute_full_subgroups = compute_full_subgroups.into(); + self.compute_full_subgroups = compute_full_subgroups.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSubgroupSizeControlProperties { +pub struct PhysicalDeviceSubgroupSizeControlProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_subgroup_size: u32, pub max_subgroup_size: u32, pub max_compute_workgroup_subgroups: u32, pub required_subgroup_size_stages: ShaderStageFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties { +impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, @@ -39353,367 +25307,194 @@ impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties { max_subgroup_size: u32::default(), max_compute_workgroup_subgroups: u32::default(), required_subgroup_size_stages: ShaderStageFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSubgroupSizeControlProperties { - pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { - PhysicalDeviceSubgroupSizeControlPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { - inner: PhysicalDeviceSubgroupSizeControlProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { - type Target = PhysicalDeviceSubgroupSizeControlProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties<'_> {} +impl<'a> PhysicalDeviceSubgroupSizeControlProperties<'a> { + #[inline] pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { - self.inner.min_subgroup_size = min_subgroup_size; + self.min_subgroup_size = min_subgroup_size; self } + #[inline] pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { - self.inner.max_subgroup_size = max_subgroup_size; + self.max_subgroup_size = max_subgroup_size; self } + #[inline] pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self { - self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; self } + #[inline] pub fn required_subgroup_size_stages( mut self, required_subgroup_size_stages: ShaderStageFlags, ) -> Self { - self.inner.required_subgroup_size_stages = required_subgroup_size_stages; + self.required_subgroup_size_stages = required_subgroup_size_stages; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo { +pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub required_subgroup_size: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo { +impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, p_next: ::std::ptr::null_mut(), required_subgroup_size: u32::default(), + _marker: PhantomData, } } } -impl PipelineShaderStageRequiredSubgroupSizeCreateInfo { - pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { - PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { - inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineShaderStageCreateInfo - for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_> + for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'_> { } -unsafe impl ExtendsPipelineShaderStageCreateInfo - for PipelineShaderStageRequiredSubgroupSizeCreateInfo -{ -} -impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { - type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { +impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> { + #[inline] pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self { - self.inner.required_subgroup_size = required_subgroup_size; + self.required_subgroup_size = required_subgroup_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubpassShadingPipelineCreateInfoHUAWEI { +pub struct SubpassShadingPipelineCreateInfoHUAWEI<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub render_pass: RenderPass, pub subpass: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI { +impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI<'_> { fn default() -> Self { Self { s_type: StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, p_next: ::std::ptr::null_mut(), render_pass: RenderPass::default(), subpass: u32::default(), + _marker: PhantomData, } } } -impl SubpassShadingPipelineCreateInfoHUAWEI { - pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { - SubpassShadingPipelineCreateInfoHUAWEIBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { - inner: SubpassShadingPipelineCreateInfoHUAWEI, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'_> {} -unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI {} -impl<'a> ::std::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { - type Target = SubpassShadingPipelineCreateInfoHUAWEI; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { +unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI<'_> {} +impl<'a> SubpassShadingPipelineCreateInfoHUAWEI<'a> { + #[inline] pub fn render_pass(mut self, render_pass: RenderPass) -> Self { - self.inner.render_pass = render_pass; + self.render_pass = render_pass; self } + #[inline] pub fn subpass(mut self, subpass: u32) -> Self { - self.inner.subpass = subpass; + self.subpass = subpass; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubpassShadingPipelineCreateInfoHUAWEI { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI { +pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_subpass_shading_workgroup_size_aspect_ratio: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI { +impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI, p_next: ::std::ptr::null_mut(), max_subpass_shading_workgroup_size_aspect_ratio: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSubpassShadingPropertiesHUAWEI { - pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { - PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { - inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { - type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'_> {} +impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> { + #[inline] pub fn max_subpass_shading_workgroup_size_aspect_ratio( mut self, max_subpass_shading_workgroup_size_aspect_ratio: u32, ) -> Self { - self.inner.max_subpass_shading_workgroup_size_aspect_ratio = + self.max_subpass_shading_workgroup_size_aspect_ratio = max_subpass_shading_workgroup_size_aspect_ratio; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryOpaqueCaptureAddressAllocateInfo { +pub struct MemoryOpaqueCaptureAddressAllocateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub opaque_capture_address: u64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo { +impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, p_next: ::std::ptr::null(), opaque_capture_address: u64::default(), + _marker: PhantomData, } } } -impl MemoryOpaqueCaptureAddressAllocateInfo { - pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { - MemoryOpaqueCaptureAddressAllocateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { - inner: MemoryOpaqueCaptureAddressAllocateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {} -impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { - type Target = MemoryOpaqueCaptureAddressAllocateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo<'_> {} +impl<'a> MemoryOpaqueCaptureAddressAllocateInfo<'a> { + #[inline] pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { - self.inner.opaque_capture_address = opaque_capture_address; + self.opaque_capture_address = opaque_capture_address; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceMemoryOpaqueCaptureAddressInfo { +pub struct DeviceMemoryOpaqueCaptureAddressInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo { +impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, p_next: ::std::ptr::null(), memory: DeviceMemory::default(), + _marker: PhantomData, } } } -impl DeviceMemoryOpaqueCaptureAddressInfo { - pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { - DeviceMemoryOpaqueCaptureAddressInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { - inner: DeviceMemoryOpaqueCaptureAddressInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { - type Target = DeviceMemoryOpaqueCaptureAddressInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { +impl<'a> DeviceMemoryOpaqueCaptureAddressInfo<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceLineRasterizationFeaturesEXT { +pub struct PhysicalDeviceLineRasterizationFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub rectangular_lines: Bool32, @@ -39722,8 +25503,9 @@ pub struct PhysicalDeviceLineRasterizationFeaturesEXT { pub stippled_rectangular_lines: Bool32, pub stippled_bresenham_lines: Bool32, pub stippled_smooth_lines: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, @@ -39734,144 +25516,86 @@ impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT { stippled_rectangular_lines: Bool32::default(), stippled_bresenham_lines: Bool32::default(), stippled_smooth_lines: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceLineRasterizationFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { - PhysicalDeviceLineRasterizationFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceLineRasterizationFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceLineRasterizationFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceLineRasterizationFeaturesEXT<'a> { + #[inline] pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self { - self.inner.rectangular_lines = rectangular_lines.into(); + self.rectangular_lines = rectangular_lines.into(); self } + #[inline] pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self { - self.inner.bresenham_lines = bresenham_lines.into(); + self.bresenham_lines = bresenham_lines.into(); self } + #[inline] pub fn smooth_lines(mut self, smooth_lines: bool) -> Self { - self.inner.smooth_lines = smooth_lines.into(); + self.smooth_lines = smooth_lines.into(); self } + #[inline] pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self { - self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into(); + self.stippled_rectangular_lines = stippled_rectangular_lines.into(); self } + #[inline] pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self { - self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into(); + self.stippled_bresenham_lines = stippled_bresenham_lines.into(); self } + #[inline] pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self { - self.inner.stippled_smooth_lines = stippled_smooth_lines.into(); + self.stippled_smooth_lines = stippled_smooth_lines.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceLineRasterizationPropertiesEXT { +pub struct PhysicalDeviceLineRasterizationPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub line_sub_pixel_precision_bits: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), line_sub_pixel_precision_bits: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceLineRasterizationPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { - PhysicalDeviceLineRasterizationPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceLineRasterizationPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceLineRasterizationPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceLineRasterizationPropertiesEXT<'a> { + #[inline] pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self { - self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits; + self.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationLineStateCreateInfoEXT { +pub struct PipelineRasterizationLineStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub line_rasterization_mode: LineRasterizationModeEXT, pub stippled_line_enable: Bool32, pub line_stipple_factor: u32, pub line_stipple_pattern: u16, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT { +impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, @@ -39880,140 +25604,79 @@ impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT { stippled_line_enable: Bool32::default(), line_stipple_factor: u32::default(), line_stipple_pattern: u16::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationLineStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { - PipelineRasterizationLineStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { - inner: PipelineRasterizationLineStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_> + for PipelineRasterizationLineStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationLineStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { - type Target = PipelineRasterizationLineStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineRasterizationLineStateCreateInfoEXT<'a> { + #[inline] pub fn line_rasterization_mode( mut self, line_rasterization_mode: LineRasterizationModeEXT, ) -> Self { - self.inner.line_rasterization_mode = line_rasterization_mode; + self.line_rasterization_mode = line_rasterization_mode; self } + #[inline] pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self { - self.inner.stippled_line_enable = stippled_line_enable.into(); + self.stippled_line_enable = stippled_line_enable.into(); self } + #[inline] pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self { - self.inner.line_stipple_factor = line_stipple_factor; + self.line_stipple_factor = line_stipple_factor; self } + #[inline] pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self { - self.inner.line_stipple_pattern = line_stipple_pattern; + self.line_stipple_pattern = line_stipple_pattern; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePipelineCreationCacheControlFeatures { +pub struct PhysicalDevicePipelineCreationCacheControlFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub pipeline_creation_cache_control: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures { +impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, p_next: ::std::ptr::null_mut(), pipeline_creation_cache_control: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePipelineCreationCacheControlFeatures { - pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { - PhysicalDevicePipelineCreationCacheControlFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { - inner: PhysicalDevicePipelineCreationCacheControlFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_> + for PhysicalDevicePipelineCreationCacheControlFeatures<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { - type Target = PhysicalDevicePipelineCreationCacheControlFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures<'_> {} +impl<'a> PhysicalDevicePipelineCreationCacheControlFeatures<'a> { + #[inline] pub fn pipeline_creation_cache_control( mut self, pipeline_creation_cache_control: bool, ) -> Self { - self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); + self.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkan11Features { +pub struct PhysicalDeviceVulkan11Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub storage_buffer16_bit_access: Bool32, @@ -40028,8 +25691,9 @@ pub struct PhysicalDeviceVulkan11Features { pub protected_memory: Bool32, pub sampler_ycbcr_conversion: Bool32, pub shader_draw_parameters: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVulkan11Features { +impl ::std::default::Default for PhysicalDeviceVulkan11Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, @@ -40046,105 +25710,86 @@ impl ::std::default::Default for PhysicalDeviceVulkan11Features { protected_memory: Bool32::default(), sampler_ycbcr_conversion: Bool32::default(), shader_draw_parameters: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVulkan11Features { - pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> { - PhysicalDeviceVulkan11FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> { - inner: PhysicalDeviceVulkan11Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> { - type Target = PhysicalDeviceVulkan11Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features<'_> {} +impl<'a> PhysicalDeviceVulkan11Features<'a> { + #[inline] pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self { - self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); self } + #[inline] pub fn uniform_and_storage_buffer16_bit_access( mut self, uniform_and_storage_buffer16_bit_access: bool, ) -> Self { - self.inner.uniform_and_storage_buffer16_bit_access = + self.uniform_and_storage_buffer16_bit_access = uniform_and_storage_buffer16_bit_access.into(); self } + #[inline] pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { - self.inner.storage_push_constant16 = storage_push_constant16.into(); + self.storage_push_constant16 = storage_push_constant16.into(); self } + #[inline] pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { - self.inner.storage_input_output16 = storage_input_output16.into(); + self.storage_input_output16 = storage_input_output16.into(); self } + #[inline] pub fn multiview(mut self, multiview: bool) -> Self { - self.inner.multiview = multiview.into(); + self.multiview = multiview.into(); self } + #[inline] pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self { - self.inner.multiview_geometry_shader = multiview_geometry_shader.into(); + self.multiview_geometry_shader = multiview_geometry_shader.into(); self } + #[inline] pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self { - self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self.multiview_tessellation_shader = multiview_tessellation_shader.into(); self } + #[inline] pub fn variable_pointers_storage_buffer( mut self, variable_pointers_storage_buffer: bool, ) -> Self { - self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); + self.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); self } + #[inline] pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { - self.inner.variable_pointers = variable_pointers.into(); + self.variable_pointers = variable_pointers.into(); self } + #[inline] pub fn protected_memory(mut self, protected_memory: bool) -> Self { - self.inner.protected_memory = protected_memory.into(); + self.protected_memory = protected_memory.into(); self } + #[inline] pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self { - self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); self } + #[inline] pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { - self.inner.shader_draw_parameters = shader_draw_parameters.into(); + self.shader_draw_parameters = shader_draw_parameters.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkan11Features { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkan11Properties { +pub struct PhysicalDeviceVulkan11Properties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub device_uuid: [u8; UUID_SIZE], @@ -40162,8 +25807,9 @@ pub struct PhysicalDeviceVulkan11Properties { pub protected_no_fault: Bool32, pub max_per_set_descriptors: u32, pub max_memory_allocation_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVulkan11Properties { +impl ::std::default::Default for PhysicalDeviceVulkan11Properties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, @@ -40183,121 +25829,105 @@ impl ::std::default::Default for PhysicalDeviceVulkan11Properties { protected_no_fault: Bool32::default(), max_per_set_descriptors: u32::default(), max_memory_allocation_size: DeviceSize::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVulkan11Properties { - pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> { - PhysicalDeviceVulkan11PropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> { - inner: PhysicalDeviceVulkan11Properties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> { - type Target = PhysicalDeviceVulkan11Properties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties<'_> {} +impl<'a> PhysicalDeviceVulkan11Properties<'a> { + #[inline] pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self { - self.inner.device_uuid = device_uuid; + self.device_uuid = device_uuid; self } + #[inline] pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self { - self.inner.driver_uuid = driver_uuid; + self.driver_uuid = driver_uuid; self } + #[inline] pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self { - self.inner.device_luid = device_luid; + self.device_luid = device_luid; self } + #[inline] pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { - self.inner.device_node_mask = device_node_mask; + self.device_node_mask = device_node_mask; self } + #[inline] pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { - self.inner.device_luid_valid = device_luid_valid.into(); + self.device_luid_valid = device_luid_valid.into(); self } + #[inline] pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { - self.inner.subgroup_size = subgroup_size; + self.subgroup_size = subgroup_size; self } + #[inline] pub fn subgroup_supported_stages( mut self, subgroup_supported_stages: ShaderStageFlags, ) -> Self { - self.inner.subgroup_supported_stages = subgroup_supported_stages; + self.subgroup_supported_stages = subgroup_supported_stages; self } + #[inline] pub fn subgroup_supported_operations( mut self, subgroup_supported_operations: SubgroupFeatureFlags, ) -> Self { - self.inner.subgroup_supported_operations = subgroup_supported_operations; + self.subgroup_supported_operations = subgroup_supported_operations; self } + #[inline] pub fn subgroup_quad_operations_in_all_stages( mut self, subgroup_quad_operations_in_all_stages: bool, ) -> Self { - self.inner.subgroup_quad_operations_in_all_stages = - subgroup_quad_operations_in_all_stages.into(); + self.subgroup_quad_operations_in_all_stages = subgroup_quad_operations_in_all_stages.into(); self } + #[inline] pub fn point_clipping_behavior( mut self, point_clipping_behavior: PointClippingBehavior, ) -> Self { - self.inner.point_clipping_behavior = point_clipping_behavior; + self.point_clipping_behavior = point_clipping_behavior; self } + #[inline] pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self { - self.inner.max_multiview_view_count = max_multiview_view_count; + self.max_multiview_view_count = max_multiview_view_count; self } + #[inline] pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self { - self.inner.max_multiview_instance_index = max_multiview_instance_index; + self.max_multiview_instance_index = max_multiview_instance_index; self } + #[inline] pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { - self.inner.protected_no_fault = protected_no_fault.into(); + self.protected_no_fault = protected_no_fault.into(); self } + #[inline] pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { - self.inner.max_per_set_descriptors = max_per_set_descriptors; + self.max_per_set_descriptors = max_per_set_descriptors; self } + #[inline] pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self { - self.inner.max_memory_allocation_size = max_memory_allocation_size; + self.max_memory_allocation_size = max_memory_allocation_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkan11Properties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkan12Features { +pub struct PhysicalDeviceVulkan12Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub sampler_mirror_clamp_to_edge: Bool32, @@ -40347,8 +25977,9 @@ pub struct PhysicalDeviceVulkan12Features { pub shader_output_viewport_index: Bool32, pub shader_output_layer: Bool32, pub subgroup_broadcast_dynamic_id: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVulkan12Features { +impl ::std::default::Default for PhysicalDeviceVulkan12Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, @@ -40400,342 +26031,344 @@ impl ::std::default::Default for PhysicalDeviceVulkan12Features { shader_output_viewport_index: Bool32::default(), shader_output_layer: Bool32::default(), subgroup_broadcast_dynamic_id: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVulkan12Features { - pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> { - PhysicalDeviceVulkan12FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> { - inner: PhysicalDeviceVulkan12Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> { - type Target = PhysicalDeviceVulkan12Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features<'_> {} +impl<'a> PhysicalDeviceVulkan12Features<'a> { + #[inline] pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self { - self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into(); + self.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into(); self } + #[inline] pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self { - self.inner.draw_indirect_count = draw_indirect_count.into(); + self.draw_indirect_count = draw_indirect_count.into(); self } + #[inline] pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self { - self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); self } + #[inline] pub fn uniform_and_storage_buffer8_bit_access( mut self, uniform_and_storage_buffer8_bit_access: bool, ) -> Self { - self.inner.uniform_and_storage_buffer8_bit_access = - uniform_and_storage_buffer8_bit_access.into(); + self.uniform_and_storage_buffer8_bit_access = uniform_and_storage_buffer8_bit_access.into(); self } + #[inline] pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { - self.inner.storage_push_constant8 = storage_push_constant8.into(); + self.storage_push_constant8 = storage_push_constant8.into(); self } + #[inline] pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self { - self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); self } + #[inline] pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self { - self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); self } + #[inline] pub fn shader_float16(mut self, shader_float16: bool) -> Self { - self.inner.shader_float16 = shader_float16.into(); + self.shader_float16 = shader_float16.into(); self } + #[inline] pub fn shader_int8(mut self, shader_int8: bool) -> Self { - self.inner.shader_int8 = shader_int8.into(); + self.shader_int8 = shader_int8.into(); self } + #[inline] pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self { - self.inner.descriptor_indexing = descriptor_indexing.into(); + self.descriptor_indexing = descriptor_indexing.into(); self } + #[inline] pub fn shader_input_attachment_array_dynamic_indexing( mut self, shader_input_attachment_array_dynamic_indexing: bool, ) -> Self { - self.inner.shader_input_attachment_array_dynamic_indexing = + self.shader_input_attachment_array_dynamic_indexing = shader_input_attachment_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_uniform_texel_buffer_array_dynamic_indexing( mut self, shader_uniform_texel_buffer_array_dynamic_indexing: bool, ) -> Self { - self.inner - .shader_uniform_texel_buffer_array_dynamic_indexing = + self.shader_uniform_texel_buffer_array_dynamic_indexing = shader_uniform_texel_buffer_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_storage_texel_buffer_array_dynamic_indexing( mut self, shader_storage_texel_buffer_array_dynamic_indexing: bool, ) -> Self { - self.inner - .shader_storage_texel_buffer_array_dynamic_indexing = + self.shader_storage_texel_buffer_array_dynamic_indexing = shader_storage_texel_buffer_array_dynamic_indexing.into(); self } + #[inline] pub fn shader_uniform_buffer_array_non_uniform_indexing( mut self, shader_uniform_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_uniform_buffer_array_non_uniform_indexing = + self.shader_uniform_buffer_array_non_uniform_indexing = shader_uniform_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_sampled_image_array_non_uniform_indexing( mut self, shader_sampled_image_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_sampled_image_array_non_uniform_indexing = + self.shader_sampled_image_array_non_uniform_indexing = shader_sampled_image_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_storage_buffer_array_non_uniform_indexing( mut self, shader_storage_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_storage_buffer_array_non_uniform_indexing = + self.shader_storage_buffer_array_non_uniform_indexing = shader_storage_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_storage_image_array_non_uniform_indexing( mut self, shader_storage_image_array_non_uniform_indexing: bool, ) -> Self { - self.inner.shader_storage_image_array_non_uniform_indexing = + self.shader_storage_image_array_non_uniform_indexing = shader_storage_image_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_input_attachment_array_non_uniform_indexing( mut self, shader_input_attachment_array_non_uniform_indexing: bool, ) -> Self { - self.inner - .shader_input_attachment_array_non_uniform_indexing = + self.shader_input_attachment_array_non_uniform_indexing = shader_input_attachment_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( mut self, shader_uniform_texel_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner - .shader_uniform_texel_buffer_array_non_uniform_indexing = + self.shader_uniform_texel_buffer_array_non_uniform_indexing = shader_uniform_texel_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn shader_storage_texel_buffer_array_non_uniform_indexing( mut self, shader_storage_texel_buffer_array_non_uniform_indexing: bool, ) -> Self { - self.inner - .shader_storage_texel_buffer_array_non_uniform_indexing = + self.shader_storage_texel_buffer_array_non_uniform_indexing = shader_storage_texel_buffer_array_non_uniform_indexing.into(); self } + #[inline] pub fn descriptor_binding_uniform_buffer_update_after_bind( mut self, descriptor_binding_uniform_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_uniform_buffer_update_after_bind = + self.descriptor_binding_uniform_buffer_update_after_bind = descriptor_binding_uniform_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_sampled_image_update_after_bind( mut self, descriptor_binding_sampled_image_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_sampled_image_update_after_bind = + self.descriptor_binding_sampled_image_update_after_bind = descriptor_binding_sampled_image_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_storage_image_update_after_bind( mut self, descriptor_binding_storage_image_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_storage_image_update_after_bind = + self.descriptor_binding_storage_image_update_after_bind = descriptor_binding_storage_image_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_storage_buffer_update_after_bind( mut self, descriptor_binding_storage_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_storage_buffer_update_after_bind = + self.descriptor_binding_storage_buffer_update_after_bind = descriptor_binding_storage_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( mut self, descriptor_binding_uniform_texel_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_uniform_texel_buffer_update_after_bind = + self.descriptor_binding_uniform_texel_buffer_update_after_bind = descriptor_binding_uniform_texel_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_storage_texel_buffer_update_after_bind( mut self, descriptor_binding_storage_texel_buffer_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_storage_texel_buffer_update_after_bind = + self.descriptor_binding_storage_texel_buffer_update_after_bind = descriptor_binding_storage_texel_buffer_update_after_bind.into(); self } + #[inline] pub fn descriptor_binding_update_unused_while_pending( mut self, descriptor_binding_update_unused_while_pending: bool, ) -> Self { - self.inner.descriptor_binding_update_unused_while_pending = + self.descriptor_binding_update_unused_while_pending = descriptor_binding_update_unused_while_pending.into(); self } + #[inline] pub fn descriptor_binding_partially_bound( mut self, descriptor_binding_partially_bound: bool, ) -> Self { - self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); + self.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); self } + #[inline] pub fn descriptor_binding_variable_descriptor_count( mut self, descriptor_binding_variable_descriptor_count: bool, ) -> Self { - self.inner.descriptor_binding_variable_descriptor_count = + self.descriptor_binding_variable_descriptor_count = descriptor_binding_variable_descriptor_count.into(); self } + #[inline] pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self { - self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); + self.runtime_descriptor_array = runtime_descriptor_array.into(); self } + #[inline] pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self { - self.inner.sampler_filter_minmax = sampler_filter_minmax.into(); + self.sampler_filter_minmax = sampler_filter_minmax.into(); self } + #[inline] pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { - self.inner.scalar_block_layout = scalar_block_layout.into(); + self.scalar_block_layout = scalar_block_layout.into(); self } + #[inline] pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { - self.inner.imageless_framebuffer = imageless_framebuffer.into(); + self.imageless_framebuffer = imageless_framebuffer.into(); self } + #[inline] pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self { - self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); self } + #[inline] pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self { - self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); self } + #[inline] pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self { - self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); self } + #[inline] pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { - self.inner.host_query_reset = host_query_reset.into(); + self.host_query_reset = host_query_reset.into(); self } + #[inline] pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { - self.inner.timeline_semaphore = timeline_semaphore.into(); + self.timeline_semaphore = timeline_semaphore.into(); self } + #[inline] pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { - self.inner.buffer_device_address = buffer_device_address.into(); + self.buffer_device_address = buffer_device_address.into(); self } + #[inline] pub fn buffer_device_address_capture_replay( mut self, buffer_device_address_capture_replay: bool, ) -> Self { - self.inner.buffer_device_address_capture_replay = - buffer_device_address_capture_replay.into(); + self.buffer_device_address_capture_replay = buffer_device_address_capture_replay.into(); self } + #[inline] pub fn buffer_device_address_multi_device( mut self, buffer_device_address_multi_device: bool, ) -> Self { - self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); self } + #[inline] pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { - self.inner.vulkan_memory_model = vulkan_memory_model.into(); + self.vulkan_memory_model = vulkan_memory_model.into(); self } + #[inline] pub fn vulkan_memory_model_device_scope( mut self, vulkan_memory_model_device_scope: bool, ) -> Self { - self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); + self.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); self } + #[inline] pub fn vulkan_memory_model_availability_visibility_chains( mut self, vulkan_memory_model_availability_visibility_chains: bool, ) -> Self { - self.inner - .vulkan_memory_model_availability_visibility_chains = + self.vulkan_memory_model_availability_visibility_chains = vulkan_memory_model_availability_visibility_chains.into(); self } + #[inline] pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self { - self.inner.shader_output_viewport_index = shader_output_viewport_index.into(); + self.shader_output_viewport_index = shader_output_viewport_index.into(); self } + #[inline] pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self { - self.inner.shader_output_layer = shader_output_layer.into(); + self.shader_output_layer = shader_output_layer.into(); self } + #[inline] pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self { - self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into(); + self.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkan12Features { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkan12Properties { +pub struct PhysicalDeviceVulkan12Properties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub driver_id: DriverId, @@ -40790,9 +26423,10 @@ pub struct PhysicalDeviceVulkan12Properties { pub filter_minmax_image_component_mapping: Bool32, pub max_timeline_semaphore_value_difference: u64, pub framebuffer_integer_color_sample_counts: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PhysicalDeviceVulkan12Properties { +impl fmt::Debug for PhysicalDeviceVulkan12Properties<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceVulkan12Properties") .field("s_type", &self.s_type) @@ -40994,7 +26628,7 @@ impl fmt::Debug for PhysicalDeviceVulkan12Properties { .finish() } } -impl ::std::default::Default for PhysicalDeviceVulkan12Properties { +impl ::std::default::Default for PhysicalDeviceVulkan12Properties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, @@ -41051,429 +26685,427 @@ impl ::std::default::Default for PhysicalDeviceVulkan12Properties { filter_minmax_image_component_mapping: Bool32::default(), max_timeline_semaphore_value_difference: u64::default(), framebuffer_integer_color_sample_counts: SampleCountFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVulkan12Properties { - pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> { - PhysicalDeviceVulkan12PropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> { - inner: PhysicalDeviceVulkan12Properties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> { - type Target = PhysicalDeviceVulkan12Properties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties<'_> {} +impl<'a> PhysicalDeviceVulkan12Properties<'a> { + #[inline] pub fn driver_id(mut self, driver_id: DriverId) -> Self { - self.inner.driver_id = driver_id; + self.driver_id = driver_id; self } + #[inline] pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self { - self.inner.driver_name = driver_name; + self.driver_name = driver_name; self } + #[inline] pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self { - self.inner.driver_info = driver_info; + self.driver_info = driver_info; self } + #[inline] pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self { - self.inner.conformance_version = conformance_version; + self.conformance_version = conformance_version; self } + #[inline] pub fn denorm_behavior_independence( mut self, denorm_behavior_independence: ShaderFloatControlsIndependence, ) -> Self { - self.inner.denorm_behavior_independence = denorm_behavior_independence; + self.denorm_behavior_independence = denorm_behavior_independence; self } + #[inline] pub fn rounding_mode_independence( mut self, rounding_mode_independence: ShaderFloatControlsIndependence, ) -> Self { - self.inner.rounding_mode_independence = rounding_mode_independence; + self.rounding_mode_independence = rounding_mode_independence; self } + #[inline] pub fn shader_signed_zero_inf_nan_preserve_float16( mut self, shader_signed_zero_inf_nan_preserve_float16: bool, ) -> Self { - self.inner.shader_signed_zero_inf_nan_preserve_float16 = + self.shader_signed_zero_inf_nan_preserve_float16 = shader_signed_zero_inf_nan_preserve_float16.into(); self } + #[inline] pub fn shader_signed_zero_inf_nan_preserve_float32( mut self, shader_signed_zero_inf_nan_preserve_float32: bool, ) -> Self { - self.inner.shader_signed_zero_inf_nan_preserve_float32 = + self.shader_signed_zero_inf_nan_preserve_float32 = shader_signed_zero_inf_nan_preserve_float32.into(); self } + #[inline] pub fn shader_signed_zero_inf_nan_preserve_float64( mut self, shader_signed_zero_inf_nan_preserve_float64: bool, ) -> Self { - self.inner.shader_signed_zero_inf_nan_preserve_float64 = + self.shader_signed_zero_inf_nan_preserve_float64 = shader_signed_zero_inf_nan_preserve_float64.into(); self } + #[inline] pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self { - self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); self } + #[inline] pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self { - self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); self } + #[inline] pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self { - self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); self } + #[inline] pub fn shader_denorm_flush_to_zero_float16( mut self, shader_denorm_flush_to_zero_float16: bool, ) -> Self { - self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); + self.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); self } + #[inline] pub fn shader_denorm_flush_to_zero_float32( mut self, shader_denorm_flush_to_zero_float32: bool, ) -> Self { - self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); + self.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); self } + #[inline] pub fn shader_denorm_flush_to_zero_float64( mut self, shader_denorm_flush_to_zero_float64: bool, ) -> Self { - self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); + self.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); self } + #[inline] pub fn shader_rounding_mode_rte_float16( mut self, shader_rounding_mode_rte_float16: bool, ) -> Self { - self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); + self.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); self } + #[inline] pub fn shader_rounding_mode_rte_float32( mut self, shader_rounding_mode_rte_float32: bool, ) -> Self { - self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); + self.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); self } + #[inline] pub fn shader_rounding_mode_rte_float64( mut self, shader_rounding_mode_rte_float64: bool, ) -> Self { - self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); + self.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); self } + #[inline] pub fn shader_rounding_mode_rtz_float16( mut self, shader_rounding_mode_rtz_float16: bool, ) -> Self { - self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); + self.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); self } + #[inline] pub fn shader_rounding_mode_rtz_float32( mut self, shader_rounding_mode_rtz_float32: bool, ) -> Self { - self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); + self.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); self } + #[inline] pub fn shader_rounding_mode_rtz_float64( mut self, shader_rounding_mode_rtz_float64: bool, ) -> Self { - self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); + self.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); self } + #[inline] pub fn max_update_after_bind_descriptors_in_all_pools( mut self, max_update_after_bind_descriptors_in_all_pools: u32, ) -> Self { - self.inner.max_update_after_bind_descriptors_in_all_pools = + self.max_update_after_bind_descriptors_in_all_pools = max_update_after_bind_descriptors_in_all_pools; self } + #[inline] pub fn shader_uniform_buffer_array_non_uniform_indexing_native( mut self, shader_uniform_buffer_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_uniform_buffer_array_non_uniform_indexing_native = + self.shader_uniform_buffer_array_non_uniform_indexing_native = shader_uniform_buffer_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_sampled_image_array_non_uniform_indexing_native( mut self, shader_sampled_image_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_sampled_image_array_non_uniform_indexing_native = + self.shader_sampled_image_array_non_uniform_indexing_native = shader_sampled_image_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_storage_buffer_array_non_uniform_indexing_native( mut self, shader_storage_buffer_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_storage_buffer_array_non_uniform_indexing_native = + self.shader_storage_buffer_array_non_uniform_indexing_native = shader_storage_buffer_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_storage_image_array_non_uniform_indexing_native( mut self, shader_storage_image_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_storage_image_array_non_uniform_indexing_native = + self.shader_storage_image_array_non_uniform_indexing_native = shader_storage_image_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn shader_input_attachment_array_non_uniform_indexing_native( mut self, shader_input_attachment_array_non_uniform_indexing_native: bool, ) -> Self { - self.inner - .shader_input_attachment_array_non_uniform_indexing_native = + self.shader_input_attachment_array_non_uniform_indexing_native = shader_input_attachment_array_non_uniform_indexing_native.into(); self } + #[inline] pub fn robust_buffer_access_update_after_bind( mut self, robust_buffer_access_update_after_bind: bool, ) -> Self { - self.inner.robust_buffer_access_update_after_bind = - robust_buffer_access_update_after_bind.into(); + self.robust_buffer_access_update_after_bind = robust_buffer_access_update_after_bind.into(); self } + #[inline] pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self { - self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_samplers( mut self, max_per_stage_descriptor_update_after_bind_samplers: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_samplers = + self.max_per_stage_descriptor_update_after_bind_samplers = max_per_stage_descriptor_update_after_bind_samplers; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( mut self, max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_uniform_buffers = + self.max_per_stage_descriptor_update_after_bind_uniform_buffers = max_per_stage_descriptor_update_after_bind_uniform_buffers; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( mut self, max_per_stage_descriptor_update_after_bind_storage_buffers: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_storage_buffers = + self.max_per_stage_descriptor_update_after_bind_storage_buffers = max_per_stage_descriptor_update_after_bind_storage_buffers; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_sampled_images( mut self, max_per_stage_descriptor_update_after_bind_sampled_images: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_sampled_images = + self.max_per_stage_descriptor_update_after_bind_sampled_images = max_per_stage_descriptor_update_after_bind_sampled_images; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_storage_images( mut self, max_per_stage_descriptor_update_after_bind_storage_images: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_storage_images = + self.max_per_stage_descriptor_update_after_bind_storage_images = max_per_stage_descriptor_update_after_bind_storage_images; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_input_attachments( mut self, max_per_stage_descriptor_update_after_bind_input_attachments: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_input_attachments = + self.max_per_stage_descriptor_update_after_bind_input_attachments = max_per_stage_descriptor_update_after_bind_input_attachments; self } + #[inline] pub fn max_per_stage_update_after_bind_resources( mut self, max_per_stage_update_after_bind_resources: u32, ) -> Self { - self.inner.max_per_stage_update_after_bind_resources = - max_per_stage_update_after_bind_resources; + self.max_per_stage_update_after_bind_resources = max_per_stage_update_after_bind_resources; self } + #[inline] pub fn max_descriptor_set_update_after_bind_samplers( mut self, max_descriptor_set_update_after_bind_samplers: u32, ) -> Self { - self.inner.max_descriptor_set_update_after_bind_samplers = + self.max_descriptor_set_update_after_bind_samplers = max_descriptor_set_update_after_bind_samplers; self } + #[inline] pub fn max_descriptor_set_update_after_bind_uniform_buffers( mut self, max_descriptor_set_update_after_bind_uniform_buffers: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_uniform_buffers = + self.max_descriptor_set_update_after_bind_uniform_buffers = max_descriptor_set_update_after_bind_uniform_buffers; self } + #[inline] pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic = max_descriptor_set_update_after_bind_uniform_buffers_dynamic; self } + #[inline] pub fn max_descriptor_set_update_after_bind_storage_buffers( mut self, max_descriptor_set_update_after_bind_storage_buffers: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_storage_buffers = + self.max_descriptor_set_update_after_bind_storage_buffers = max_descriptor_set_update_after_bind_storage_buffers; self } + #[inline] pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( mut self, max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + self.max_descriptor_set_update_after_bind_storage_buffers_dynamic = max_descriptor_set_update_after_bind_storage_buffers_dynamic; self } + #[inline] pub fn max_descriptor_set_update_after_bind_sampled_images( mut self, max_descriptor_set_update_after_bind_sampled_images: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_sampled_images = + self.max_descriptor_set_update_after_bind_sampled_images = max_descriptor_set_update_after_bind_sampled_images; self } + #[inline] pub fn max_descriptor_set_update_after_bind_storage_images( mut self, max_descriptor_set_update_after_bind_storage_images: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_storage_images = + self.max_descriptor_set_update_after_bind_storage_images = max_descriptor_set_update_after_bind_storage_images; self } + #[inline] pub fn max_descriptor_set_update_after_bind_input_attachments( mut self, max_descriptor_set_update_after_bind_input_attachments: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_input_attachments = + self.max_descriptor_set_update_after_bind_input_attachments = max_descriptor_set_update_after_bind_input_attachments; self } + #[inline] pub fn supported_depth_resolve_modes( mut self, supported_depth_resolve_modes: ResolveModeFlags, ) -> Self { - self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self.supported_depth_resolve_modes = supported_depth_resolve_modes; self } + #[inline] pub fn supported_stencil_resolve_modes( mut self, supported_stencil_resolve_modes: ResolveModeFlags, ) -> Self { - self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self.supported_stencil_resolve_modes = supported_stencil_resolve_modes; self } + #[inline] pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self { - self.inner.independent_resolve_none = independent_resolve_none.into(); + self.independent_resolve_none = independent_resolve_none.into(); self } + #[inline] pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { - self.inner.independent_resolve = independent_resolve.into(); + self.independent_resolve = independent_resolve.into(); self } + #[inline] pub fn filter_minmax_single_component_formats( mut self, filter_minmax_single_component_formats: bool, ) -> Self { - self.inner.filter_minmax_single_component_formats = - filter_minmax_single_component_formats.into(); + self.filter_minmax_single_component_formats = filter_minmax_single_component_formats.into(); self } + #[inline] pub fn filter_minmax_image_component_mapping( mut self, filter_minmax_image_component_mapping: bool, ) -> Self { - self.inner.filter_minmax_image_component_mapping = - filter_minmax_image_component_mapping.into(); + self.filter_minmax_image_component_mapping = filter_minmax_image_component_mapping.into(); self } + #[inline] pub fn max_timeline_semaphore_value_difference( mut self, max_timeline_semaphore_value_difference: u64, ) -> Self { - self.inner.max_timeline_semaphore_value_difference = - max_timeline_semaphore_value_difference; + self.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference; self } + #[inline] pub fn framebuffer_integer_color_sample_counts( mut self, framebuffer_integer_color_sample_counts: SampleCountFlags, ) -> Self { - self.inner.framebuffer_integer_color_sample_counts = - framebuffer_integer_color_sample_counts; + self.framebuffer_integer_color_sample_counts = framebuffer_integer_color_sample_counts; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkan12Properties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkan13Features { +pub struct PhysicalDeviceVulkan13Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub robust_image_access: Bool32, @@ -41491,8 +27123,9 @@ pub struct PhysicalDeviceVulkan13Features { pub dynamic_rendering: Bool32, pub shader_integer_dot_product: Bool32, pub maintenance4: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVulkan13Features { +impl ::std::default::Default for PhysicalDeviceVulkan13Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, @@ -41512,125 +27145,108 @@ impl ::std::default::Default for PhysicalDeviceVulkan13Features { dynamic_rendering: Bool32::default(), shader_integer_dot_product: Bool32::default(), maintenance4: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVulkan13Features { - pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> { - PhysicalDeviceVulkan13FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> { - inner: PhysicalDeviceVulkan13Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> { - type Target = PhysicalDeviceVulkan13Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features<'_> {} +impl<'a> PhysicalDeviceVulkan13Features<'a> { + #[inline] pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { - self.inner.robust_image_access = robust_image_access.into(); + self.robust_image_access = robust_image_access.into(); self } + #[inline] pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { - self.inner.inline_uniform_block = inline_uniform_block.into(); + self.inline_uniform_block = inline_uniform_block.into(); self } + #[inline] pub fn descriptor_binding_inline_uniform_block_update_after_bind( mut self, descriptor_binding_inline_uniform_block_update_after_bind: bool, ) -> Self { - self.inner - .descriptor_binding_inline_uniform_block_update_after_bind = + self.descriptor_binding_inline_uniform_block_update_after_bind = descriptor_binding_inline_uniform_block_update_after_bind.into(); self } + #[inline] pub fn pipeline_creation_cache_control( mut self, pipeline_creation_cache_control: bool, ) -> Self { - self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); + self.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); self } + #[inline] pub fn private_data(mut self, private_data: bool) -> Self { - self.inner.private_data = private_data.into(); + self.private_data = private_data.into(); self } + #[inline] pub fn shader_demote_to_helper_invocation( mut self, shader_demote_to_helper_invocation: bool, ) -> Self { - self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); + self.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); self } + #[inline] pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self { - self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self.shader_terminate_invocation = shader_terminate_invocation.into(); self } + #[inline] pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { - self.inner.subgroup_size_control = subgroup_size_control.into(); + self.subgroup_size_control = subgroup_size_control.into(); self } + #[inline] pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { - self.inner.compute_full_subgroups = compute_full_subgroups.into(); + self.compute_full_subgroups = compute_full_subgroups.into(); self } + #[inline] pub fn synchronization2(mut self, synchronization2: bool) -> Self { - self.inner.synchronization2 = synchronization2.into(); + self.synchronization2 = synchronization2.into(); self } + #[inline] pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self { - self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); self } + #[inline] pub fn shader_zero_initialize_workgroup_memory( mut self, shader_zero_initialize_workgroup_memory: bool, ) -> Self { - self.inner.shader_zero_initialize_workgroup_memory = + self.shader_zero_initialize_workgroup_memory = shader_zero_initialize_workgroup_memory.into(); self } + #[inline] pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { - self.inner.dynamic_rendering = dynamic_rendering.into(); + self.dynamic_rendering = dynamic_rendering.into(); self } + #[inline] pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { - self.inner.shader_integer_dot_product = shader_integer_dot_product.into(); + self.shader_integer_dot_product = shader_integer_dot_product.into(); self } + #[inline] pub fn maintenance4(mut self, maintenance4: bool) -> Self { - self.inner.maintenance4 = maintenance4.into(); + self.maintenance4 = maintenance4.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkan13Features { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVulkan13Properties { +pub struct PhysicalDeviceVulkan13Properties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_subgroup_size: u32, @@ -41679,528 +27295,459 @@ pub struct PhysicalDeviceVulkan13Properties { pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize, pub uniform_texel_buffer_offset_single_texel_alignment: Bool32, pub max_buffer_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVulkan13Properties { +impl ::std::default::Default for PhysicalDeviceVulkan13Properties<'_> { fn default() -> Self { - Self { s_type : StructureType :: PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () } + Self { s_type : StructureType :: PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () , _marker : PhantomData , } } } -impl PhysicalDeviceVulkan13Properties { - pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> { - PhysicalDeviceVulkan13PropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> { - inner: PhysicalDeviceVulkan13Properties, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> { - type Target = PhysicalDeviceVulkan13Properties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties<'_> {} +impl<'a> PhysicalDeviceVulkan13Properties<'a> { + #[inline] pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { - self.inner.min_subgroup_size = min_subgroup_size; + self.min_subgroup_size = min_subgroup_size; self } + #[inline] pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { - self.inner.max_subgroup_size = max_subgroup_size; + self.max_subgroup_size = max_subgroup_size; self } + #[inline] pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self { - self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; self } + #[inline] pub fn required_subgroup_size_stages( mut self, required_subgroup_size_stages: ShaderStageFlags, ) -> Self { - self.inner.required_subgroup_size_stages = required_subgroup_size_stages; + self.required_subgroup_size_stages = required_subgroup_size_stages; self } + #[inline] pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self { - self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size; + self.max_inline_uniform_block_size = max_inline_uniform_block_size; self } + #[inline] pub fn max_per_stage_descriptor_inline_uniform_blocks( mut self, max_per_stage_descriptor_inline_uniform_blocks: u32, ) -> Self { - self.inner.max_per_stage_descriptor_inline_uniform_blocks = + self.max_per_stage_descriptor_inline_uniform_blocks = max_per_stage_descriptor_inline_uniform_blocks; self } + #[inline] pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( mut self, max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, ) -> Self { - self.inner - .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = + self.max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; self } + #[inline] pub fn max_descriptor_set_inline_uniform_blocks( mut self, max_descriptor_set_inline_uniform_blocks: u32, ) -> Self { - self.inner.max_descriptor_set_inline_uniform_blocks = - max_descriptor_set_inline_uniform_blocks; + self.max_descriptor_set_inline_uniform_blocks = max_descriptor_set_inline_uniform_blocks; self } + #[inline] pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( mut self, max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, ) -> Self { - self.inner - .max_descriptor_set_update_after_bind_inline_uniform_blocks = + self.max_descriptor_set_update_after_bind_inline_uniform_blocks = max_descriptor_set_update_after_bind_inline_uniform_blocks; self } + #[inline] pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self { - self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size; + self.max_inline_uniform_total_size = max_inline_uniform_total_size; self } + #[inline] pub fn integer_dot_product8_bit_unsigned_accelerated( mut self, integer_dot_product8_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product8_bit_unsigned_accelerated = + self.integer_dot_product8_bit_unsigned_accelerated = integer_dot_product8_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product8_bit_signed_accelerated( mut self, integer_dot_product8_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product8_bit_signed_accelerated = + self.integer_dot_product8_bit_signed_accelerated = integer_dot_product8_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product8_bit_mixed_signedness_accelerated( mut self, integer_dot_product8_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product8_bit_mixed_signedness_accelerated = + self.integer_dot_product8_bit_mixed_signedness_accelerated = integer_dot_product8_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product4x8_bit_packed_unsigned_accelerated = + self.integer_dot_product4x8_bit_packed_unsigned_accelerated = integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product4x8_bit_packed_signed_accelerated( mut self, integer_dot_product4x8_bit_packed_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product4x8_bit_packed_signed_accelerated = + self.integer_dot_product4x8_bit_packed_signed_accelerated = integer_dot_product4x8_bit_packed_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + self.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product16_bit_unsigned_accelerated( mut self, integer_dot_product16_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product16_bit_unsigned_accelerated = + self.integer_dot_product16_bit_unsigned_accelerated = integer_dot_product16_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product16_bit_signed_accelerated( mut self, integer_dot_product16_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product16_bit_signed_accelerated = + self.integer_dot_product16_bit_signed_accelerated = integer_dot_product16_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product16_bit_mixed_signedness_accelerated( mut self, integer_dot_product16_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product16_bit_mixed_signedness_accelerated = + self.integer_dot_product16_bit_mixed_signedness_accelerated = integer_dot_product16_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product32_bit_unsigned_accelerated( mut self, integer_dot_product32_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product32_bit_unsigned_accelerated = + self.integer_dot_product32_bit_unsigned_accelerated = integer_dot_product32_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product32_bit_signed_accelerated( mut self, integer_dot_product32_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product32_bit_signed_accelerated = + self.integer_dot_product32_bit_signed_accelerated = integer_dot_product32_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product32_bit_mixed_signedness_accelerated( mut self, integer_dot_product32_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product32_bit_mixed_signedness_accelerated = + self.integer_dot_product32_bit_mixed_signedness_accelerated = integer_dot_product32_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product64_bit_unsigned_accelerated( mut self, integer_dot_product64_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product64_bit_unsigned_accelerated = + self.integer_dot_product64_bit_unsigned_accelerated = integer_dot_product64_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product64_bit_signed_accelerated( mut self, integer_dot_product64_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product64_bit_signed_accelerated = + self.integer_dot_product64_bit_signed_accelerated = integer_dot_product64_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product64_bit_mixed_signedness_accelerated( mut self, integer_dot_product64_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product64_bit_mixed_signedness_accelerated = + self.integer_dot_product64_bit_mixed_signedness_accelerated = integer_dot_product64_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + self.integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, ) -> Self { - self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; self } + #[inline] pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating16_bit_signed_accelerated = integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating32_bit_signed_accelerated = integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating64_bit_signed_accelerated = integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn storage_texel_buffer_offset_alignment_bytes( mut self, storage_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self { - self.inner.storage_texel_buffer_offset_alignment_bytes = + self.storage_texel_buffer_offset_alignment_bytes = storage_texel_buffer_offset_alignment_bytes; self } + #[inline] pub fn storage_texel_buffer_offset_single_texel_alignment( mut self, storage_texel_buffer_offset_single_texel_alignment: bool, ) -> Self { - self.inner - .storage_texel_buffer_offset_single_texel_alignment = + self.storage_texel_buffer_offset_single_texel_alignment = storage_texel_buffer_offset_single_texel_alignment.into(); self } + #[inline] pub fn uniform_texel_buffer_offset_alignment_bytes( mut self, uniform_texel_buffer_offset_alignment_bytes: DeviceSize, ) -> Self { - self.inner.uniform_texel_buffer_offset_alignment_bytes = + self.uniform_texel_buffer_offset_alignment_bytes = uniform_texel_buffer_offset_alignment_bytes; self } + #[inline] pub fn uniform_texel_buffer_offset_single_texel_alignment( mut self, uniform_texel_buffer_offset_single_texel_alignment: bool, ) -> Self { - self.inner - .uniform_texel_buffer_offset_single_texel_alignment = + self.uniform_texel_buffer_offset_single_texel_alignment = uniform_texel_buffer_offset_single_texel_alignment.into(); self } + #[inline] pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { - self.inner.max_buffer_size = max_buffer_size; + self.max_buffer_size = max_buffer_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVulkan13Properties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineCompilerControlCreateInfoAMD { +pub struct PipelineCompilerControlCreateInfoAMD<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub compiler_control_flags: PipelineCompilerControlFlagsAMD, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD { +impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, p_next: ::std::ptr::null(), compiler_control_flags: PipelineCompilerControlFlagsAMD::default(), + _marker: PhantomData, } } } -impl PipelineCompilerControlCreateInfoAMD { - pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> { - PipelineCompilerControlCreateInfoAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> { - inner: PipelineCompilerControlCreateInfoAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {} -unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {} -unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {} -impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> { - type Target = PipelineCompilerControlCreateInfoAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> { +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD<'_> {} +impl<'a> PipelineCompilerControlCreateInfoAMD<'a> { + #[inline] pub fn compiler_control_flags( mut self, compiler_control_flags: PipelineCompilerControlFlagsAMD, ) -> Self { - self.inner.compiler_control_flags = compiler_control_flags; + self.compiler_control_flags = compiler_control_flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineCompilerControlCreateInfoAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCoherentMemoryFeaturesAMD { +pub struct PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub device_coherent_memory: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD { +impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, p_next: ::std::ptr::null_mut(), device_coherent_memory: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCoherentMemoryFeaturesAMD { - pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { - PhysicalDeviceCoherentMemoryFeaturesAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { - inner: PhysicalDeviceCoherentMemoryFeaturesAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { - type Target = PhysicalDeviceCoherentMemoryFeaturesAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD<'_> {} +impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { + #[inline] pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self { - self.inner.device_coherent_memory = device_coherent_memory.into(); + self.device_coherent_memory = device_coherent_memory.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceToolProperties { +pub struct PhysicalDeviceToolProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub name: [c_char; MAX_EXTENSION_NAME_SIZE], @@ -42208,9 +27755,10 @@ pub struct PhysicalDeviceToolProperties { pub purposes: ToolPurposeFlags, pub description: [c_char; MAX_DESCRIPTION_SIZE], pub layer: [c_char; MAX_EXTENSION_NAME_SIZE], + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for PhysicalDeviceToolProperties { +impl fmt::Debug for PhysicalDeviceToolProperties<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("PhysicalDeviceToolProperties") .field("s_type", &self.s_type) @@ -42231,7 +27779,7 @@ impl fmt::Debug for PhysicalDeviceToolProperties { .finish() } } -impl ::std::default::Default for PhysicalDeviceToolProperties { +impl ::std::default::Default for PhysicalDeviceToolProperties<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES, @@ -42241,72 +27789,49 @@ impl ::std::default::Default for PhysicalDeviceToolProperties { purposes: ToolPurposeFlags::default(), description: unsafe { ::std::mem::zeroed() }, layer: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PhysicalDeviceToolProperties { - pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> { - PhysicalDeviceToolPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceToolPropertiesBuilder<'a> { - inner: PhysicalDeviceToolProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> { - type Target = PhysicalDeviceToolProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> { +impl<'a> PhysicalDeviceToolProperties<'a> { + #[inline] pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { - self.inner.name = name; + self.name = name; self } + #[inline] pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { - self.inner.version = version; + self.version = version; self } + #[inline] pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self { - self.inner.purposes = purposes; + self.purposes = purposes; self } + #[inline] pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.inner.description = description; + self.description = description; self } + #[inline] pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { - self.inner.layer = layer; + self.layer = layer; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceToolProperties { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerCustomBorderColorCreateInfoEXT { +pub struct SamplerCustomBorderColorCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub custom_border_color: ClearColorValue, pub format: Format, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT { +impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT") .field("s_type", &self.s_type) @@ -42316,324 +27841,173 @@ impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT { .finish() } } -impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT { +impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, p_next: ::std::ptr::null(), custom_border_color: ClearColorValue::default(), format: Format::default(), + _marker: PhantomData, } } } -impl SamplerCustomBorderColorCreateInfoEXT { - pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { - SamplerCustomBorderColorCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { - inner: SamplerCustomBorderColorCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {} -impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { - type Target = SamplerCustomBorderColorCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT<'_> {} +impl<'a> SamplerCustomBorderColorCreateInfoEXT<'a> { + #[inline] pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self { - self.inner.custom_border_color = custom_border_color; + self.custom_border_color = custom_border_color; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCustomBorderColorPropertiesEXT { +pub struct PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_custom_border_color_samplers: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), max_custom_border_color_samplers: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCustomBorderColorPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { - PhysicalDeviceCustomBorderColorPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceCustomBorderColorPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceCustomBorderColorPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { + #[inline] pub fn max_custom_border_color_samplers( mut self, max_custom_border_color_samplers: u32, ) -> Self { - self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers; + self.max_custom_border_color_samplers = max_custom_border_color_samplers; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceCustomBorderColorFeaturesEXT { +pub struct PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub custom_border_colors: Bool32, pub custom_border_color_without_format: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, p_next: ::std::ptr::null_mut(), custom_border_colors: Bool32::default(), custom_border_color_without_format: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceCustomBorderColorFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { - PhysicalDeviceCustomBorderColorFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceCustomBorderColorFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceCustomBorderColorFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { + #[inline] pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self { - self.inner.custom_border_colors = custom_border_colors.into(); + self.custom_border_colors = custom_border_colors.into(); self } + #[inline] pub fn custom_border_color_without_format( mut self, custom_border_color_without_format: bool, ) -> Self { - self.inner.custom_border_color_without_format = custom_border_color_without_format.into(); + self.custom_border_color_without_format = custom_border_color_without_format.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SamplerBorderColorComponentMappingCreateInfoEXT { +pub struct SamplerBorderColorComponentMappingCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub components: ComponentMapping, pub srgb: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT { +impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, p_next: ::std::ptr::null(), components: ComponentMapping::default(), srgb: Bool32::default(), + _marker: PhantomData, } } } -impl SamplerBorderColorComponentMappingCreateInfoEXT { - pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { - SamplerBorderColorComponentMappingCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { - inner: SamplerBorderColorComponentMappingCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSamplerCreateInfo - for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_> -{ -} -unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {} -impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { - type Target = SamplerBorderColorComponentMappingCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT<'_> {} +impl<'a> SamplerBorderColorComponentMappingCreateInfoEXT<'a> { + #[inline] pub fn components(mut self, components: ComponentMapping) -> Self { - self.inner.components = components; + self.components = components; self } + #[inline] pub fn srgb(mut self, srgb: bool) -> Self { - self.inner.srgb = srgb.into(); + self.srgb = srgb.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT { +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub border_color_swizzle: Bool32, pub border_color_swizzle_from_image: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, p_next: ::std::ptr::null_mut(), border_color_swizzle: Bool32::default(), border_color_swizzle_from_image: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceBorderColorSwizzleFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { - PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { + #[inline] pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self { - self.inner.border_color_swizzle = border_color_swizzle.into(); + self.border_color_swizzle = border_color_swizzle.into(); self } + #[inline] pub fn border_color_swizzle_from_image( mut self, border_color_swizzle_from_image: bool, ) -> Self { - self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into(); + self.border_color_swizzle_from_image = border_color_swizzle_from_image.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -42662,7 +28036,7 @@ impl ::std::default::Default for DeviceOrHostAddressConstKHR { #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureGeometryTrianglesDataKHR { +pub struct AccelerationStructureGeometryTrianglesDataKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vertex_format: Format, @@ -42672,9 +28046,10 @@ pub struct AccelerationStructureGeometryTrianglesDataKHR { pub index_type: IndexType, pub index_data: DeviceOrHostAddressConstKHR, pub transform_data: DeviceOrHostAddressConstKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR { +impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR") .field("s_type", &self.s_type) @@ -42689,7 +28064,7 @@ impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR { .finish() } } -impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR { +impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR, @@ -42701,67 +28076,51 @@ impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR { index_type: IndexType::default(), index_data: DeviceOrHostAddressConstKHR::default(), transform_data: DeviceOrHostAddressConstKHR::default(), + _marker: PhantomData, } } } -impl AccelerationStructureGeometryTrianglesDataKHR { - pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { - AccelerationStructureGeometryTrianglesDataKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { - inner: AccelerationStructureGeometryTrianglesDataKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { - type Target = AccelerationStructureGeometryTrianglesDataKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { +impl<'a> AccelerationStructureGeometryTrianglesDataKHR<'a> { + #[inline] pub fn vertex_format(mut self, vertex_format: Format) -> Self { - self.inner.vertex_format = vertex_format; + self.vertex_format = vertex_format; self } + #[inline] pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { - self.inner.vertex_data = vertex_data; + self.vertex_data = vertex_data; self } + #[inline] pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self { - self.inner.vertex_stride = vertex_stride; + self.vertex_stride = vertex_stride; self } + #[inline] pub fn max_vertex(mut self, max_vertex: u32) -> Self { - self.inner.max_vertex = max_vertex; + self.max_vertex = max_vertex; self } + #[inline] pub fn index_type(mut self, index_type: IndexType) -> Self { - self.inner.index_type = index_type; + self.index_type = index_type; self } + #[inline] pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self { - self.inner.index_data = index_data; + self.index_data = index_data; self } + #[inline] pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self { - self.inner.transform_data = transform_data; + self.transform_data = transform_data; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -42770,29 +28129,24 @@ impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureGeometryAabbsDataKHR { +pub struct AccelerationStructureGeometryAabbsDataKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub data: DeviceOrHostAddressConstKHR, pub stride: DeviceSize, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR { +impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR") .field("s_type", &self.s_type) @@ -42802,67 +28156,41 @@ impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR { .finish() } } -impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR { +impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR, p_next: ::std::ptr::null(), data: DeviceOrHostAddressConstKHR::default(), stride: DeviceSize::default(), + _marker: PhantomData, } } } -impl AccelerationStructureGeometryAabbsDataKHR { - pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { - AccelerationStructureGeometryAabbsDataKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { - inner: AccelerationStructureGeometryAabbsDataKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { - type Target = AccelerationStructureGeometryAabbsDataKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { +impl<'a> AccelerationStructureGeometryAabbsDataKHR<'a> { + #[inline] pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { - self.inner.data = data; + self.data = data; self } + #[inline] pub fn stride(mut self, stride: DeviceSize) -> Self { - self.inner.stride = stride; + self.stride = stride; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureGeometryInstancesDataKHR { +pub struct AccelerationStructureGeometryInstancesDataKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub array_of_pointers: Bool32, pub data: DeviceOrHostAddressConstKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR { +impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR") .field("s_type", &self.s_type) @@ -42872,65 +28200,38 @@ impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR { .finish() } } -impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR { +impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR, p_next: ::std::ptr::null(), array_of_pointers: Bool32::default(), data: DeviceOrHostAddressConstKHR::default(), + _marker: PhantomData, } } } -impl AccelerationStructureGeometryInstancesDataKHR { - pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { - AccelerationStructureGeometryInstancesDataKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { - inner: AccelerationStructureGeometryInstancesDataKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { - type Target = AccelerationStructureGeometryInstancesDataKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { +impl<'a> AccelerationStructureGeometryInstancesDataKHR<'a> { + #[inline] pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self { - self.inner.array_of_pointers = array_of_pointers.into(); + self.array_of_pointers = array_of_pointers.into(); self } + #[inline] pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { - self.inner.data = data; + self.data = data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub union AccelerationStructureGeometryDataKHR { - pub triangles: AccelerationStructureGeometryTrianglesDataKHR, - pub aabbs: AccelerationStructureGeometryAabbsDataKHR, - pub instances: AccelerationStructureGeometryInstancesDataKHR, +pub union AccelerationStructureGeometryDataKHR<'a> { + pub triangles: AccelerationStructureGeometryTrianglesDataKHR<'a>, + pub aabbs: AccelerationStructureGeometryAabbsDataKHR<'a>, + pub instances: AccelerationStructureGeometryInstancesDataKHR<'a>, } -impl ::std::default::Default for AccelerationStructureGeometryDataKHR { +impl<'a> ::std::default::Default for AccelerationStructureGeometryDataKHR<'a> { fn default() -> Self { unsafe { ::std::mem::zeroed() } } @@ -42938,15 +28239,16 @@ impl ::std::default::Default for AccelerationStructureGeometryDataKHR { #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureGeometryKHR { +pub struct AccelerationStructureGeometryKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub geometry_type: GeometryTypeKHR, - pub geometry: AccelerationStructureGeometryDataKHR, + pub geometry: AccelerationStructureGeometryDataKHR<'a>, pub flags: GeometryFlagsKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureGeometryKHR { +impl fmt::Debug for AccelerationStructureGeometryKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AccelerationStructureGeometryKHR") .field("s_type", &self.s_type) @@ -42957,7 +28259,7 @@ impl fmt::Debug for AccelerationStructureGeometryKHR { .finish() } } -impl ::std::default::Default for AccelerationStructureGeometryKHR { +impl ::std::default::Default for AccelerationStructureGeometryKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR, @@ -42965,57 +28267,31 @@ impl ::std::default::Default for AccelerationStructureGeometryKHR { geometry_type: GeometryTypeKHR::default(), geometry: AccelerationStructureGeometryDataKHR::default(), flags: GeometryFlagsKHR::default(), + _marker: PhantomData, } } } -impl AccelerationStructureGeometryKHR { - pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> { - AccelerationStructureGeometryKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureGeometryKHRBuilder<'a> { - inner: AccelerationStructureGeometryKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> { - type Target = AccelerationStructureGeometryKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureGeometryKHRBuilder<'a> { +impl<'a> AccelerationStructureGeometryKHR<'a> { + #[inline] pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self { - self.inner.geometry_type = geometry_type; + self.geometry_type = geometry_type; self } - pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self { - self.inner.geometry = geometry; + #[inline] + pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR<'a>) -> Self { + self.geometry = geometry; self } + #[inline] pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureGeometryKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureBuildGeometryInfoKHR { +pub struct AccelerationStructureBuildGeometryInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ty: AccelerationStructureTypeKHR, @@ -43024,12 +28300,13 @@ pub struct AccelerationStructureBuildGeometryInfoKHR { pub src_acceleration_structure: AccelerationStructureKHR, pub dst_acceleration_structure: AccelerationStructureKHR, pub geometry_count: u32, - pub p_geometries: *const AccelerationStructureGeometryKHR, - pub pp_geometries: *const *const AccelerationStructureGeometryKHR, + pub p_geometries: *const AccelerationStructureGeometryKHR<'a>, + pub pp_geometries: *const *const AccelerationStructureGeometryKHR<'a>, pub scratch_data: DeviceOrHostAddressKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR { +impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR") .field("s_type", &self.s_type) @@ -43052,7 +28329,7 @@ impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR { .finish() } } -impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR { +impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR, @@ -43066,83 +28343,62 @@ impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR { p_geometries: ::std::ptr::null(), pp_geometries: ::std::ptr::null(), scratch_data: DeviceOrHostAddressKHR::default(), + _marker: PhantomData, } } } -impl AccelerationStructureBuildGeometryInfoKHR { - pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - AccelerationStructureBuildGeometryInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - inner: AccelerationStructureBuildGeometryInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - type Target = AccelerationStructureBuildGeometryInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { +impl<'a> AccelerationStructureBuildGeometryInfoKHR<'a> { + #[inline] pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self { - self.inner.mode = mode; + self.mode = mode; self } + #[inline] pub fn src_acceleration_structure( mut self, src_acceleration_structure: AccelerationStructureKHR, ) -> Self { - self.inner.src_acceleration_structure = src_acceleration_structure; + self.src_acceleration_structure = src_acceleration_structure; self } + #[inline] pub fn dst_acceleration_structure( mut self, dst_acceleration_structure: AccelerationStructureKHR, ) -> Self { - self.inner.dst_acceleration_structure = dst_acceleration_structure; + self.dst_acceleration_structure = dst_acceleration_structure; self } + #[inline] pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self { - self.inner.geometry_count = geometries.len() as _; - self.inner.p_geometries = geometries.as_ptr(); + self.geometry_count = geometries.len() as _; + self.p_geometries = geometries.as_ptr(); self } + #[inline] pub fn geometries_ptrs( mut self, - geometries: &'a [&'a AccelerationStructureGeometryKHR], + geometries: &'a [&'a AccelerationStructureGeometryKHR<'a>], ) -> Self { - self.inner.geometry_count = geometries.len() as _; - self.inner.pp_geometries = geometries.as_ptr() as *const *const _; + self.geometry_count = geometries.len() as _; + self.pp_geometries = geometries.as_ptr() as *const *const _; self } + #[inline] pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self { - self.inner.scratch_data = scratch_data; + self.scratch_data = scratch_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -43155,58 +28411,32 @@ pub struct AccelerationStructureBuildRangeInfoKHR { pub transform_offset: u32, } impl AccelerationStructureBuildRangeInfoKHR { - pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { - AccelerationStructureBuildRangeInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> { - inner: AccelerationStructureBuildRangeInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { - type Target = AccelerationStructureBuildRangeInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + #[inline] pub fn primitive_count(mut self, primitive_count: u32) -> Self { - self.inner.primitive_count = primitive_count; + self.primitive_count = primitive_count; self } + #[inline] pub fn primitive_offset(mut self, primitive_offset: u32) -> Self { - self.inner.primitive_offset = primitive_offset; + self.primitive_offset = primitive_offset; self } + #[inline] pub fn first_vertex(mut self, first_vertex: u32) -> Self { - self.inner.first_vertex = first_vertex; + self.first_vertex = first_vertex; self } + #[inline] pub fn transform_offset(mut self, transform_offset: u32) -> Self { - self.inner.transform_offset = transform_offset; + self.transform_offset = transform_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureCreateInfoKHR { +pub struct AccelerationStructureCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub create_flags: AccelerationStructureCreateFlagsKHR, @@ -43215,8 +28445,9 @@ pub struct AccelerationStructureCreateInfoKHR { pub size: DeviceSize, pub ty: AccelerationStructureTypeKHR, pub device_address: DeviceAddress, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureCreateInfoKHR { +impl ::std::default::Default for AccelerationStructureCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR, @@ -43227,63 +28458,46 @@ impl ::std::default::Default for AccelerationStructureCreateInfoKHR { size: DeviceSize::default(), ty: AccelerationStructureTypeKHR::default(), device_address: DeviceAddress::default(), + _marker: PhantomData, } } } -impl AccelerationStructureCreateInfoKHR { - pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> { - AccelerationStructureCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureCreateInfoKHRBuilder<'a> { - inner: AccelerationStructureCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> { - type Target = AccelerationStructureCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { +impl<'a> AccelerationStructureCreateInfoKHR<'a> { + #[inline] pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self { - self.inner.create_flags = create_flags; + self.create_flags = create_flags; self } + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } + #[inline] pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn device_address(mut self, device_address: DeviceAddress) -> Self { - self.inner.device_address = device_address; + self.device_address = device_address; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -43292,17 +28506,11 @@ impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -43317,60 +28525,36 @@ pub struct AabbPositionsKHR { pub max_z: f32, } impl AabbPositionsKHR { - pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> { - AabbPositionsKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AabbPositionsKHRBuilder<'a> { - inner: AabbPositionsKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> { - type Target = AabbPositionsKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AabbPositionsKHRBuilder<'a> { + #[inline] pub fn min_x(mut self, min_x: f32) -> Self { - self.inner.min_x = min_x; + self.min_x = min_x; self } + #[inline] pub fn min_y(mut self, min_y: f32) -> Self { - self.inner.min_y = min_y; + self.min_y = min_y; self } + #[inline] pub fn min_z(mut self, min_z: f32) -> Self { - self.inner.min_z = min_z; + self.min_z = min_z; self } + #[inline] pub fn max_x(mut self, max_x: f32) -> Self { - self.inner.max_x = max_x; + self.max_x = max_x; self } + #[inline] pub fn max_y(mut self, max_y: f32) -> Self { - self.inner.max_y = max_y; + self.max_y = max_y; self } + #[inline] pub fn max_z(mut self, max_z: f32) -> Self { - self.inner.max_z = max_z; + self.max_z = max_z; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AabbPositionsKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -43398,125 +28582,72 @@ pub struct AccelerationStructureInstanceKHR { #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureDeviceAddressInfoKHR { +pub struct AccelerationStructureDeviceAddressInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acceleration_structure: AccelerationStructureKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR { +impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, p_next: ::std::ptr::null(), acceleration_structure: AccelerationStructureKHR::default(), + _marker: PhantomData, } } } -impl AccelerationStructureDeviceAddressInfoKHR { - pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - AccelerationStructureDeviceAddressInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - inner: AccelerationStructureDeviceAddressInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - type Target = AccelerationStructureDeviceAddressInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { +impl<'a> AccelerationStructureDeviceAddressInfoKHR<'a> { + #[inline] pub fn acceleration_structure( mut self, acceleration_structure: AccelerationStructureKHR, ) -> Self { - self.inner.acceleration_structure = acceleration_structure; + self.acceleration_structure = acceleration_structure; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureVersionInfoKHR { +pub struct AccelerationStructureVersionInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_version_data: *const [u8; 2 * UUID_SIZE], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureVersionInfoKHR { +impl ::std::default::Default for AccelerationStructureVersionInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR, p_next: ::std::ptr::null(), p_version_data: ::std::ptr::null(), + _marker: PhantomData, } } } -impl AccelerationStructureVersionInfoKHR { - pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> { - AccelerationStructureVersionInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureVersionInfoKHRBuilder<'a> { - inner: AccelerationStructureVersionInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> { - type Target = AccelerationStructureVersionInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> { +impl<'a> AccelerationStructureVersionInfoKHR<'a> { + #[inline] pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self { - self.inner.p_version_data = version_data; + self.p_version_data = version_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureVersionInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyAccelerationStructureInfoKHR { +pub struct CopyAccelerationStructureInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src: AccelerationStructureKHR, pub dst: AccelerationStructureKHR, pub mode: CopyAccelerationStructureModeKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyAccelerationStructureInfoKHR { +impl ::std::default::Default for CopyAccelerationStructureInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR, @@ -43524,65 +28655,40 @@ impl ::std::default::Default for CopyAccelerationStructureInfoKHR { src: AccelerationStructureKHR::default(), dst: AccelerationStructureKHR::default(), mode: CopyAccelerationStructureModeKHR::default(), + _marker: PhantomData, } } } -impl CopyAccelerationStructureInfoKHR { - pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> { - CopyAccelerationStructureInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyAccelerationStructureInfoKHRBuilder<'a> { - inner: CopyAccelerationStructureInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> { - type Target = CopyAccelerationStructureInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> { +impl<'a> CopyAccelerationStructureInfoKHR<'a> { + #[inline] pub fn src(mut self, src: AccelerationStructureKHR) -> Self { - self.inner.src = src; + self.src = src; self } + #[inline] pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self { - self.inner.dst = dst; + self.dst = dst; self } + #[inline] pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { - self.inner.mode = mode; + self.mode = mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyAccelerationStructureInfoKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyAccelerationStructureToMemoryInfoKHR { +pub struct CopyAccelerationStructureToMemoryInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src: AccelerationStructureKHR, pub dst: DeviceOrHostAddressKHR, pub mode: CopyAccelerationStructureModeKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR { +impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR") .field("s_type", &self.s_type) @@ -43593,7 +28699,7 @@ impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR { .finish() } } -impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR { +impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR, @@ -43601,65 +28707,40 @@ impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR { src: AccelerationStructureKHR::default(), dst: DeviceOrHostAddressKHR::default(), mode: CopyAccelerationStructureModeKHR::default(), + _marker: PhantomData, } } } -impl CopyAccelerationStructureToMemoryInfoKHR { - pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { - CopyAccelerationStructureToMemoryInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { - inner: CopyAccelerationStructureToMemoryInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { - type Target = CopyAccelerationStructureToMemoryInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { +impl<'a> CopyAccelerationStructureToMemoryInfoKHR<'a> { + #[inline] pub fn src(mut self, src: AccelerationStructureKHR) -> Self { - self.inner.src = src; + self.src = src; self } + #[inline] pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { - self.inner.dst = dst; + self.dst = dst; self } + #[inline] pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { - self.inner.mode = mode; + self.mode = mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyMemoryToAccelerationStructureInfoKHR { +pub struct CopyMemoryToAccelerationStructureInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src: DeviceOrHostAddressConstKHR, pub dst: AccelerationStructureKHR, pub mode: CopyAccelerationStructureModeKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR { +impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR") .field("s_type", &self.s_type) @@ -43670,7 +28751,7 @@ impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR { .finish() } } -impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR { +impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR, @@ -43678,246 +28759,136 @@ impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR { src: DeviceOrHostAddressConstKHR::default(), dst: AccelerationStructureKHR::default(), mode: CopyAccelerationStructureModeKHR::default(), + _marker: PhantomData, } } } -impl CopyMemoryToAccelerationStructureInfoKHR { - pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { - CopyMemoryToAccelerationStructureInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { - inner: CopyMemoryToAccelerationStructureInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { - type Target = CopyMemoryToAccelerationStructureInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { +impl<'a> CopyMemoryToAccelerationStructureInfoKHR<'a> { + #[inline] pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { - self.inner.src = src; + self.src = src; self } + #[inline] pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self { - self.inner.dst = dst; + self.dst = dst; self } + #[inline] pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { - self.inner.mode = mode; + self.mode = mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RayTracingPipelineInterfaceCreateInfoKHR { +pub struct RayTracingPipelineInterfaceCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_pipeline_ray_payload_size: u32, pub max_pipeline_ray_hit_attribute_size: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR { +impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR, p_next: ::std::ptr::null(), max_pipeline_ray_payload_size: u32::default(), max_pipeline_ray_hit_attribute_size: u32::default(), + _marker: PhantomData, } } } -impl RayTracingPipelineInterfaceCreateInfoKHR { - pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - RayTracingPipelineInterfaceCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - inner: RayTracingPipelineInterfaceCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - type Target = RayTracingPipelineInterfaceCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { +impl<'a> RayTracingPipelineInterfaceCreateInfoKHR<'a> { + #[inline] pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self { - self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size; + self.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size; self } + #[inline] pub fn max_pipeline_ray_hit_attribute_size( mut self, max_pipeline_ray_hit_attribute_size: u32, ) -> Self { - self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; + self.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineLibraryCreateInfoKHR { +pub struct PipelineLibraryCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub library_count: u32, pub p_libraries: *const Pipeline, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineLibraryCreateInfoKHR { +impl ::std::default::Default for PipelineLibraryCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR, p_next: ::std::ptr::null(), library_count: u32::default(), p_libraries: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineLibraryCreateInfoKHR { - pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> { - PipelineLibraryCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineLibraryCreateInfoKHRBuilder<'a> { - inner: PipelineLibraryCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> { - type Target = PipelineLibraryCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> { +impl<'a> PipelineLibraryCreateInfoKHR<'a> { + #[inline] pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self { - self.inner.library_count = libraries.len() as _; - self.inner.p_libraries = libraries.as_ptr(); + self.library_count = libraries.len() as _; + self.p_libraries = libraries.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineLibraryCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT { +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub extended_dynamic_state: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, p_next: ::std::ptr::null_mut(), extended_dynamic_state: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExtendedDynamicStateFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { - PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> { + #[inline] pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self { - self.inner.extended_dynamic_state = extended_dynamic_state.into(); + self.extended_dynamic_state = extended_dynamic_state.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT { +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub extended_dynamic_state2: Bool32, pub extended_dynamic_state2_logic_op: Bool32, pub extended_dynamic_state2_patch_control_points: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT { +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, @@ -43925,522 +28896,276 @@ impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT extended_dynamic_state2: Bool32::default(), extended_dynamic_state2_logic_op: Bool32::default(), extended_dynamic_state2_patch_control_points: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExtendedDynamicState2FeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { - PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { - inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> { + #[inline] pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self { - self.inner.extended_dynamic_state2 = extended_dynamic_state2.into(); + self.extended_dynamic_state2 = extended_dynamic_state2.into(); self } + #[inline] pub fn extended_dynamic_state2_logic_op( mut self, extended_dynamic_state2_logic_op: bool, ) -> Self { - self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into(); + self.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into(); self } + #[inline] pub fn extended_dynamic_state2_patch_control_points( mut self, extended_dynamic_state2_patch_control_points: bool, ) -> Self { - self.inner.extended_dynamic_state2_patch_control_points = + self.extended_dynamic_state2_patch_control_points = extended_dynamic_state2_patch_control_points.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderPassTransformBeginInfoQCOM { +pub struct RenderPassTransformBeginInfoQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub transform: SurfaceTransformFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassTransformBeginInfoQCOM { +impl ::std::default::Default for RenderPassTransformBeginInfoQCOM<'_> { fn default() -> Self { Self { s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, p_next: ::std::ptr::null_mut(), transform: SurfaceTransformFlagsKHR::default(), + _marker: PhantomData, } } } -impl RenderPassTransformBeginInfoQCOM { - pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> { - RenderPassTransformBeginInfoQCOMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> { - inner: RenderPassTransformBeginInfoQCOM, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {} -unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {} -impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> { - type Target = RenderPassTransformBeginInfoQCOM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> { +unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM<'_> {} +impl<'a> RenderPassTransformBeginInfoQCOM<'a> { + #[inline] pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.transform = transform; + self.transform = transform; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderPassTransformBeginInfoQCOM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyCommandTransformInfoQCOM { +pub struct CopyCommandTransformInfoQCOM<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub transform: SurfaceTransformFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyCommandTransformInfoQCOM { +impl ::std::default::Default for CopyCommandTransformInfoQCOM<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM, p_next: ::std::ptr::null(), transform: SurfaceTransformFlagsKHR::default(), + _marker: PhantomData, } } } -impl CopyCommandTransformInfoQCOM { - pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> { - CopyCommandTransformInfoQCOMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyCommandTransformInfoQCOMBuilder<'a> { - inner: CopyCommandTransformInfoQCOM, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {} -unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {} -unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {} -unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {} -impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> { - type Target = CopyCommandTransformInfoQCOM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> { +unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM<'_> {} +unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM<'_> {} +impl<'a> CopyCommandTransformInfoQCOM<'a> { + #[inline] pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.transform = transform; + self.transform = transform; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyCommandTransformInfoQCOM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM { +pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub transform: SurfaceTransformFlagsKHR, pub render_area: Rect2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM { +impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, p_next: ::std::ptr::null_mut(), transform: SurfaceTransformFlagsKHR::default(), render_area: Rect2D::default(), + _marker: PhantomData, } } } -impl CommandBufferInheritanceRenderPassTransformInfoQCOM { - pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { - CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { - inner: CommandBufferInheritanceRenderPassTransformInfoQCOM, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsCommandBufferInheritanceInfo - for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_> + for CommandBufferInheritanceRenderPassTransformInfoQCOM<'_> { } -unsafe impl ExtendsCommandBufferInheritanceInfo - for CommandBufferInheritanceRenderPassTransformInfoQCOM -{ -} -impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { - type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { +impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { + #[inline] pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { - self.inner.transform = transform; + self.transform = transform; self } + #[inline] pub fn render_area(mut self, render_area: Rect2D) -> Self { - self.inner.render_area = render_area; + self.render_area = render_area; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV { +pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub diagnostics_config: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV { +impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, p_next: ::std::ptr::null_mut(), diagnostics_config: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDiagnosticsConfigFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { - PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { - inner: PhysicalDeviceDiagnosticsConfigFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV<'_> {} +impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> { + #[inline] pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self { - self.inner.diagnostics_config = diagnostics_config.into(); + self.diagnostics_config = diagnostics_config.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DeviceDiagnosticsConfigCreateInfoNV { +pub struct DeviceDiagnosticsConfigCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: DeviceDiagnosticsConfigFlagsNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV { +impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, p_next: ::std::ptr::null(), flags: DeviceDiagnosticsConfigFlagsNV::default(), + _marker: PhantomData, } } } -impl DeviceDiagnosticsConfigCreateInfoNV { - pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { - DeviceDiagnosticsConfigCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { - inner: DeviceDiagnosticsConfigCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {} -impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { - type Target = DeviceDiagnosticsConfigCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV<'_> {} +impl<'a> DeviceDiagnosticsConfigCreateInfoNV<'a> { + #[inline] pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { +pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_zero_initialize_workgroup_memory: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { +impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, p_next: ::std::ptr::null_mut(), shader_zero_initialize_workgroup_memory: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { - pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { - PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { - inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_> + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { - type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'_> {} +impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> { + #[inline] pub fn shader_zero_initialize_workgroup_memory( mut self, shader_zero_initialize_workgroup_memory: bool, ) -> Self { - self.inner.shader_zero_initialize_workgroup_memory = + self.shader_zero_initialize_workgroup_memory = shader_zero_initialize_workgroup_memory.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_subgroup_uniform_control_flow: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, p_next: ::std::ptr::null_mut(), shader_subgroup_uniform_control_flow: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { - PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'_> { } unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'_> { } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {} -impl<'a> ::std::ops::Deref - for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> -{ - type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut - for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> -{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { +impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> { + #[inline] pub fn shader_subgroup_uniform_control_flow( mut self, shader_subgroup_uniform_control_flow: bool, ) -> Self { - self.inner.shader_subgroup_uniform_control_flow = - shader_subgroup_uniform_control_flow.into(); + self.shader_subgroup_uniform_control_flow = shader_subgroup_uniform_control_flow.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRobustness2FeaturesEXT { +pub struct PhysicalDeviceRobustness2FeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub robust_buffer_access2: Bool32, pub robust_image_access2: Bool32, pub null_descriptor: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT { +impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, @@ -44448,198 +29173,115 @@ impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT { robust_buffer_access2: Bool32::default(), robust_image_access2: Bool32::default(), null_descriptor: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRobustness2FeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { - PhysicalDeviceRobustness2FeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { - inner: PhysicalDeviceRobustness2FeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceRobustness2FeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceRobustness2FeaturesEXT<'a> { + #[inline] pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self { - self.inner.robust_buffer_access2 = robust_buffer_access2.into(); + self.robust_buffer_access2 = robust_buffer_access2.into(); self } + #[inline] pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self { - self.inner.robust_image_access2 = robust_image_access2.into(); + self.robust_image_access2 = robust_image_access2.into(); self } + #[inline] pub fn null_descriptor(mut self, null_descriptor: bool) -> Self { - self.inner.null_descriptor = null_descriptor.into(); + self.null_descriptor = null_descriptor.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRobustness2PropertiesEXT { +pub struct PhysicalDeviceRobustness2PropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub robust_storage_buffer_access_size_alignment: DeviceSize, pub robust_uniform_buffer_access_size_alignment: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT { +impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), robust_storage_buffer_access_size_alignment: DeviceSize::default(), robust_uniform_buffer_access_size_alignment: DeviceSize::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRobustness2PropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { - PhysicalDeviceRobustness2PropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { - inner: PhysicalDeviceRobustness2PropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceRobustness2PropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT<'_> {} +impl<'a> PhysicalDeviceRobustness2PropertiesEXT<'a> { + #[inline] pub fn robust_storage_buffer_access_size_alignment( mut self, robust_storage_buffer_access_size_alignment: DeviceSize, ) -> Self { - self.inner.robust_storage_buffer_access_size_alignment = + self.robust_storage_buffer_access_size_alignment = robust_storage_buffer_access_size_alignment; self } + #[inline] pub fn robust_uniform_buffer_access_size_alignment( mut self, robust_uniform_buffer_access_size_alignment: DeviceSize, ) -> Self { - self.inner.robust_uniform_buffer_access_size_alignment = + self.robust_uniform_buffer_access_size_alignment = robust_uniform_buffer_access_size_alignment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceImageRobustnessFeatures { +pub struct PhysicalDeviceImageRobustnessFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub robust_image_access: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures { +impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, p_next: ::std::ptr::null_mut(), robust_image_access: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceImageRobustnessFeatures { - pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { - PhysicalDeviceImageRobustnessFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { - inner: PhysicalDeviceImageRobustnessFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { - type Target = PhysicalDeviceImageRobustnessFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures<'_> {} +impl<'a> PhysicalDeviceImageRobustnessFeatures<'a> { + #[inline] pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { - self.inner.robust_image_access = robust_image_access.into(); + self.robust_image_access = robust_image_access.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { +pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub workgroup_memory_explicit_layout: Bool32, pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32, pub workgroup_memory_explicit_layout8_bit_access: Bool32, pub workgroup_memory_explicit_layout16_bit_access: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, @@ -44648,93 +29290,57 @@ impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeat workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(), workgroup_memory_explicit_layout8_bit_access: Bool32::default(), workgroup_memory_explicit_layout16_bit_access: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { - PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR -{ -} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut - for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> -{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> { + #[inline] pub fn workgroup_memory_explicit_layout( mut self, workgroup_memory_explicit_layout: bool, ) -> Self { - self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into(); + self.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into(); self } + #[inline] pub fn workgroup_memory_explicit_layout_scalar_block_layout( mut self, workgroup_memory_explicit_layout_scalar_block_layout: bool, ) -> Self { - self.inner - .workgroup_memory_explicit_layout_scalar_block_layout = + self.workgroup_memory_explicit_layout_scalar_block_layout = workgroup_memory_explicit_layout_scalar_block_layout.into(); self } + #[inline] pub fn workgroup_memory_explicit_layout8_bit_access( mut self, workgroup_memory_explicit_layout8_bit_access: bool, ) -> Self { - self.inner.workgroup_memory_explicit_layout8_bit_access = + self.workgroup_memory_explicit_layout8_bit_access = workgroup_memory_explicit_layout8_bit_access.into(); self } + #[inline] pub fn workgroup_memory_explicit_layout16_bit_access( mut self, workgroup_memory_explicit_layout16_bit_access: bool, ) -> Self { - self.inner.workgroup_memory_explicit_layout16_bit_access = + self.workgroup_memory_explicit_layout16_bit_access = workgroup_memory_explicit_layout16_bit_access.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePortabilitySubsetFeaturesKHR { +pub struct PhysicalDevicePortabilitySubsetFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub constant_alpha_color_blend_factors: Bool32, @@ -44752,8 +29358,9 @@ pub struct PhysicalDevicePortabilitySubsetFeaturesKHR { pub tessellation_point_mode: Bool32, pub triangle_fans: Bool32, pub vertex_attribute_access_beyond_stride: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR { +impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, @@ -44773,322 +29380,211 @@ impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR { tessellation_point_mode: Bool32::default(), triangle_fans: Bool32::default(), vertex_attribute_access_beyond_stride: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePortabilitySubsetFeaturesKHR { - pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { - PhysicalDevicePortabilitySubsetFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { - inner: PhysicalDevicePortabilitySubsetFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { - type Target = PhysicalDevicePortabilitySubsetFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR<'_> {} +impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHR<'a> { + #[inline] pub fn constant_alpha_color_blend_factors( mut self, constant_alpha_color_blend_factors: bool, ) -> Self { - self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into(); + self.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into(); self } + #[inline] pub fn events(mut self, events: bool) -> Self { - self.inner.events = events.into(); + self.events = events.into(); self } + #[inline] pub fn image_view_format_reinterpretation( mut self, image_view_format_reinterpretation: bool, ) -> Self { - self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into(); + self.image_view_format_reinterpretation = image_view_format_reinterpretation.into(); self } + #[inline] pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self { - self.inner.image_view_format_swizzle = image_view_format_swizzle.into(); + self.image_view_format_swizzle = image_view_format_swizzle.into(); self } + #[inline] pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self { - self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into(); + self.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into(); self } + #[inline] pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self { - self.inner.multisample_array_image = multisample_array_image.into(); + self.multisample_array_image = multisample_array_image.into(); self } + #[inline] pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self { - self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into(); + self.mutable_comparison_samplers = mutable_comparison_samplers.into(); self } + #[inline] pub fn point_polygons(mut self, point_polygons: bool) -> Self { - self.inner.point_polygons = point_polygons.into(); + self.point_polygons = point_polygons.into(); self } + #[inline] pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self { - self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into(); + self.sampler_mip_lod_bias = sampler_mip_lod_bias.into(); self } + #[inline] pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self { - self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into(); + self.separate_stencil_mask_ref = separate_stencil_mask_ref.into(); self } + #[inline] pub fn shader_sample_rate_interpolation_functions( mut self, shader_sample_rate_interpolation_functions: bool, ) -> Self { - self.inner.shader_sample_rate_interpolation_functions = + self.shader_sample_rate_interpolation_functions = shader_sample_rate_interpolation_functions.into(); self } + #[inline] pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self { - self.inner.tessellation_isolines = tessellation_isolines.into(); + self.tessellation_isolines = tessellation_isolines.into(); self } + #[inline] pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self { - self.inner.tessellation_point_mode = tessellation_point_mode.into(); + self.tessellation_point_mode = tessellation_point_mode.into(); self } + #[inline] pub fn triangle_fans(mut self, triangle_fans: bool) -> Self { - self.inner.triangle_fans = triangle_fans.into(); + self.triangle_fans = triangle_fans.into(); self } + #[inline] pub fn vertex_attribute_access_beyond_stride( mut self, vertex_attribute_access_beyond_stride: bool, ) -> Self { - self.inner.vertex_attribute_access_beyond_stride = - vertex_attribute_access_beyond_stride.into(); + self.vertex_attribute_access_beyond_stride = vertex_attribute_access_beyond_stride.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevicePortabilitySubsetPropertiesKHR { +pub struct PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_vertex_input_binding_stride_alignment: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR { +impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), min_vertex_input_binding_stride_alignment: u32::default(), + _marker: PhantomData, } } } -impl PhysicalDevicePortabilitySubsetPropertiesKHR { - pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { - PhysicalDevicePortabilitySubsetPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { - inner: PhysicalDevicePortabilitySubsetPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { - type Target = PhysicalDevicePortabilitySubsetPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR<'_> {} +impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { + #[inline] pub fn min_vertex_input_binding_stride_alignment( mut self, min_vertex_input_binding_stride_alignment: u32, ) -> Self { - self.inner.min_vertex_input_binding_stride_alignment = - min_vertex_input_binding_stride_alignment; + self.min_vertex_input_binding_stride_alignment = min_vertex_input_binding_stride_alignment; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDevice4444FormatsFeaturesEXT { +pub struct PhysicalDevice4444FormatsFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub format_a4r4g4b4: Bool32, pub format_a4b4g4r4: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT { +impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, p_next: ::std::ptr::null_mut(), format_a4r4g4b4: Bool32::default(), format_a4b4g4r4: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDevice4444FormatsFeaturesEXT { - pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { - PhysicalDevice4444FormatsFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { - inner: PhysicalDevice4444FormatsFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { - type Target = PhysicalDevice4444FormatsFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT<'_> {} +impl<'a> PhysicalDevice4444FormatsFeaturesEXT<'a> { + #[inline] pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self { - self.inner.format_a4r4g4b4 = format_a4r4g4b4.into(); + self.format_a4r4g4b4 = format_a4r4g4b4.into(); self } + #[inline] pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self { - self.inner.format_a4b4g4r4 = format_a4b4g4r4.into(); + self.format_a4b4g4r4 = format_a4b4g4r4.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI { +pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub subpass_shading: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI { +impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, p_next: ::std::ptr::null_mut(), subpass_shading: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSubpassShadingFeaturesHUAWEI { - pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { - PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { - inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { - type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'_> {} +impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> { + #[inline] pub fn subpass_shading(mut self, subpass_shading: bool) -> Self { - self.inner.subpass_shading = subpass_shading.into(); + self.subpass_shading = subpass_shading.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCopy2 { +pub struct BufferCopy2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_offset: DeviceSize, pub dst_offset: DeviceSize, pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCopy2 { +impl ::std::default::Default for BufferCopy2<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_COPY_2, @@ -45096,58 +29592,32 @@ impl ::std::default::Default for BufferCopy2 { src_offset: DeviceSize::default(), dst_offset: DeviceSize::default(), size: DeviceSize::default(), + _marker: PhantomData, } } } -impl BufferCopy2 { - pub fn builder<'a>() -> BufferCopy2Builder<'a> { - BufferCopy2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCopy2Builder<'a> { - inner: BufferCopy2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> { - type Target = BufferCopy2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCopy2Builder<'a> { +impl<'a> BufferCopy2<'a> { + #[inline] pub fn src_offset(mut self, src_offset: DeviceSize) -> Self { - self.inner.src_offset = src_offset; + self.src_offset = src_offset; self } + #[inline] pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self { - self.inner.dst_offset = dst_offset; + self.dst_offset = dst_offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCopy2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageCopy2 { +pub struct ImageCopy2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_subresource: ImageSubresourceLayers, @@ -45155,8 +29625,9 @@ pub struct ImageCopy2 { pub dst_subresource: ImageSubresourceLayers, pub dst_offset: Offset3D, pub extent: Extent3D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageCopy2 { +impl ::std::default::Default for ImageCopy2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_COPY_2, @@ -45166,74 +29637,51 @@ impl ::std::default::Default for ImageCopy2 { dst_subresource: ImageSubresourceLayers::default(), dst_offset: Offset3D::default(), extent: Extent3D::default(), + _marker: PhantomData, } } } -impl ImageCopy2 { - pub fn builder<'a>() -> ImageCopy2Builder<'a> { - ImageCopy2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageCopy2Builder<'a> { - inner: ImageCopy2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> { - type Target = ImageCopy2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageCopy2Builder<'a> { +impl<'a> ImageCopy2<'a> { + #[inline] pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { - self.inner.src_subresource = src_subresource; + self.src_subresource = src_subresource; self } + #[inline] pub fn src_offset(mut self, src_offset: Offset3D) -> Self { - self.inner.src_offset = src_offset; + self.src_offset = src_offset; self } + #[inline] pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { - self.inner.dst_subresource = dst_subresource; + self.dst_subresource = dst_subresource; self } + #[inline] pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { - self.inner.dst_offset = dst_offset; + self.dst_offset = dst_offset; self } + #[inline] pub fn extent(mut self, extent: Extent3D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageCopy2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageBlit2 { +pub struct ImageBlit2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_subresource: ImageSubresourceLayers, pub src_offsets: [Offset3D; 2], pub dst_subresource: ImageSubresourceLayers, pub dst_offsets: [Offset3D; 2], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageBlit2 { +impl ::std::default::Default for ImageBlit2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_BLIT_2, @@ -45242,77 +29690,52 @@ impl ::std::default::Default for ImageBlit2 { src_offsets: unsafe { ::std::mem::zeroed() }, dst_subresource: ImageSubresourceLayers::default(), dst_offsets: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl ImageBlit2 { - pub fn builder<'a>() -> ImageBlit2Builder<'a> { - ImageBlit2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageBlit2Builder<'a> { - inner: ImageBlit2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageBlit2 {} -impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> { - type Target = ImageBlit2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageBlit2Builder<'a> { +impl<'a> ImageBlit2<'a> { + #[inline] pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { - self.inner.src_subresource = src_subresource; + self.src_subresource = src_subresource; self } + #[inline] pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self { - self.inner.src_offsets = src_offsets; + self.src_offsets = src_offsets; self } + #[inline] pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { - self.inner.dst_subresource = dst_subresource; + self.dst_subresource = dst_subresource; self } + #[inline] pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self { - self.inner.dst_offsets = dst_offsets; + self.dst_offsets = dst_offsets; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageBlit2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferImageCopy2 { +pub struct BufferImageCopy2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub buffer_offset: DeviceSize, @@ -45321,8 +29744,9 @@ pub struct BufferImageCopy2 { pub image_subresource: ImageSubresourceLayers, pub image_offset: Offset3D, pub image_extent: Extent3D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferImageCopy2 { +impl ::std::default::Default for BufferImageCopy2<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_IMAGE_COPY_2, @@ -45333,85 +29757,62 @@ impl ::std::default::Default for BufferImageCopy2 { image_subresource: ImageSubresourceLayers::default(), image_offset: Offset3D::default(), image_extent: Extent3D::default(), + _marker: PhantomData, } } } -impl BufferImageCopy2 { - pub fn builder<'a>() -> BufferImageCopy2Builder<'a> { - BufferImageCopy2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferImageCopy2Builder<'a> { - inner: BufferImageCopy2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsBufferImageCopy2 {} -impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> { - type Target = BufferImageCopy2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferImageCopy2Builder<'a> { +impl<'a> BufferImageCopy2<'a> { + #[inline] pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self { - self.inner.buffer_offset = buffer_offset; + self.buffer_offset = buffer_offset; self } + #[inline] pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { - self.inner.buffer_row_length = buffer_row_length; + self.buffer_row_length = buffer_row_length; self } + #[inline] pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { - self.inner.buffer_image_height = buffer_image_height; + self.buffer_image_height = buffer_image_height; self } + #[inline] pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { - self.inner.image_subresource = image_subresource; + self.image_subresource = image_subresource; self } + #[inline] pub fn image_offset(mut self, image_offset: Offset3D) -> Self { - self.inner.image_offset = image_offset; + self.image_offset = image_offset; self } + #[inline] pub fn image_extent(mut self, image_extent: Extent3D) -> Self { - self.inner.image_extent = image_extent; + self.image_extent = image_extent; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferImageCopy2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageResolve2 { +pub struct ImageResolve2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_subresource: ImageSubresourceLayers, @@ -45419,8 +29820,9 @@ pub struct ImageResolve2 { pub dst_subresource: ImageSubresourceLayers, pub dst_offset: Offset3D, pub extent: Extent3D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageResolve2 { +impl ::std::default::Default for ImageResolve2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_RESOLVE_2, @@ -45430,74 +29832,51 @@ impl ::std::default::Default for ImageResolve2 { dst_subresource: ImageSubresourceLayers::default(), dst_offset: Offset3D::default(), extent: Extent3D::default(), + _marker: PhantomData, } } } -impl ImageResolve2 { - pub fn builder<'a>() -> ImageResolve2Builder<'a> { - ImageResolve2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageResolve2Builder<'a> { - inner: ImageResolve2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> { - type Target = ImageResolve2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageResolve2Builder<'a> { +impl<'a> ImageResolve2<'a> { + #[inline] pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { - self.inner.src_subresource = src_subresource; + self.src_subresource = src_subresource; self } + #[inline] pub fn src_offset(mut self, src_offset: Offset3D) -> Self { - self.inner.src_offset = src_offset; + self.src_offset = src_offset; self } + #[inline] pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { - self.inner.dst_subresource = dst_subresource; + self.dst_subresource = dst_subresource; self } + #[inline] pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { - self.inner.dst_offset = dst_offset; + self.dst_offset = dst_offset; self } + #[inline] pub fn extent(mut self, extent: Extent3D) -> Self { - self.inner.extent = extent; + self.extent = extent; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageResolve2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyBufferInfo2 { +pub struct CopyBufferInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_buffer: Buffer, pub dst_buffer: Buffer, pub region_count: u32, - pub p_regions: *const BufferCopy2, + pub p_regions: *const BufferCopy2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyBufferInfo2 { +impl ::std::default::Default for CopyBufferInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_BUFFER_INFO_2, @@ -45506,59 +29885,33 @@ impl ::std::default::Default for CopyBufferInfo2 { dst_buffer: Buffer::default(), region_count: u32::default(), p_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CopyBufferInfo2 { - pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> { - CopyBufferInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyBufferInfo2Builder<'a> { - inner: CopyBufferInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> { - type Target = CopyBufferInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyBufferInfo2Builder<'a> { +impl<'a> CopyBufferInfo2<'a> { + #[inline] pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { - self.inner.src_buffer = src_buffer; + self.src_buffer = src_buffer; self } + #[inline] pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { - self.inner.dst_buffer = dst_buffer; + self.dst_buffer = dst_buffer; self } + #[inline] pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self { - self.inner.region_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyBufferInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyImageInfo2 { +pub struct CopyImageInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_image: Image, @@ -45566,9 +29919,10 @@ pub struct CopyImageInfo2 { pub dst_image: Image, pub dst_image_layout: ImageLayout, pub region_count: u32, - pub p_regions: *const ImageCopy2, + pub p_regions: *const ImageCopy2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyImageInfo2 { +impl ::std::default::Default for CopyImageInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_IMAGE_INFO_2, @@ -45579,67 +29933,43 @@ impl ::std::default::Default for CopyImageInfo2 { dst_image_layout: ImageLayout::default(), region_count: u32::default(), p_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CopyImageInfo2 { - pub fn builder<'a>() -> CopyImageInfo2Builder<'a> { - CopyImageInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyImageInfo2Builder<'a> { - inner: CopyImageInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> { - type Target = CopyImageInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyImageInfo2Builder<'a> { +impl<'a> CopyImageInfo2<'a> { + #[inline] pub fn src_image(mut self, src_image: Image) -> Self { - self.inner.src_image = src_image; + self.src_image = src_image; self } + #[inline] pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { - self.inner.src_image_layout = src_image_layout; + self.src_image_layout = src_image_layout; self } + #[inline] pub fn dst_image(mut self, dst_image: Image) -> Self { - self.inner.dst_image = dst_image; + self.dst_image = dst_image; self } + #[inline] pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { - self.inner.dst_image_layout = dst_image_layout; + self.dst_image_layout = dst_image_layout; self } + #[inline] pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self { - self.inner.region_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyImageInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BlitImageInfo2 { +pub struct BlitImageInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_image: Image, @@ -45647,10 +29977,11 @@ pub struct BlitImageInfo2 { pub dst_image: Image, pub dst_image_layout: ImageLayout, pub region_count: u32, - pub p_regions: *const ImageBlit2, + pub p_regions: *const ImageBlit2<'a>, pub filter: Filter, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BlitImageInfo2 { +impl ::std::default::Default for BlitImageInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::BLIT_IMAGE_INFO_2, @@ -45662,80 +29993,58 @@ impl ::std::default::Default for BlitImageInfo2 { region_count: u32::default(), p_regions: ::std::ptr::null(), filter: Filter::default(), + _marker: PhantomData, } } } -impl BlitImageInfo2 { - pub fn builder<'a>() -> BlitImageInfo2Builder<'a> { - BlitImageInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BlitImageInfo2Builder<'a> { - inner: BlitImageInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> { - type Target = BlitImageInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BlitImageInfo2Builder<'a> { +impl<'a> BlitImageInfo2<'a> { + #[inline] pub fn src_image(mut self, src_image: Image) -> Self { - self.inner.src_image = src_image; + self.src_image = src_image; self } + #[inline] pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { - self.inner.src_image_layout = src_image_layout; + self.src_image_layout = src_image_layout; self } + #[inline] pub fn dst_image(mut self, dst_image: Image) -> Self { - self.inner.dst_image = dst_image; + self.dst_image = dst_image; self } + #[inline] pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { - self.inner.dst_image_layout = dst_image_layout; + self.dst_image_layout = dst_image_layout; self } + #[inline] pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self { - self.inner.region_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } + #[inline] pub fn filter(mut self, filter: Filter) -> Self { - self.inner.filter = filter; + self.filter = filter; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BlitImageInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyBufferToImageInfo2 { +pub struct CopyBufferToImageInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_buffer: Buffer, pub dst_image: Image, pub dst_image_layout: ImageLayout, pub region_count: u32, - pub p_regions: *const BufferImageCopy2, + pub p_regions: *const BufferImageCopy2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyBufferToImageInfo2 { +impl ::std::default::Default for CopyBufferToImageInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2, @@ -45745,72 +30054,48 @@ impl ::std::default::Default for CopyBufferToImageInfo2 { dst_image_layout: ImageLayout::default(), region_count: u32::default(), p_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CopyBufferToImageInfo2 { - pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> { - CopyBufferToImageInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyBufferToImageInfo2Builder<'a> { - inner: CopyBufferToImageInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> { - type Target = CopyBufferToImageInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyBufferToImageInfo2Builder<'a> { +impl<'a> CopyBufferToImageInfo2<'a> { + #[inline] pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { - self.inner.src_buffer = src_buffer; + self.src_buffer = src_buffer; self } + #[inline] pub fn dst_image(mut self, dst_image: Image) -> Self { - self.inner.dst_image = dst_image; + self.dst_image = dst_image; self } + #[inline] pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { - self.inner.dst_image_layout = dst_image_layout; + self.dst_image_layout = dst_image_layout; self } + #[inline] pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self { - self.inner.region_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyBufferToImageInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CopyImageToBufferInfo2 { +pub struct CopyImageToBufferInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_image: Image, pub src_image_layout: ImageLayout, pub dst_buffer: Buffer, pub region_count: u32, - pub p_regions: *const BufferImageCopy2, + pub p_regions: *const BufferImageCopy2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CopyImageToBufferInfo2 { +impl ::std::default::Default for CopyImageToBufferInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2, @@ -45820,63 +30105,38 @@ impl ::std::default::Default for CopyImageToBufferInfo2 { dst_buffer: Buffer::default(), region_count: u32::default(), p_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CopyImageToBufferInfo2 { - pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> { - CopyImageToBufferInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CopyImageToBufferInfo2Builder<'a> { - inner: CopyImageToBufferInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> { - type Target = CopyImageToBufferInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CopyImageToBufferInfo2Builder<'a> { +impl<'a> CopyImageToBufferInfo2<'a> { + #[inline] pub fn src_image(mut self, src_image: Image) -> Self { - self.inner.src_image = src_image; + self.src_image = src_image; self } + #[inline] pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { - self.inner.src_image_layout = src_image_layout; + self.src_image_layout = src_image_layout; self } + #[inline] pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { - self.inner.dst_buffer = dst_buffer; + self.dst_buffer = dst_buffer; self } + #[inline] pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self { - self.inner.region_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CopyImageToBufferInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ResolveImageInfo2 { +pub struct ResolveImageInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_image: Image, @@ -45884,9 +30144,10 @@ pub struct ResolveImageInfo2 { pub dst_image: Image, pub dst_image_layout: ImageLayout, pub region_count: u32, - pub p_regions: *const ImageResolve2, + pub p_regions: *const ImageResolve2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ResolveImageInfo2 { +impl ::std::default::Default for ResolveImageInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::RESOLVE_IMAGE_INFO_2, @@ -45897,274 +30158,166 @@ impl ::std::default::Default for ResolveImageInfo2 { dst_image_layout: ImageLayout::default(), region_count: u32::default(), p_regions: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ResolveImageInfo2 { - pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> { - ResolveImageInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ResolveImageInfo2Builder<'a> { - inner: ResolveImageInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> { - type Target = ResolveImageInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ResolveImageInfo2Builder<'a> { +impl<'a> ResolveImageInfo2<'a> { + #[inline] pub fn src_image(mut self, src_image: Image) -> Self { - self.inner.src_image = src_image; + self.src_image = src_image; self } + #[inline] pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { - self.inner.src_image_layout = src_image_layout; + self.src_image_layout = src_image_layout; self } + #[inline] pub fn dst_image(mut self, dst_image: Image) -> Self { - self.inner.dst_image = dst_image; + self.dst_image = dst_image; self } + #[inline] pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { - self.inner.dst_image_layout = dst_image_layout; + self.dst_image_layout = dst_image_layout; self } + #[inline] pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self { - self.inner.region_count = regions.len() as _; - self.inner.p_regions = regions.as_ptr(); + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ResolveImageInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_image_int64_atomics: Bool32, pub sparse_image_int64_atomics: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { +impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, p_next: ::std::ptr::null_mut(), shader_image_int64_atomics: Bool32::default(), sparse_image_int64_atomics: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { - PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { - inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> { + #[inline] pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self { - self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into(); + self.shader_image_int64_atomics = shader_image_int64_atomics.into(); self } + #[inline] pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self { - self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into(); + self.sparse_image_int64_atomics = sparse_image_int64_atomics.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FragmentShadingRateAttachmentInfoKHR { +pub struct FragmentShadingRateAttachmentInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_fragment_shading_rate_attachment: *const AttachmentReference2, + pub p_fragment_shading_rate_attachment: *const AttachmentReference2<'a>, pub shading_rate_attachment_texel_size: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR { +impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, p_next: ::std::ptr::null(), p_fragment_shading_rate_attachment: ::std::ptr::null(), shading_rate_attachment_texel_size: Extent2D::default(), + _marker: PhantomData, } } } -impl FragmentShadingRateAttachmentInfoKHR { - pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { - FragmentShadingRateAttachmentInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> { - inner: FragmentShadingRateAttachmentInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {} -unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {} -impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { - type Target = FragmentShadingRateAttachmentInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR<'_> {} +impl<'a> FragmentShadingRateAttachmentInfoKHR<'a> { + #[inline] pub fn fragment_shading_rate_attachment( mut self, - fragment_shading_rate_attachment: &'a AttachmentReference2, + fragment_shading_rate_attachment: &'a AttachmentReference2<'a>, ) -> Self { - self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment; + self.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment; self } + #[inline] pub fn shading_rate_attachment_texel_size( mut self, shading_rate_attachment_texel_size: Extent2D, ) -> Self { - self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineFragmentShadingRateStateCreateInfoKHR { +pub struct PipelineFragmentShadingRateStateCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub fragment_size: Extent2D, pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR { +impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, p_next: ::std::ptr::null(), fragment_size: Extent2D::default(), combiner_ops: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PipelineFragmentShadingRateStateCreateInfoKHR { - pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { - PipelineFragmentShadingRateStateCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { - inner: PipelineFragmentShadingRateStateCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsGraphicsPipelineCreateInfo - for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_> + for PipelineFragmentShadingRateStateCreateInfoKHR<'_> { } -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {} -impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { - type Target = PipelineFragmentShadingRateStateCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { +impl<'a> PipelineFragmentShadingRateStateCreateInfoKHR<'a> { + #[inline] pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self { - self.inner.fragment_size = fragment_size; + self.fragment_size = fragment_size; self } + #[inline] pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self { - self.inner.combiner_ops = combiner_ops; + self.combiner_ops = combiner_ops; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR { +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub pipeline_fragment_shading_rate: Bool32, pub primitive_fragment_shading_rate: Bool32, pub attachment_fragment_shading_rate: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR { +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, @@ -46172,71 +30325,40 @@ impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR { pipeline_fragment_shading_rate: Bool32::default(), primitive_fragment_shading_rate: Bool32::default(), attachment_fragment_shading_rate: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShadingRateFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { - PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceFragmentShadingRateFeaturesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> { + #[inline] pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self { - self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into(); + self.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into(); self } + #[inline] pub fn primitive_fragment_shading_rate( mut self, primitive_fragment_shading_rate: bool, ) -> Self { - self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into(); + self.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into(); self } + #[inline] pub fn attachment_fragment_shading_rate( mut self, attachment_fragment_shading_rate: bool, ) -> Self { - self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into(); + self.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR { +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_fragment_shading_rate_attachment_texel_size: Extent2D, @@ -46256,8 +30378,9 @@ pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR { pub fragment_shading_rate_with_fragment_shader_interlock: Bool32, pub fragment_shading_rate_with_custom_sample_locations: Bool32, pub fragment_shading_rate_strict_multiply_combiner: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR { +impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, @@ -46279,312 +30402,235 @@ impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(), fragment_shading_rate_with_custom_sample_locations: Bool32::default(), fragment_shading_rate_strict_multiply_combiner: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShadingRatePropertiesKHR { - pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { - PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { - inner: PhysicalDeviceFragmentShadingRatePropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_> + for PhysicalDeviceFragmentShadingRatePropertiesKHR<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { - type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { +impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> { + #[inline] pub fn min_fragment_shading_rate_attachment_texel_size( mut self, min_fragment_shading_rate_attachment_texel_size: Extent2D, ) -> Self { - self.inner.min_fragment_shading_rate_attachment_texel_size = + self.min_fragment_shading_rate_attachment_texel_size = min_fragment_shading_rate_attachment_texel_size; self } + #[inline] pub fn max_fragment_shading_rate_attachment_texel_size( mut self, max_fragment_shading_rate_attachment_texel_size: Extent2D, ) -> Self { - self.inner.max_fragment_shading_rate_attachment_texel_size = + self.max_fragment_shading_rate_attachment_texel_size = max_fragment_shading_rate_attachment_texel_size; self } + #[inline] pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio( mut self, max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, ) -> Self { - self.inner - .max_fragment_shading_rate_attachment_texel_size_aspect_ratio = + self.max_fragment_shading_rate_attachment_texel_size_aspect_ratio = max_fragment_shading_rate_attachment_texel_size_aspect_ratio; self } + #[inline] pub fn primitive_fragment_shading_rate_with_multiple_viewports( mut self, primitive_fragment_shading_rate_with_multiple_viewports: bool, ) -> Self { - self.inner - .primitive_fragment_shading_rate_with_multiple_viewports = + self.primitive_fragment_shading_rate_with_multiple_viewports = primitive_fragment_shading_rate_with_multiple_viewports.into(); self } + #[inline] pub fn layered_shading_rate_attachments( mut self, layered_shading_rate_attachments: bool, ) -> Self { - self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into(); + self.layered_shading_rate_attachments = layered_shading_rate_attachments.into(); self } + #[inline] pub fn fragment_shading_rate_non_trivial_combiner_ops( mut self, fragment_shading_rate_non_trivial_combiner_ops: bool, ) -> Self { - self.inner.fragment_shading_rate_non_trivial_combiner_ops = + self.fragment_shading_rate_non_trivial_combiner_ops = fragment_shading_rate_non_trivial_combiner_ops.into(); self } + #[inline] pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self { - self.inner.max_fragment_size = max_fragment_size; + self.max_fragment_size = max_fragment_size; self } + #[inline] pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self { - self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio; + self.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio; self } + #[inline] pub fn max_fragment_shading_rate_coverage_samples( mut self, max_fragment_shading_rate_coverage_samples: u32, ) -> Self { - self.inner.max_fragment_shading_rate_coverage_samples = + self.max_fragment_shading_rate_coverage_samples = max_fragment_shading_rate_coverage_samples; self } + #[inline] pub fn max_fragment_shading_rate_rasterization_samples( mut self, max_fragment_shading_rate_rasterization_samples: SampleCountFlags, ) -> Self { - self.inner.max_fragment_shading_rate_rasterization_samples = + self.max_fragment_shading_rate_rasterization_samples = max_fragment_shading_rate_rasterization_samples; self } + #[inline] pub fn fragment_shading_rate_with_shader_depth_stencil_writes( mut self, fragment_shading_rate_with_shader_depth_stencil_writes: bool, ) -> Self { - self.inner - .fragment_shading_rate_with_shader_depth_stencil_writes = + self.fragment_shading_rate_with_shader_depth_stencil_writes = fragment_shading_rate_with_shader_depth_stencil_writes.into(); self } + #[inline] pub fn fragment_shading_rate_with_sample_mask( mut self, fragment_shading_rate_with_sample_mask: bool, ) -> Self { - self.inner.fragment_shading_rate_with_sample_mask = - fragment_shading_rate_with_sample_mask.into(); + self.fragment_shading_rate_with_sample_mask = fragment_shading_rate_with_sample_mask.into(); self } + #[inline] pub fn fragment_shading_rate_with_shader_sample_mask( mut self, fragment_shading_rate_with_shader_sample_mask: bool, ) -> Self { - self.inner.fragment_shading_rate_with_shader_sample_mask = + self.fragment_shading_rate_with_shader_sample_mask = fragment_shading_rate_with_shader_sample_mask.into(); self } + #[inline] pub fn fragment_shading_rate_with_conservative_rasterization( mut self, fragment_shading_rate_with_conservative_rasterization: bool, ) -> Self { - self.inner - .fragment_shading_rate_with_conservative_rasterization = + self.fragment_shading_rate_with_conservative_rasterization = fragment_shading_rate_with_conservative_rasterization.into(); self } + #[inline] pub fn fragment_shading_rate_with_fragment_shader_interlock( mut self, fragment_shading_rate_with_fragment_shader_interlock: bool, ) -> Self { - self.inner - .fragment_shading_rate_with_fragment_shader_interlock = + self.fragment_shading_rate_with_fragment_shader_interlock = fragment_shading_rate_with_fragment_shader_interlock.into(); self } + #[inline] pub fn fragment_shading_rate_with_custom_sample_locations( mut self, fragment_shading_rate_with_custom_sample_locations: bool, ) -> Self { - self.inner - .fragment_shading_rate_with_custom_sample_locations = + self.fragment_shading_rate_with_custom_sample_locations = fragment_shading_rate_with_custom_sample_locations.into(); self } + #[inline] pub fn fragment_shading_rate_strict_multiply_combiner( mut self, fragment_shading_rate_strict_multiply_combiner: bool, ) -> Self { - self.inner.fragment_shading_rate_strict_multiply_combiner = + self.fragment_shading_rate_strict_multiply_combiner = fragment_shading_rate_strict_multiply_combiner.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShadingRateKHR { +pub struct PhysicalDeviceFragmentShadingRateKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub sample_counts: SampleCountFlags, pub fragment_size: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR { +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, p_next: ::std::ptr::null_mut(), sample_counts: SampleCountFlags::default(), fragment_size: Extent2D::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShadingRateKHR { - pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { - PhysicalDeviceFragmentShadingRateKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { - inner: PhysicalDeviceFragmentShadingRateKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { - type Target = PhysicalDeviceFragmentShadingRateKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { +impl<'a> PhysicalDeviceFragmentShadingRateKHR<'a> { + #[inline] pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self { - self.inner.sample_counts = sample_counts; + self.sample_counts = sample_counts; self } + #[inline] pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self { - self.inner.fragment_size = fragment_size; + self.fragment_size = fragment_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderTerminateInvocationFeatures { +pub struct PhysicalDeviceShaderTerminateInvocationFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_terminate_invocation: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures { +impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, p_next: ::std::ptr::null_mut(), shader_terminate_invocation: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderTerminateInvocationFeatures { - pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { - PhysicalDeviceShaderTerminateInvocationFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { - inner: PhysicalDeviceShaderTerminateInvocationFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderTerminateInvocationFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures<'_> {} +impl<'a> PhysicalDeviceShaderTerminateInvocationFeatures<'a> { + #[inline] pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self { - self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self.shader_terminate_invocation = shader_terminate_invocation.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub fragment_shading_rate_enums: Bool32, pub supersample_fragment_shading_rates: Bool32, pub no_invocation_fragment_shading_rates: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, @@ -46592,148 +30638,86 @@ impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesN fragment_shading_rate_enums: Bool32::default(), supersample_fragment_shading_rates: Bool32::default(), no_invocation_fragment_shading_rates: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { - PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { - inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'_> {} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> { + #[inline] pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self { - self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into(); + self.fragment_shading_rate_enums = fragment_shading_rate_enums.into(); self } + #[inline] pub fn supersample_fragment_shading_rates( mut self, supersample_fragment_shading_rates: bool, ) -> Self { - self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into(); + self.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into(); self } + #[inline] pub fn no_invocation_fragment_shading_rates( mut self, no_invocation_fragment_shading_rates: bool, ) -> Self { - self.inner.no_invocation_fragment_shading_rates = - no_invocation_fragment_shading_rates.into(); + self.no_invocation_fragment_shading_rates = no_invocation_fragment_shading_rates.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_fragment_shading_rate_invocation_count: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, p_next: ::std::ptr::null_mut(), max_fragment_shading_rate_invocation_count: SampleCountFlags::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { - pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { - PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { - inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_> + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV -{ -} -impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { - type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { +impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> { + #[inline] pub fn max_fragment_shading_rate_invocation_count( mut self, max_fragment_shading_rate_invocation_count: SampleCountFlags, ) -> Self { - self.inner.max_fragment_shading_rate_invocation_count = + self.max_fragment_shading_rate_invocation_count = max_fragment_shading_rate_invocation_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV { +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub shading_rate_type: FragmentShadingRateTypeNV, pub shading_rate: FragmentShadingRateNV, pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV { +impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, @@ -46741,70 +30725,44 @@ impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoN shading_rate_type: FragmentShadingRateTypeNV::default(), shading_rate: FragmentShadingRateNV::default(), combiner_ops: unsafe { ::std::mem::zeroed() }, + _marker: PhantomData, } } } -impl PipelineFragmentShadingRateEnumStateCreateInfoNV { - pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { - PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { - inner: PipelineFragmentShadingRateEnumStateCreateInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsGraphicsPipelineCreateInfo - for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_> + for PipelineFragmentShadingRateEnumStateCreateInfoNV<'_> { } -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {} -impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { - type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { +impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> { + #[inline] pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self { - self.inner.shading_rate_type = shading_rate_type; + self.shading_rate_type = shading_rate_type; self } + #[inline] pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self { - self.inner.shading_rate = shading_rate; + self.shading_rate = shading_rate; self } + #[inline] pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self { - self.inner.combiner_ops = combiner_ops; + self.combiner_ops = combiner_ops; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureBuildSizesInfoKHR { +pub struct AccelerationStructureBuildSizesInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub acceleration_structure_size: DeviceSize, pub update_scratch_size: DeviceSize, pub build_scratch_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR { +impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR, @@ -46812,498 +30770,255 @@ impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR { acceleration_structure_size: DeviceSize::default(), update_scratch_size: DeviceSize::default(), build_scratch_size: DeviceSize::default(), + _marker: PhantomData, } } } -impl AccelerationStructureBuildSizesInfoKHR { - pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { - AccelerationStructureBuildSizesInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> { - inner: AccelerationStructureBuildSizesInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { - type Target = AccelerationStructureBuildSizesInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { +impl<'a> AccelerationStructureBuildSizesInfoKHR<'a> { + #[inline] pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self { - self.inner.acceleration_structure_size = acceleration_structure_size; + self.acceleration_structure_size = acceleration_structure_size; self } + #[inline] pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self { - self.inner.update_scratch_size = update_scratch_size; + self.update_scratch_size = update_scratch_size; self } + #[inline] pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self { - self.inner.build_scratch_size = build_scratch_size; + self.build_scratch_size = build_scratch_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub mutable_descriptor_type: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { +impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, p_next: ::std::ptr::null_mut(), mutable_descriptor_type: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { - pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { - PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { - inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_> + for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {} -impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { - type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE<'_> {} +impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE<'a> { + #[inline] pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self { - self.inner.mutable_descriptor_type = mutable_descriptor_type.into(); + self.mutable_descriptor_type = mutable_descriptor_type.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MutableDescriptorTypeListVALVE { +pub struct MutableDescriptorTypeListVALVE<'a> { pub descriptor_type_count: u32, pub p_descriptor_types: *const DescriptorType, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MutableDescriptorTypeListVALVE { +impl ::std::default::Default for MutableDescriptorTypeListVALVE<'_> { fn default() -> Self { Self { descriptor_type_count: u32::default(), p_descriptor_types: ::std::ptr::null(), + _marker: PhantomData, } } } -impl MutableDescriptorTypeListVALVE { - pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> { - MutableDescriptorTypeListVALVEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MutableDescriptorTypeListVALVEBuilder<'a> { - inner: MutableDescriptorTypeListVALVE, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> { - type Target = MutableDescriptorTypeListVALVE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> { +impl<'a> MutableDescriptorTypeListVALVE<'a> { + #[inline] pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self { - self.inner.descriptor_type_count = descriptor_types.len() as _; - self.inner.p_descriptor_types = descriptor_types.as_ptr(); + self.descriptor_type_count = descriptor_types.len() as _; + self.p_descriptor_types = descriptor_types.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MutableDescriptorTypeListVALVE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MutableDescriptorTypeCreateInfoVALVE { +pub struct MutableDescriptorTypeCreateInfoVALVE<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub mutable_descriptor_type_list_count: u32, - pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE, + pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE { +impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE<'_> { fn default() -> Self { Self { s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, p_next: ::std::ptr::null(), mutable_descriptor_type_list_count: u32::default(), p_mutable_descriptor_type_lists: ::std::ptr::null(), + _marker: PhantomData, } } } -impl MutableDescriptorTypeCreateInfoVALVE { - pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { - MutableDescriptorTypeCreateInfoVALVEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { - inner: MutableDescriptorTypeCreateInfoVALVE, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsDescriptorSetLayoutCreateInfo - for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> -{ -} -unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {} -unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {} -unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {} -impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { - type Target = MutableDescriptorTypeCreateInfoVALVE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE<'_> {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE<'_> {} +impl<'a> MutableDescriptorTypeCreateInfoVALVE<'a> { + #[inline] pub fn mutable_descriptor_type_lists( mut self, mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE], ) -> Self { - self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _; - self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr(); + self.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _; + self.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDepthClipControlFeaturesEXT { +pub struct PhysicalDeviceDepthClipControlFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub depth_clip_control: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, p_next: ::std::ptr::null_mut(), depth_clip_control: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDepthClipControlFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { - PhysicalDeviceDepthClipControlFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceDepthClipControlFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceDepthClipControlFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDepthClipControlFeaturesEXT<'a> { + #[inline] pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self { - self.inner.depth_clip_control = depth_clip_control.into(); + self.depth_clip_control = depth_clip_control.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineViewportDepthClipControlCreateInfoEXT { +pub struct PipelineViewportDepthClipControlCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub negative_one_to_one: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT { +impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, p_next: ::std::ptr::null(), negative_one_to_one: Bool32::default(), + _marker: PhantomData, } } } -impl PipelineViewportDepthClipControlCreateInfoEXT { - pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { - PipelineViewportDepthClipControlCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { - inner: PipelineViewportDepthClipControlCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_> + for PipelineViewportDepthClipControlCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineViewportStateCreateInfo - for PipelineViewportDepthClipControlCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { - type Target = PipelineViewportDepthClipControlCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { +impl<'a> PipelineViewportDepthClipControlCreateInfoEXT<'a> { + #[inline] pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self { - self.inner.negative_one_to_one = negative_one_to_one.into(); + self.negative_one_to_one = negative_one_to_one.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT { +pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub vertex_input_dynamic_state: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, p_next: ::std::ptr::null_mut(), vertex_input_dynamic_state: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { - PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> + for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> { + #[inline] pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self { - self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into(); + self.vertex_input_dynamic_state = vertex_input_dynamic_state.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV { +pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub external_memory_rdma: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV { +impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, p_next: ::std::ptr::null_mut(), external_memory_rdma: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceExternalMemoryRDMAFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { - PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { - inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'_> {} +impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> { + #[inline] pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self { - self.inner.external_memory_rdma = external_memory_rdma.into(); + self.external_memory_rdma = external_memory_rdma.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VertexInputBindingDescription2EXT { +pub struct VertexInputBindingDescription2EXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub binding: u32, pub stride: u32, pub input_rate: VertexInputRate, pub divisor: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VertexInputBindingDescription2EXT { +impl ::std::default::Default for VertexInputBindingDescription2EXT<'_> { fn default() -> Self { Self { s_type: StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, @@ -47312,70 +31027,46 @@ impl ::std::default::Default for VertexInputBindingDescription2EXT { stride: u32::default(), input_rate: VertexInputRate::default(), divisor: u32::default(), + _marker: PhantomData, } } } -impl VertexInputBindingDescription2EXT { - pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> { - VertexInputBindingDescription2EXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VertexInputBindingDescription2EXTBuilder<'a> { - inner: VertexInputBindingDescription2EXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> { - type Target = VertexInputBindingDescription2EXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VertexInputBindingDescription2EXTBuilder<'a> { +impl<'a> VertexInputBindingDescription2EXT<'a> { + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } + #[inline] pub fn stride(mut self, stride: u32) -> Self { - self.inner.stride = stride; + self.stride = stride; self } + #[inline] pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self { - self.inner.input_rate = input_rate; + self.input_rate = input_rate; self } + #[inline] pub fn divisor(mut self, divisor: u32) -> Self { - self.inner.divisor = divisor; + self.divisor = divisor; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VertexInputBindingDescription2EXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VertexInputAttributeDescription2EXT { +pub struct VertexInputAttributeDescription2EXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub location: u32, pub binding: u32, pub format: Format, pub offset: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VertexInputAttributeDescription2EXT { +impl ::std::default::Default for VertexInputAttributeDescription2EXT<'_> { fn default() -> Self { Self { s_type: StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, @@ -47384,193 +31075,106 @@ impl ::std::default::Default for VertexInputAttributeDescription2EXT { binding: u32::default(), format: Format::default(), offset: u32::default(), + _marker: PhantomData, } } } -impl VertexInputAttributeDescription2EXT { - pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> { - VertexInputAttributeDescription2EXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VertexInputAttributeDescription2EXTBuilder<'a> { - inner: VertexInputAttributeDescription2EXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> { - type Target = VertexInputAttributeDescription2EXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> { +impl<'a> VertexInputAttributeDescription2EXT<'a> { + #[inline] pub fn location(mut self, location: u32) -> Self { - self.inner.location = location; + self.location = location; self } + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn offset(mut self, offset: u32) -> Self { - self.inner.offset = offset; + self.offset = offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VertexInputAttributeDescription2EXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceColorWriteEnableFeaturesEXT { +pub struct PhysicalDeviceColorWriteEnableFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub color_write_enable: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, p_next: ::std::ptr::null_mut(), color_write_enable: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceColorWriteEnableFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { - PhysicalDeviceColorWriteEnableFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceColorWriteEnableFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceColorWriteEnableFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXT<'a> { + #[inline] pub fn color_write_enable(mut self, color_write_enable: bool) -> Self { - self.inner.color_write_enable = color_write_enable.into(); + self.color_write_enable = color_write_enable.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineColorWriteCreateInfoEXT { +pub struct PipelineColorWriteCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub attachment_count: u32, pub p_color_write_enables: *const Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineColorWriteCreateInfoEXT { +impl ::std::default::Default for PipelineColorWriteCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), attachment_count: u32::default(), p_color_write_enables: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PipelineColorWriteCreateInfoEXT { - pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> { - PipelineColorWriteCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> { - inner: PipelineColorWriteCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPipelineColorBlendStateCreateInfo - for PipelineColorWriteCreateInfoEXTBuilder<'_> -{ -} -unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT {} -impl<'a> ::std::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> { - type Target = PipelineColorWriteCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT<'_> {} +impl<'a> PipelineColorWriteCreateInfoEXT<'a> { + #[inline] pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self { - self.inner.attachment_count = color_write_enables.len() as _; - self.inner.p_color_write_enables = color_write_enables.as_ptr(); + self.attachment_count = color_write_enables.len() as _; + self.p_color_write_enables = color_write_enables.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineColorWriteCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryBarrier2 { +pub struct MemoryBarrier2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_stage_mask: PipelineStageFlags2, pub src_access_mask: AccessFlags2, pub dst_stage_mask: PipelineStageFlags2, pub dst_access_mask: AccessFlags2, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryBarrier2 { +impl ::std::default::Default for MemoryBarrier2<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_BARRIER_2, @@ -47579,64 +31183,38 @@ impl ::std::default::Default for MemoryBarrier2 { src_access_mask: AccessFlags2::default(), dst_stage_mask: PipelineStageFlags2::default(), dst_access_mask: AccessFlags2::default(), + _marker: PhantomData, } } } -impl MemoryBarrier2 { - pub fn builder<'a>() -> MemoryBarrier2Builder<'a> { - MemoryBarrier2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryBarrier2Builder<'a> { - inner: MemoryBarrier2, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {} -unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {} -impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> { - type Target = MemoryBarrier2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryBarrier2Builder<'a> { +unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2<'_> {} +impl<'a> MemoryBarrier2<'a> { + #[inline] pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { - self.inner.src_stage_mask = src_stage_mask; + self.src_stage_mask = src_stage_mask; self } + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { - self.inner.dst_stage_mask = dst_stage_mask; + self.dst_stage_mask = dst_stage_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryBarrier2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageMemoryBarrier2 { +pub struct ImageMemoryBarrier2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_stage_mask: PipelineStageFlags2, @@ -47649,8 +31227,9 @@ pub struct ImageMemoryBarrier2 { pub dst_queue_family_index: u32, pub image: Image, pub subresource_range: ImageSubresourceRange, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageMemoryBarrier2 { +impl ::std::default::Default for ImageMemoryBarrier2<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_MEMORY_BARRIER_2, @@ -47665,101 +31244,82 @@ impl ::std::default::Default for ImageMemoryBarrier2 { dst_queue_family_index: u32::default(), image: Image::default(), subresource_range: ImageSubresourceRange::default(), + _marker: PhantomData, } } } -impl ImageMemoryBarrier2 { - pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> { - ImageMemoryBarrier2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageMemoryBarrier2Builder<'a> { - inner: ImageMemoryBarrier2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsImageMemoryBarrier2 {} -impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> { - type Target = ImageMemoryBarrier2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageMemoryBarrier2Builder<'a> { +impl<'a> ImageMemoryBarrier2<'a> { + #[inline] pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { - self.inner.src_stage_mask = src_stage_mask; + self.src_stage_mask = src_stage_mask; self } + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { - self.inner.dst_stage_mask = dst_stage_mask; + self.dst_stage_mask = dst_stage_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } + #[inline] pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { - self.inner.old_layout = old_layout; + self.old_layout = old_layout; self } + #[inline] pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { - self.inner.new_layout = new_layout; + self.new_layout = new_layout; self } + #[inline] pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { - self.inner.src_queue_family_index = src_queue_family_index; + self.src_queue_family_index = src_queue_family_index; self } + #[inline] pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { - self.inner.dst_queue_family_index = dst_queue_family_index; + self.dst_queue_family_index = dst_queue_family_index; self } + #[inline] pub fn image(mut self, image: Image) -> Self { - self.inner.image = image; + self.image = image; self } + #[inline] pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { - self.inner.subresource_range = subresource_range; + self.subresource_range = subresource_range; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageMemoryBarrier2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferMemoryBarrier2 { +pub struct BufferMemoryBarrier2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub src_stage_mask: PipelineStageFlags2, @@ -47771,8 +31331,9 @@ pub struct BufferMemoryBarrier2 { pub buffer: Buffer, pub offset: DeviceSize, pub size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferMemoryBarrier2 { +impl ::std::default::Default for BufferMemoryBarrier2<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_MEMORY_BARRIER_2, @@ -47786,93 +31347,74 @@ impl ::std::default::Default for BufferMemoryBarrier2 { buffer: Buffer::default(), offset: DeviceSize::default(), size: DeviceSize::default(), + _marker: PhantomData, } } } -impl BufferMemoryBarrier2 { - pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> { - BufferMemoryBarrier2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferMemoryBarrier2Builder<'a> { - inner: BufferMemoryBarrier2, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> { - type Target = BufferMemoryBarrier2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferMemoryBarrier2Builder<'a> { +impl<'a> BufferMemoryBarrier2<'a> { + #[inline] pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { - self.inner.src_stage_mask = src_stage_mask; + self.src_stage_mask = src_stage_mask; self } + #[inline] pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { - self.inner.src_access_mask = src_access_mask; + self.src_access_mask = src_access_mask; self } + #[inline] pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { - self.inner.dst_stage_mask = dst_stage_mask; + self.dst_stage_mask = dst_stage_mask; self } + #[inline] pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { - self.inner.dst_access_mask = dst_access_mask; + self.dst_access_mask = dst_access_mask; self } + #[inline] pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { - self.inner.src_queue_family_index = src_queue_family_index; + self.src_queue_family_index = src_queue_family_index; self } + #[inline] pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { - self.inner.dst_queue_family_index = dst_queue_family_index; + self.dst_queue_family_index = dst_queue_family_index; self } + #[inline] pub fn buffer(mut self, buffer: Buffer) -> Self { - self.inner.buffer = buffer; + self.buffer = buffer; self } + #[inline] pub fn offset(mut self, offset: DeviceSize) -> Self { - self.inner.offset = offset; + self.offset = offset; self } + #[inline] pub fn size(mut self, size: DeviceSize) -> Self { - self.inner.size = size; + self.size = size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferMemoryBarrier2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DependencyInfo { +pub struct DependencyInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub dependency_flags: DependencyFlags, pub memory_barrier_count: u32, - pub p_memory_barriers: *const MemoryBarrier2, + pub p_memory_barriers: *const MemoryBarrier2<'a>, pub buffer_memory_barrier_count: u32, - pub p_buffer_memory_barriers: *const BufferMemoryBarrier2, + pub p_buffer_memory_barriers: *const BufferMemoryBarrier2<'a>, pub image_memory_barrier_count: u32, - pub p_image_memory_barriers: *const ImageMemoryBarrier2, + pub p_image_memory_barriers: *const ImageMemoryBarrier2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DependencyInfo { +impl ::std::default::Default for DependencyInfo<'_> { fn default() -> Self { Self { s_type: StructureType::DEPENDENCY_INFO, @@ -47884,79 +31426,55 @@ impl ::std::default::Default for DependencyInfo { p_buffer_memory_barriers: ::std::ptr::null(), image_memory_barrier_count: u32::default(), p_image_memory_barriers: ::std::ptr::null(), + _marker: PhantomData, } } } -impl DependencyInfo { - pub fn builder<'a>() -> DependencyInfoBuilder<'a> { - DependencyInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DependencyInfoBuilder<'a> { - inner: DependencyInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> { - type Target = DependencyInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DependencyInfoBuilder<'a> { +impl<'a> DependencyInfo<'a> { + #[inline] pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { - self.inner.dependency_flags = dependency_flags; + self.dependency_flags = dependency_flags; self } + #[inline] pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self { - self.inner.memory_barrier_count = memory_barriers.len() as _; - self.inner.p_memory_barriers = memory_barriers.as_ptr(); + self.memory_barrier_count = memory_barriers.len() as _; + self.p_memory_barriers = memory_barriers.as_ptr(); self } + #[inline] pub fn buffer_memory_barriers( mut self, buffer_memory_barriers: &'a [BufferMemoryBarrier2], ) -> Self { - self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _; - self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr(); + self.buffer_memory_barrier_count = buffer_memory_barriers.len() as _; + self.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr(); self } + #[inline] pub fn image_memory_barriers( mut self, image_memory_barriers: &'a [ImageMemoryBarrier2], ) -> Self { - self.inner.image_memory_barrier_count = image_memory_barriers.len() as _; - self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr(); + self.image_memory_barrier_count = image_memory_barriers.len() as _; + self.p_image_memory_barriers = image_memory_barriers.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DependencyInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SemaphoreSubmitInfo { +pub struct SemaphoreSubmitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub semaphore: Semaphore, pub value: u64, pub stage_mask: PipelineStageFlags2, pub device_index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SemaphoreSubmitInfo { +impl ::std::default::Default for SemaphoreSubmitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::SEMAPHORE_SUBMIT_INFO, @@ -47965,133 +31483,83 @@ impl ::std::default::Default for SemaphoreSubmitInfo { value: u64::default(), stage_mask: PipelineStageFlags2::default(), device_index: u32::default(), + _marker: PhantomData, } } } -impl SemaphoreSubmitInfo { - pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> { - SemaphoreSubmitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SemaphoreSubmitInfoBuilder<'a> { - inner: SemaphoreSubmitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> { - type Target = SemaphoreSubmitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SemaphoreSubmitInfoBuilder<'a> { +impl<'a> SemaphoreSubmitInfo<'a> { + #[inline] pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.inner.semaphore = semaphore; + self.semaphore = semaphore; self } + #[inline] pub fn value(mut self, value: u64) -> Self { - self.inner.value = value; + self.value = value; self } + #[inline] pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self { - self.inner.stage_mask = stage_mask; + self.stage_mask = stage_mask; self } + #[inline] pub fn device_index(mut self, device_index: u32) -> Self { - self.inner.device_index = device_index; + self.device_index = device_index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SemaphoreSubmitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferSubmitInfo { +pub struct CommandBufferSubmitInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub command_buffer: CommandBuffer, pub device_mask: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferSubmitInfo { +impl ::std::default::Default for CommandBufferSubmitInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_SUBMIT_INFO, p_next: ::std::ptr::null(), command_buffer: CommandBuffer::default(), device_mask: u32::default(), + _marker: PhantomData, } } } -impl CommandBufferSubmitInfo { - pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> { - CommandBufferSubmitInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferSubmitInfoBuilder<'a> { - inner: CommandBufferSubmitInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> { - type Target = CommandBufferSubmitInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferSubmitInfoBuilder<'a> { +impl<'a> CommandBufferSubmitInfo<'a> { + #[inline] pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self { - self.inner.command_buffer = command_buffer; + self.command_buffer = command_buffer; self } + #[inline] pub fn device_mask(mut self, device_mask: u32) -> Self { - self.inner.device_mask = device_mask; + self.device_mask = device_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferSubmitInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SubmitInfo2 { +pub struct SubmitInfo2<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: SubmitFlags, pub wait_semaphore_info_count: u32, - pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo, + pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo<'a>, pub command_buffer_info_count: u32, - pub p_command_buffer_infos: *const CommandBufferSubmitInfo, + pub p_command_buffer_infos: *const CommandBufferSubmitInfo<'a>, pub signal_semaphore_info_count: u32, - pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo, + pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubmitInfo2 { +impl ::std::default::Default for SubmitInfo2<'_> { fn default() -> Self { Self { s_type: StructureType::SUBMIT_INFO_2, @@ -48103,568 +31571,318 @@ impl ::std::default::Default for SubmitInfo2 { p_command_buffer_infos: ::std::ptr::null(), signal_semaphore_info_count: u32::default(), p_signal_semaphore_infos: ::std::ptr::null(), + _marker: PhantomData, } } } -impl SubmitInfo2 { - pub fn builder<'a>() -> SubmitInfo2Builder<'a> { - SubmitInfo2Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SubmitInfo2Builder<'a> { - inner: SubmitInfo2, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsSubmitInfo2 {} -impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> { - type Target = SubmitInfo2; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SubmitInfo2Builder<'a> { +impl<'a> SubmitInfo2<'a> { + #[inline] pub fn flags(mut self, flags: SubmitFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self { - self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _; - self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr(); + self.wait_semaphore_info_count = wait_semaphore_infos.len() as _; + self.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr(); self } + #[inline] pub fn command_buffer_infos( mut self, command_buffer_infos: &'a [CommandBufferSubmitInfo], ) -> Self { - self.inner.command_buffer_info_count = command_buffer_infos.len() as _; - self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr(); + self.command_buffer_info_count = command_buffer_infos.len() as _; + self.p_command_buffer_infos = command_buffer_infos.as_ptr(); self } + #[inline] pub fn signal_semaphore_infos( mut self, signal_semaphore_infos: &'a [SemaphoreSubmitInfo], ) -> Self { - self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _; - self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr(); + self.signal_semaphore_info_count = signal_semaphore_infos.len() as _; + self.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SubmitInfo2 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueueFamilyCheckpointProperties2NV { +pub struct QueueFamilyCheckpointProperties2NV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub checkpoint_execution_stage_mask: PipelineStageFlags2, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueueFamilyCheckpointProperties2NV { +impl ::std::default::Default for QueueFamilyCheckpointProperties2NV<'_> { fn default() -> Self { Self { s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, p_next: ::std::ptr::null_mut(), checkpoint_execution_stage_mask: PipelineStageFlags2::default(), + _marker: PhantomData, } } } -impl QueueFamilyCheckpointProperties2NV { - pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> { - QueueFamilyCheckpointProperties2NVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> { - inner: QueueFamilyCheckpointProperties2NV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NVBuilder<'_> {} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV {} -impl<'a> ::std::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> { - type Target = QueueFamilyCheckpointProperties2NV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> { +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV<'_> {} +impl<'a> QueueFamilyCheckpointProperties2NV<'a> { + #[inline] pub fn checkpoint_execution_stage_mask( mut self, checkpoint_execution_stage_mask: PipelineStageFlags2, ) -> Self { - self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueueFamilyCheckpointProperties2NV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CheckpointData2NV { +pub struct CheckpointData2NV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub stage: PipelineStageFlags2, pub p_checkpoint_marker: *mut c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CheckpointData2NV { +impl ::std::default::Default for CheckpointData2NV<'_> { fn default() -> Self { Self { s_type: StructureType::CHECKPOINT_DATA_2_NV, p_next: ::std::ptr::null_mut(), stage: PipelineStageFlags2::default(), p_checkpoint_marker: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl CheckpointData2NV { - pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> { - CheckpointData2NVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CheckpointData2NVBuilder<'a> { - inner: CheckpointData2NV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> { - type Target = CheckpointData2NV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CheckpointData2NVBuilder<'a> { +impl<'a> CheckpointData2NV<'a> { + #[inline] pub fn stage(mut self, stage: PipelineStageFlags2) -> Self { - self.inner.stage = stage; + self.stage = stage; self } + #[inline] pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self { - self.inner.p_checkpoint_marker = checkpoint_marker; + self.p_checkpoint_marker = checkpoint_marker; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CheckpointData2NV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceSynchronization2Features { +pub struct PhysicalDeviceSynchronization2Features<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub synchronization2: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSynchronization2Features { +impl ::std::default::Default for PhysicalDeviceSynchronization2Features<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, p_next: ::std::ptr::null_mut(), synchronization2: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceSynchronization2Features { - pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> { - PhysicalDeviceSynchronization2FeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> { - inner: PhysicalDeviceSynchronization2Features, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {} -impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> { - type Target = PhysicalDeviceSynchronization2Features; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features<'_> {} +impl<'a> PhysicalDeviceSynchronization2Features<'a> { + #[inline] pub fn synchronization2(mut self, synchronization2: bool) -> Self { - self.inner.synchronization2 = synchronization2.into(); + self.synchronization2 = synchronization2.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceSynchronization2Features { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoQueueFamilyProperties2KHR { +pub struct VideoQueueFamilyProperties2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub video_codec_operations: VideoCodecOperationFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoQueueFamilyProperties2KHR { +impl ::std::default::Default for VideoQueueFamilyProperties2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR, p_next: ::std::ptr::null_mut(), video_codec_operations: VideoCodecOperationFlagsKHR::default(), + _marker: PhantomData, } } } -impl VideoQueueFamilyProperties2KHR { - pub fn builder<'a>() -> VideoQueueFamilyProperties2KHRBuilder<'a> { - VideoQueueFamilyProperties2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoQueueFamilyProperties2KHRBuilder<'a> { - inner: VideoQueueFamilyProperties2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHRBuilder<'_> {} -unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHR {} -impl<'a> ::std::ops::Deref for VideoQueueFamilyProperties2KHRBuilder<'a> { - type Target = VideoQueueFamilyProperties2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoQueueFamilyProperties2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> { +unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHR<'_> {} +impl<'a> VideoQueueFamilyProperties2KHR<'a> { + #[inline] pub fn video_codec_operations( mut self, video_codec_operations: VideoCodecOperationFlagsKHR, ) -> Self { - self.inner.video_codec_operations = video_codec_operations; + self.video_codec_operations = video_codec_operations; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoQueueFamilyProperties2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct QueueFamilyQueryResultStatusProperties2KHR { +pub struct QueueFamilyQueryResultStatusProperties2KHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub supported: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR { +impl ::std::default::Default for QueueFamilyQueryResultStatusProperties2KHR<'_> { fn default() -> Self { Self { s_type: StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR, p_next: ::std::ptr::null_mut(), supported: Bool32::default(), + _marker: PhantomData, } } } -impl QueueFamilyQueryResultStatusProperties2KHR { - pub fn builder<'a>() -> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { - QueueFamilyQueryResultStatusProperties2KHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { - inner: QueueFamilyQueryResultStatusProperties2KHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueueFamilyProperties2 - for QueueFamilyQueryResultStatusProperties2KHRBuilder<'_> -{ -} -unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusProperties2KHR {} -impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { - type Target = QueueFamilyQueryResultStatusProperties2KHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> QueueFamilyQueryResultStatusProperties2KHRBuilder<'a> { +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusProperties2KHR<'_> {} +impl<'a> QueueFamilyQueryResultStatusProperties2KHR<'a> { + #[inline] pub fn supported(mut self, supported: bool) -> Self { - self.inner.supported = supported.into(); + self.supported = supported.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> QueueFamilyQueryResultStatusProperties2KHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoProfilesKHR { +pub struct VideoProfilesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub profile_count: u32, - pub p_profiles: *const VideoProfileKHR, + pub p_profiles: *const VideoProfileKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoProfilesKHR { +impl ::std::default::Default for VideoProfilesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_PROFILES_KHR, p_next: ::std::ptr::null_mut(), profile_count: u32::default(), p_profiles: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoProfilesKHR { - pub fn builder<'a>() -> VideoProfilesKHRBuilder<'a> { - VideoProfilesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoProfilesKHRBuilder<'a> { - inner: VideoProfilesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFormatProperties2 for VideoProfilesKHRBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoProfilesKHR {} -unsafe impl ExtendsImageCreateInfo for VideoProfilesKHRBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoProfilesKHR {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHRBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHR {} -unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHRBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHR {} -impl<'a> ::std::ops::Deref for VideoProfilesKHRBuilder<'a> { - type Target = VideoProfilesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoProfilesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoProfilesKHRBuilder<'a> { +unsafe impl ExtendsFormatProperties2 for VideoProfilesKHR<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoProfilesKHR<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHR<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHR<'_> {} +impl<'a> VideoProfilesKHR<'a> { + #[inline] pub fn profiles(mut self, profiles: &'a [VideoProfileKHR]) -> Self { - self.inner.profile_count = profiles.len() as _; - self.inner.p_profiles = profiles.as_ptr(); + self.profile_count = profiles.len() as _; + self.p_profiles = profiles.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoProfilesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceVideoFormatInfoKHR { +pub struct PhysicalDeviceVideoFormatInfoKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub image_usage: ImageUsageFlags, - pub p_video_profiles: *const VideoProfilesKHR, + pub p_video_profiles: *const VideoProfilesKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR { +impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, p_next: ::std::ptr::null_mut(), image_usage: ImageUsageFlags::default(), p_video_profiles: ::std::ptr::null(), + _marker: PhantomData, } } } -impl PhysicalDeviceVideoFormatInfoKHR { - pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { - PhysicalDeviceVideoFormatInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { - inner: PhysicalDeviceVideoFormatInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { - type Target = PhysicalDeviceVideoFormatInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { +impl<'a> PhysicalDeviceVideoFormatInfoKHR<'a> { + #[inline] pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self { - self.inner.image_usage = image_usage; + self.image_usage = image_usage; self } - pub fn video_profiles(mut self, video_profiles: &'a VideoProfilesKHR) -> Self { - self.inner.p_video_profiles = video_profiles; + #[inline] + pub fn video_profiles(mut self, video_profiles: &'a VideoProfilesKHR<'a>) -> Self { + self.p_video_profiles = video_profiles; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceVideoFormatInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoFormatPropertiesKHR { +pub struct VideoFormatPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub format: Format, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoFormatPropertiesKHR { +impl ::std::default::Default for VideoFormatPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_FORMAT_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), format: Format::default(), + _marker: PhantomData, } } } -impl VideoFormatPropertiesKHR { - pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> { - VideoFormatPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoFormatPropertiesKHRBuilder<'a> { - inner: VideoFormatPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> { - type Target = VideoFormatPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoFormatPropertiesKHRBuilder<'a> { +impl<'a> VideoFormatPropertiesKHR<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoFormatPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoProfileKHR { +pub struct VideoProfileKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub video_codec_operation: VideoCodecOperationFlagsKHR, pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR, pub luma_bit_depth: VideoComponentBitDepthFlagsKHR, pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoProfileKHR { +impl ::std::default::Default for VideoProfileKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_PROFILE_KHR, @@ -48673,93 +31891,63 @@ impl ::std::default::Default for VideoProfileKHR { chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(), luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), + _marker: PhantomData, } } } -impl VideoProfileKHR { - pub fn builder<'a>() -> VideoProfileKHRBuilder<'a> { - VideoProfileKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoProfileKHRBuilder<'a> { - inner: VideoProfileKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHR {} -unsafe impl ExtendsFormatProperties2 for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoProfileKHR {} -unsafe impl ExtendsImageCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoProfileKHR {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR {} -unsafe impl ExtendsBufferCreateInfo for VideoProfileKHRBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHR<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoProfileKHR<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoProfileKHR<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR<'_> {} pub unsafe trait ExtendsVideoProfileKHR {} -impl<'a> ::std::ops::Deref for VideoProfileKHRBuilder<'a> { - type Target = VideoProfileKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoProfileKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoProfileKHRBuilder<'a> { +impl<'a> VideoProfileKHR<'a> { + #[inline] pub fn video_codec_operation( mut self, video_codec_operation: VideoCodecOperationFlagsKHR, ) -> Self { - self.inner.video_codec_operation = video_codec_operation; + self.video_codec_operation = video_codec_operation; self } + #[inline] pub fn chroma_subsampling( mut self, chroma_subsampling: VideoChromaSubsamplingFlagsKHR, ) -> Self { - self.inner.chroma_subsampling = chroma_subsampling; + self.chroma_subsampling = chroma_subsampling; self } + #[inline] pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self { - self.inner.luma_bit_depth = luma_bit_depth; + self.luma_bit_depth = luma_bit_depth; self } + #[inline] pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self { - self.inner.chroma_bit_depth = chroma_bit_depth; + self.chroma_bit_depth = chroma_bit_depth; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoProfileKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoCapabilitiesKHR { +pub struct VideoCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub capability_flags: VideoCapabilityFlagsKHR, @@ -48771,8 +31959,9 @@ pub struct VideoCapabilitiesKHR { pub max_reference_pictures_slots_count: u32, pub max_reference_pictures_active_count: u32, pub std_header_version: ExtensionProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoCapabilitiesKHR { +impl ::std::default::Default for VideoCapabilitiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_CAPABILITIES_KHR, @@ -48786,180 +31975,138 @@ impl ::std::default::Default for VideoCapabilitiesKHR { max_reference_pictures_slots_count: u32::default(), max_reference_pictures_active_count: u32::default(), std_header_version: ExtensionProperties::default(), + _marker: PhantomData, } } } -impl VideoCapabilitiesKHR { - pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> { - VideoCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoCapabilitiesKHRBuilder<'a> { - inner: VideoCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoCapabilitiesKHR {} -impl<'a> ::std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> { - type Target = VideoCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoCapabilitiesKHRBuilder<'a> { +impl<'a> VideoCapabilitiesKHR<'a> { + #[inline] pub fn capability_flags(mut self, capability_flags: VideoCapabilityFlagsKHR) -> Self { - self.inner.capability_flags = capability_flags; + self.capability_flags = capability_flags; self } + #[inline] pub fn min_bitstream_buffer_offset_alignment( mut self, min_bitstream_buffer_offset_alignment: DeviceSize, ) -> Self { - self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment; + self.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment; self } + #[inline] pub fn min_bitstream_buffer_size_alignment( mut self, min_bitstream_buffer_size_alignment: DeviceSize, ) -> Self { - self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment; + self.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment; self } + #[inline] pub fn video_picture_extent_granularity( mut self, video_picture_extent_granularity: Extent2D, ) -> Self { - self.inner.video_picture_extent_granularity = video_picture_extent_granularity; + self.video_picture_extent_granularity = video_picture_extent_granularity; self } + #[inline] pub fn min_extent(mut self, min_extent: Extent2D) -> Self { - self.inner.min_extent = min_extent; + self.min_extent = min_extent; self } + #[inline] pub fn max_extent(mut self, max_extent: Extent2D) -> Self { - self.inner.max_extent = max_extent; + self.max_extent = max_extent; self } + #[inline] pub fn max_reference_pictures_slots_count( mut self, max_reference_pictures_slots_count: u32, ) -> Self { - self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count; + self.max_reference_pictures_slots_count = max_reference_pictures_slots_count; self } + #[inline] pub fn max_reference_pictures_active_count( mut self, max_reference_pictures_active_count: u32, ) -> Self { - self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count; + self.max_reference_pictures_active_count = max_reference_pictures_active_count; self } + #[inline] pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self { - self.inner.std_header_version = std_header_version; + self.std_header_version = std_header_version; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoGetMemoryPropertiesKHR { +pub struct VideoGetMemoryPropertiesKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory_bind_index: u32, - pub p_memory_requirements: *mut MemoryRequirements2, + pub p_memory_requirements: *mut MemoryRequirements2<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoGetMemoryPropertiesKHR { +impl ::std::default::Default for VideoGetMemoryPropertiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_GET_MEMORY_PROPERTIES_KHR, p_next: ::std::ptr::null(), memory_bind_index: u32::default(), p_memory_requirements: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl VideoGetMemoryPropertiesKHR { - pub fn builder<'a>() -> VideoGetMemoryPropertiesKHRBuilder<'a> { - VideoGetMemoryPropertiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoGetMemoryPropertiesKHRBuilder<'a> { - inner: VideoGetMemoryPropertiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoGetMemoryPropertiesKHRBuilder<'a> { - type Target = VideoGetMemoryPropertiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoGetMemoryPropertiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoGetMemoryPropertiesKHRBuilder<'a> { +impl<'a> VideoGetMemoryPropertiesKHR<'a> { + #[inline] pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { - self.inner.memory_bind_index = memory_bind_index; + self.memory_bind_index = memory_bind_index; self } - pub fn memory_requirements(mut self, memory_requirements: &'a mut MemoryRequirements2) -> Self { - self.inner.p_memory_requirements = memory_requirements; + #[inline] + pub fn memory_requirements( + mut self, + memory_requirements: &'a mut MemoryRequirements2<'a>, + ) -> Self { + self.p_memory_requirements = memory_requirements; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoGetMemoryPropertiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoBindMemoryKHR { +pub struct VideoBindMemoryKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory_bind_index: u32, pub memory: DeviceMemory, pub memory_offset: DeviceSize, pub memory_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoBindMemoryKHR { +impl ::std::default::Default for VideoBindMemoryKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_BIND_MEMORY_KHR, @@ -48968,70 +32115,46 @@ impl ::std::default::Default for VideoBindMemoryKHR { memory: DeviceMemory::default(), memory_offset: DeviceSize::default(), memory_size: DeviceSize::default(), + _marker: PhantomData, } } } -impl VideoBindMemoryKHR { - pub fn builder<'a>() -> VideoBindMemoryKHRBuilder<'a> { - VideoBindMemoryKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoBindMemoryKHRBuilder<'a> { - inner: VideoBindMemoryKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoBindMemoryKHRBuilder<'a> { - type Target = VideoBindMemoryKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoBindMemoryKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoBindMemoryKHRBuilder<'a> { +impl<'a> VideoBindMemoryKHR<'a> { + #[inline] pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { - self.inner.memory_bind_index = memory_bind_index; + self.memory_bind_index = memory_bind_index; self } + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { - self.inner.memory_offset = memory_offset; + self.memory_offset = memory_offset; self } + #[inline] pub fn memory_size(mut self, memory_size: DeviceSize) -> Self { - self.inner.memory_size = memory_size; + self.memory_size = memory_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoBindMemoryKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoPictureResourceKHR { +pub struct VideoPictureResourceKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub coded_offset: Offset2D, pub coded_extent: Extent2D, pub base_array_layer: u32, pub image_view_binding: ImageView, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoPictureResourceKHR { +impl ::std::default::Default for VideoPictureResourceKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_PICTURE_RESOURCE_KHR, @@ -49040,208 +32163,129 @@ impl ::std::default::Default for VideoPictureResourceKHR { coded_extent: Extent2D::default(), base_array_layer: u32::default(), image_view_binding: ImageView::default(), + _marker: PhantomData, } } } -impl VideoPictureResourceKHR { - pub fn builder<'a>() -> VideoPictureResourceKHRBuilder<'a> { - VideoPictureResourceKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoPictureResourceKHRBuilder<'a> { - inner: VideoPictureResourceKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoPictureResourceKHRBuilder<'a> { - type Target = VideoPictureResourceKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoPictureResourceKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoPictureResourceKHRBuilder<'a> { +impl<'a> VideoPictureResourceKHR<'a> { + #[inline] pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self { - self.inner.coded_offset = coded_offset; + self.coded_offset = coded_offset; self } + #[inline] pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self { - self.inner.coded_extent = coded_extent; + self.coded_extent = coded_extent; self } + #[inline] pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { - self.inner.base_array_layer = base_array_layer; + self.base_array_layer = base_array_layer; self } + #[inline] pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self { - self.inner.image_view_binding = image_view_binding; + self.image_view_binding = image_view_binding; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoPictureResourceKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoReferenceSlotKHR { +pub struct VideoReferenceSlotKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub slot_index: i8, - pub p_picture_resource: *const VideoPictureResourceKHR, + pub p_picture_resource: *const VideoPictureResourceKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoReferenceSlotKHR { +impl ::std::default::Default for VideoReferenceSlotKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_REFERENCE_SLOT_KHR, p_next: ::std::ptr::null(), slot_index: i8::default(), p_picture_resource: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoReferenceSlotKHR { - pub fn builder<'a>() -> VideoReferenceSlotKHRBuilder<'a> { - VideoReferenceSlotKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoReferenceSlotKHRBuilder<'a> { - inner: VideoReferenceSlotKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoReferenceSlotKHR {} -impl<'a> ::std::ops::Deref for VideoReferenceSlotKHRBuilder<'a> { - type Target = VideoReferenceSlotKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoReferenceSlotKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoReferenceSlotKHRBuilder<'a> { +impl<'a> VideoReferenceSlotKHR<'a> { + #[inline] pub fn slot_index(mut self, slot_index: i8) -> Self { - self.inner.slot_index = slot_index; + self.slot_index = slot_index; self } - pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceKHR) -> Self { - self.inner.p_picture_resource = picture_resource; + #[inline] + pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceKHR<'a>) -> Self { + self.p_picture_resource = picture_resource; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoReferenceSlotKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeCapabilitiesKHR { +pub struct VideoDecodeCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub flags: VideoDecodeCapabilityFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeCapabilitiesKHR { +impl ::std::default::Default for VideoDecodeCapabilitiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_CAPABILITIES_KHR, p_next: ::std::ptr::null_mut(), flags: VideoDecodeCapabilityFlagsKHR::default(), + _marker: PhantomData, } } } -impl VideoDecodeCapabilitiesKHR { - pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> { - VideoDecodeCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeCapabilitiesKHRBuilder<'a> { - inner: VideoDecodeCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {} -unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR<'_> {} pub unsafe trait ExtendsVideoDecodeCapabilitiesKHR {} -impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> { - type Target = VideoDecodeCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> { +impl<'a> VideoDecodeCapabilitiesKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*mut T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeInfoKHR { +pub struct VideoDecodeInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoDecodeFlagsKHR, @@ -49250,12 +32294,13 @@ pub struct VideoDecodeInfoKHR { pub src_buffer: Buffer, pub src_buffer_offset: DeviceSize, pub src_buffer_range: DeviceSize, - pub dst_picture_resource: VideoPictureResourceKHR, - pub p_setup_reference_slot: *const VideoReferenceSlotKHR, + pub dst_picture_resource: VideoPictureResourceKHR<'a>, + pub p_setup_reference_slot: *const VideoReferenceSlotKHR<'a>, pub reference_slot_count: u32, - pub p_reference_slots: *const VideoReferenceSlotKHR, + pub p_reference_slots: *const VideoReferenceSlotKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeInfoKHR { +impl ::std::default::Default for VideoDecodeInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_INFO_KHR, @@ -49270,240 +32315,168 @@ impl ::std::default::Default for VideoDecodeInfoKHR { p_setup_reference_slot: ::std::ptr::null(), reference_slot_count: u32::default(), p_reference_slots: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeInfoKHR { - pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> { - VideoDecodeInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeInfoKHRBuilder<'a> { - inner: VideoDecodeInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoDecodeInfoKHR {} -impl<'a> ::std::ops::Deref for VideoDecodeInfoKHRBuilder<'a> { - type Target = VideoDecodeInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeInfoKHRBuilder<'a> { +impl<'a> VideoDecodeInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self { - self.inner.coded_offset = coded_offset; + self.coded_offset = coded_offset; self } + #[inline] pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self { - self.inner.coded_extent = coded_extent; + self.coded_extent = coded_extent; self } + #[inline] pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { - self.inner.src_buffer = src_buffer; + self.src_buffer = src_buffer; self } + #[inline] pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self { - self.inner.src_buffer_offset = src_buffer_offset; + self.src_buffer_offset = src_buffer_offset; self } + #[inline] pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self { - self.inner.src_buffer_range = src_buffer_range; + self.src_buffer_range = src_buffer_range; self } - pub fn dst_picture_resource(mut self, dst_picture_resource: VideoPictureResourceKHR) -> Self { - self.inner.dst_picture_resource = dst_picture_resource; + #[inline] + pub fn dst_picture_resource( + mut self, + dst_picture_resource: VideoPictureResourceKHR<'a>, + ) -> Self { + self.dst_picture_resource = dst_picture_resource; self } - pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self { - self.inner.p_setup_reference_slot = setup_reference_slot; + #[inline] + pub fn setup_reference_slot( + mut self, + setup_reference_slot: &'a VideoReferenceSlotKHR<'a>, + ) -> Self { + self.p_setup_reference_slot = setup_reference_slot; self } + #[inline] pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self { - self.inner.reference_slot_count = reference_slots.len() as _; - self.inner.p_reference_slots = reference_slots.as_ptr(); + self.reference_slot_count = reference_slots.len() as _; + self.p_reference_slots = reference_slots.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264ProfileEXT { +pub struct VideoDecodeH264ProfileEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_profile_idc: StdVideoH264ProfileIdc, pub picture_layout: VideoDecodeH264PictureLayoutFlagsEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264ProfileEXT { +impl ::std::default::Default for VideoDecodeH264ProfileEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_PROFILE_EXT, p_next: ::std::ptr::null(), std_profile_idc: StdVideoH264ProfileIdc::default(), picture_layout: VideoDecodeH264PictureLayoutFlagsEXT::default(), + _marker: PhantomData, } } } -impl VideoDecodeH264ProfileEXT { - pub fn builder<'a>() -> VideoDecodeH264ProfileEXTBuilder<'a> { - VideoDecodeH264ProfileEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264ProfileEXTBuilder<'a> { - inner: VideoDecodeH264ProfileEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> { - type Target = VideoDecodeH264ProfileEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264ProfileEXTBuilder<'a> { +unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileEXT<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoDecodeH264ProfileEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoDecodeH264ProfileEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH264ProfileEXT<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoDecodeH264ProfileEXT<'_> {} +impl<'a> VideoDecodeH264ProfileEXT<'a> { + #[inline] pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { - self.inner.std_profile_idc = std_profile_idc; + self.std_profile_idc = std_profile_idc; self } + #[inline] pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsEXT) -> Self { - self.inner.picture_layout = picture_layout; + self.picture_layout = picture_layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264ProfileEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264CapabilitiesEXT { +pub struct VideoDecodeH264CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_level: u32, pub field_offset_granularity: Offset2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT { +impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_CAPABILITIES_EXT, p_next: ::std::ptr::null_mut(), max_level: u32::default(), field_offset_granularity: Offset2D::default(), + _marker: PhantomData, } } } -impl VideoDecodeH264CapabilitiesEXT { - pub fn builder<'a>() -> VideoDecodeH264CapabilitiesEXTBuilder<'a> { - VideoDecodeH264CapabilitiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264CapabilitiesEXTBuilder<'a> { - inner: VideoDecodeH264CapabilitiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXTBuilder<'_> {} -unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesEXTBuilder<'a> { - type Target = VideoDecodeH264CapabilitiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264CapabilitiesEXTBuilder<'a> { +unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT<'_> {} +impl<'a> VideoDecodeH264CapabilitiesEXT<'a> { + #[inline] pub fn max_level(mut self, max_level: u32) -> Self { - self.inner.max_level = max_level; + self.max_level = max_level; self } + #[inline] pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self { - self.inner.field_offset_granularity = field_offset_granularity; + self.field_offset_granularity = field_offset_granularity; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264CapabilitiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264SessionParametersAddInfoEXT { +pub struct VideoDecodeH264SessionParametersAddInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub sps_std_count: u32, pub p_sps_std: *const StdVideoH264SequenceParameterSet, pub pps_std_count: u32, pub p_pps_std: *const StdVideoH264PictureParameterSet, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT { +impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT, @@ -49512,71 +32485,41 @@ impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT { p_sps_std: ::std::ptr::null(), pps_std_count: u32::default(), p_pps_std: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH264SessionParametersAddInfoEXT { - pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> { - VideoDecodeH264SessionParametersAddInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> { - inner: VideoDecodeH264SessionParametersAddInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'_> + for VideoDecodeH264SessionParametersAddInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoDecodeH264SessionParametersAddInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> { - type Target = VideoDecodeH264SessionParametersAddInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> { +impl<'a> VideoDecodeH264SessionParametersAddInfoEXT<'a> { + #[inline] pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self { - self.inner.sps_std_count = sps_std.len() as _; - self.inner.p_sps_std = sps_std.as_ptr(); + self.sps_std_count = sps_std.len() as _; + self.p_sps_std = sps_std.as_ptr(); self } + #[inline] pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self { - self.inner.pps_std_count = pps_std.len() as _; - self.inner.p_pps_std = pps_std.as_ptr(); + self.pps_std_count = pps_std.len() as _; + self.p_pps_std = pps_std.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264SessionParametersCreateInfoEXT { +pub struct VideoDecodeH264SessionParametersCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_sps_std_count: u32, pub max_pps_std_count: u32, - pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT, + pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT { +impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT, @@ -49584,76 +32527,47 @@ impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT { max_sps_std_count: u32::default(), max_pps_std_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH264SessionParametersCreateInfoEXT { - pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> { - VideoDecodeH264SessionParametersCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> { - inner: VideoDecodeH264SessionParametersCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'_> + for VideoDecodeH264SessionParametersCreateInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoDecodeH264SessionParametersCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> { - type Target = VideoDecodeH264SessionParametersCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> { +impl<'a> VideoDecodeH264SessionParametersCreateInfoEXT<'a> { + #[inline] pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.inner.max_sps_std_count = max_sps_std_count; + self.max_sps_std_count = max_sps_std_count; self } + #[inline] pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.inner.max_pps_std_count = max_pps_std_count; + self.max_pps_std_count = max_pps_std_count; self } + #[inline] pub fn parameters_add_info( mut self, - parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoEXT, + parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoEXT<'a>, ) -> Self { - self.inner.p_parameters_add_info = parameters_add_info; + self.p_parameters_add_info = parameters_add_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264PictureInfoEXT { +pub struct VideoDecodeH264PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo, pub slices_count: u32, pub p_slices_data_offsets: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264PictureInfoEXT { +impl ::std::default::Default for VideoDecodeH264PictureInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_PICTURE_INFO_EXT, @@ -49661,309 +32575,164 @@ impl ::std::default::Default for VideoDecodeH264PictureInfoEXT { p_std_picture_info: ::std::ptr::null(), slices_count: u32::default(), p_slices_data_offsets: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH264PictureInfoEXT { - pub fn builder<'a>() -> VideoDecodeH264PictureInfoEXTBuilder<'a> { - VideoDecodeH264PictureInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264PictureInfoEXTBuilder<'a> { - inner: VideoDecodeH264PictureInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT {} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT<'_> {} pub unsafe trait ExtendsVideoDecodeH264PictureInfoEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoEXTBuilder<'a> { - type Target = VideoDecodeH264PictureInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264PictureInfoEXTBuilder<'a> { +impl<'a> VideoDecodeH264PictureInfoEXT<'a> { + #[inline] pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self { - self.inner.p_std_picture_info = std_picture_info; + self.p_std_picture_info = std_picture_info; self } + #[inline] pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self { - self.inner.slices_count = slices_data_offsets.len() as _; - self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr(); + self.slices_count = slices_data_offsets.len() as _; + self.p_slices_data_offsets = slices_data_offsets.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264PictureInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264DpbSlotInfoEXT { +pub struct VideoDecodeH264DpbSlotInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT { +impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT, p_next: ::std::ptr::null(), p_std_reference_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH264DpbSlotInfoEXT { - pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> { - VideoDecodeH264DpbSlotInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264DpbSlotInfoEXTBuilder<'a> { - inner: VideoDecodeH264DpbSlotInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> { - type Target = VideoDecodeH264DpbSlotInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXT<'_> {} +impl<'a> VideoDecodeH264DpbSlotInfoEXT<'a> { + #[inline] pub fn std_reference_info( mut self, std_reference_info: &'a StdVideoDecodeH264ReferenceInfo, ) -> Self { - self.inner.p_std_reference_info = std_reference_info; + self.p_std_reference_info = std_reference_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264DpbSlotInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH264MvcEXT { +pub struct VideoDecodeH264MvcEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_mvc: *const StdVideoDecodeH264Mvc, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH264MvcEXT { +impl ::std::default::Default for VideoDecodeH264MvcEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H264_MVC_EXT, p_next: ::std::ptr::null(), p_std_mvc: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH264MvcEXT { - pub fn builder<'a>() -> VideoDecodeH264MvcEXTBuilder<'a> { - VideoDecodeH264MvcEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH264MvcEXTBuilder<'a> { - inner: VideoDecodeH264MvcEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXTBuilder<'_> {} -unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH264MvcEXTBuilder<'a> { - type Target = VideoDecodeH264MvcEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH264MvcEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH264MvcEXTBuilder<'a> { +unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXT<'_> {} +impl<'a> VideoDecodeH264MvcEXT<'a> { + #[inline] pub fn std_mvc(mut self, std_mvc: &'a StdVideoDecodeH264Mvc) -> Self { - self.inner.p_std_mvc = std_mvc; + self.p_std_mvc = std_mvc; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH264MvcEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH265ProfileEXT { +pub struct VideoDecodeH265ProfileEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_profile_idc: StdVideoH265ProfileIdc, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265ProfileEXT { +impl ::std::default::Default for VideoDecodeH265ProfileEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H265_PROFILE_EXT, p_next: ::std::ptr::null(), std_profile_idc: StdVideoH265ProfileIdc::default(), + _marker: PhantomData, } } } -impl VideoDecodeH265ProfileEXT { - pub fn builder<'a>() -> VideoDecodeH265ProfileEXTBuilder<'a> { - VideoDecodeH265ProfileEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265ProfileEXTBuilder<'a> { - inner: VideoDecodeH265ProfileEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> { - type Target = VideoDecodeH265ProfileEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265ProfileEXTBuilder<'a> { +unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileEXT<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoDecodeH265ProfileEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoDecodeH265ProfileEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoDecodeH265ProfileEXT<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoDecodeH265ProfileEXT<'_> {} +impl<'a> VideoDecodeH265ProfileEXT<'a> { + #[inline] pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { - self.inner.std_profile_idc = std_profile_idc; + self.std_profile_idc = std_profile_idc; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265ProfileEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH265CapabilitiesEXT { +pub struct VideoDecodeH265CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub max_level: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT { +impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H265_CAPABILITIES_EXT, p_next: ::std::ptr::null_mut(), max_level: u32::default(), + _marker: PhantomData, } } } -impl VideoDecodeH265CapabilitiesEXT { - pub fn builder<'a>() -> VideoDecodeH265CapabilitiesEXTBuilder<'a> { - VideoDecodeH265CapabilitiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265CapabilitiesEXTBuilder<'a> { - inner: VideoDecodeH265CapabilitiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXTBuilder<'_> {} -unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesEXTBuilder<'a> { - type Target = VideoDecodeH265CapabilitiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265CapabilitiesEXTBuilder<'a> { +unsafe impl ExtendsVideoDecodeCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT<'_> {} +impl<'a> VideoDecodeH265CapabilitiesEXT<'a> { + #[inline] pub fn max_level(mut self, max_level: u32) -> Self { - self.inner.max_level = max_level; + self.max_level = max_level; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265CapabilitiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH265SessionParametersAddInfoEXT { +pub struct VideoDecodeH265SessionParametersAddInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vps_std_count: u32, @@ -49972,8 +32741,9 @@ pub struct VideoDecodeH265SessionParametersAddInfoEXT { pub p_sps_std: *const StdVideoH265SequenceParameterSet, pub pps_std_count: u32, pub p_pps_std: *const StdVideoH265PictureParameterSet, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT { +impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, @@ -49984,77 +32754,48 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT { p_sps_std: ::std::ptr::null(), pps_std_count: u32::default(), p_pps_std: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH265SessionParametersAddInfoEXT { - pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { - VideoDecodeH265SessionParametersAddInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { - inner: VideoDecodeH265SessionParametersAddInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'_> + for VideoDecodeH265SessionParametersAddInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoDecodeH265SessionParametersAddInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { - type Target = VideoDecodeH265SessionParametersAddInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> { +impl<'a> VideoDecodeH265SessionParametersAddInfoEXT<'a> { + #[inline] pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self { - self.inner.vps_std_count = vps_std.len() as _; - self.inner.p_vps_std = vps_std.as_ptr(); + self.vps_std_count = vps_std.len() as _; + self.p_vps_std = vps_std.as_ptr(); self } + #[inline] pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self { - self.inner.sps_std_count = sps_std.len() as _; - self.inner.p_sps_std = sps_std.as_ptr(); + self.sps_std_count = sps_std.len() as _; + self.p_sps_std = sps_std.as_ptr(); self } + #[inline] pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self { - self.inner.pps_std_count = pps_std.len() as _; - self.inner.p_pps_std = pps_std.as_ptr(); + self.pps_std_count = pps_std.len() as _; + self.p_pps_std = pps_std.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH265SessionParametersCreateInfoEXT { +pub struct VideoDecodeH265SessionParametersCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_vps_std_count: u32, pub max_sps_std_count: u32, pub max_pps_std_count: u32, - pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT, + pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT { +impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, @@ -50063,80 +32804,52 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT { max_sps_std_count: u32::default(), max_pps_std_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH265SessionParametersCreateInfoEXT { - pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> { - VideoDecodeH265SessionParametersCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> { - inner: VideoDecodeH265SessionParametersCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'_> + for VideoDecodeH265SessionParametersCreateInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoDecodeH265SessionParametersCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> { - type Target = VideoDecodeH265SessionParametersCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> { +impl<'a> VideoDecodeH265SessionParametersCreateInfoEXT<'a> { + #[inline] pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self { - self.inner.max_vps_std_count = max_vps_std_count; + self.max_vps_std_count = max_vps_std_count; self } + #[inline] pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.inner.max_sps_std_count = max_sps_std_count; + self.max_sps_std_count = max_sps_std_count; self } + #[inline] pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.inner.max_pps_std_count = max_pps_std_count; + self.max_pps_std_count = max_pps_std_count; self } + #[inline] pub fn parameters_add_info( mut self, - parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoEXT, + parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoEXT<'a>, ) -> Self { - self.inner.p_parameters_add_info = parameters_add_info; + self.p_parameters_add_info = parameters_add_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH265PictureInfoEXT { +pub struct VideoDecodeH265PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo, pub slices_count: u32, pub p_slices_data_offsets: *const u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265PictureInfoEXT { +impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H265_PICTURE_INFO_EXT, @@ -50144,132 +32857,77 @@ impl ::std::default::Default for VideoDecodeH265PictureInfoEXT { p_std_picture_info: ::std::ptr::null_mut(), slices_count: u32::default(), p_slices_data_offsets: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH265PictureInfoEXT { - pub fn builder<'a>() -> VideoDecodeH265PictureInfoEXTBuilder<'a> { - VideoDecodeH265PictureInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265PictureInfoEXTBuilder<'a> { - inner: VideoDecodeH265PictureInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoEXTBuilder<'a> { - type Target = VideoDecodeH265PictureInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265PictureInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXT<'_> {} +impl<'a> VideoDecodeH265PictureInfoEXT<'a> { + #[inline] pub fn std_picture_info( mut self, std_picture_info: &'a mut StdVideoDecodeH265PictureInfo, ) -> Self { - self.inner.p_std_picture_info = std_picture_info; + self.p_std_picture_info = std_picture_info; self } + #[inline] pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self { - self.inner.slices_count = slices_data_offsets.len() as _; - self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr(); + self.slices_count = slices_data_offsets.len() as _; + self.p_slices_data_offsets = slices_data_offsets.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265PictureInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoDecodeH265DpbSlotInfoEXT { +pub struct VideoDecodeH265DpbSlotInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT { +impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT, p_next: ::std::ptr::null(), p_std_reference_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoDecodeH265DpbSlotInfoEXT { - pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> { - VideoDecodeH265DpbSlotInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoDecodeH265DpbSlotInfoEXTBuilder<'a> { - inner: VideoDecodeH265DpbSlotInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXT {} -impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> { - type Target = VideoDecodeH265DpbSlotInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXT<'_> {} +impl<'a> VideoDecodeH265DpbSlotInfoEXT<'a> { + #[inline] pub fn std_reference_info( mut self, std_reference_info: &'a StdVideoDecodeH265ReferenceInfo, ) -> Self { - self.inner.p_std_reference_info = std_reference_info; + self.p_std_reference_info = std_reference_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoDecodeH265DpbSlotInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoSessionCreateInfoKHR { +pub struct VideoSessionCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub queue_family_index: u32, pub flags: VideoSessionCreateFlagsKHR, - pub p_video_profile: *const VideoProfileKHR, + pub p_video_profile: *const VideoProfileKHR<'a>, pub picture_format: Format, pub max_coded_extent: Extent2D, pub reference_pictures_format: Format, pub max_reference_pictures_slots_count: u32, pub max_reference_pictures_active_count: u32, pub p_std_header_version: *const ExtensionProperties, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoSessionCreateInfoKHR { +impl ::std::default::Default for VideoSessionCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_SESSION_CREATE_INFO_KHR, @@ -50283,144 +32941,104 @@ impl ::std::default::Default for VideoSessionCreateInfoKHR { max_reference_pictures_slots_count: u32::default(), max_reference_pictures_active_count: u32::default(), p_std_header_version: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoSessionCreateInfoKHR { - pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> { - VideoSessionCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoSessionCreateInfoKHRBuilder<'a> { - inner: VideoSessionCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> { - type Target = VideoSessionCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoSessionCreateInfoKHRBuilder<'a> { +impl<'a> VideoSessionCreateInfoKHR<'a> { + #[inline] pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { - self.inner.queue_family_index = queue_family_index; + self.queue_family_index = queue_family_index; self } + #[inline] pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - pub fn video_profile(mut self, video_profile: &'a VideoProfileKHR) -> Self { - self.inner.p_video_profile = video_profile; + #[inline] + pub fn video_profile(mut self, video_profile: &'a VideoProfileKHR<'a>) -> Self { + self.p_video_profile = video_profile; self } + #[inline] pub fn picture_format(mut self, picture_format: Format) -> Self { - self.inner.picture_format = picture_format; + self.picture_format = picture_format; self } + #[inline] pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self { - self.inner.max_coded_extent = max_coded_extent; + self.max_coded_extent = max_coded_extent; self } + #[inline] pub fn reference_pictures_format(mut self, reference_pictures_format: Format) -> Self { - self.inner.reference_pictures_format = reference_pictures_format; + self.reference_pictures_format = reference_pictures_format; self } + #[inline] pub fn max_reference_pictures_slots_count( mut self, max_reference_pictures_slots_count: u32, ) -> Self { - self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count; + self.max_reference_pictures_slots_count = max_reference_pictures_slots_count; self } + #[inline] pub fn max_reference_pictures_active_count( mut self, max_reference_pictures_active_count: u32, ) -> Self { - self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count; + self.max_reference_pictures_active_count = max_reference_pictures_active_count; self } + #[inline] pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self { - self.inner.p_std_header_version = std_header_version; + self.p_std_header_version = std_header_version; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoSessionCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoSessionParametersCreateInfoKHR { +pub struct VideoSessionParametersCreateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub video_session_parameters_template: VideoSessionParametersKHR, pub video_session: VideoSessionKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoSessionParametersCreateInfoKHR { +impl ::std::default::Default for VideoSessionParametersCreateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, p_next: ::std::ptr::null(), video_session_parameters_template: VideoSessionParametersKHR::default(), video_session: VideoSessionKHR::default(), + _marker: PhantomData, } } } -impl VideoSessionParametersCreateInfoKHR { - pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> { - VideoSessionParametersCreateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> { - inner: VideoSessionParametersCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoSessionParametersCreateInfoKHR {} -impl<'a> ::std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> { - type Target = VideoSessionParametersCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> { +impl<'a> VideoSessionParametersCreateInfoKHR<'a> { + #[inline] pub fn video_session_parameters_template( mut self, video_session_parameters_template: VideoSessionParametersKHR, ) -> Self { - self.inner.video_session_parameters_template = video_session_parameters_template; + self.video_session_parameters_template = video_session_parameters_template; self } + #[inline] pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self { - self.inner.video_session = video_session; + self.video_session = video_session; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -50429,70 +33047,43 @@ impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoSessionParametersCreateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoSessionParametersUpdateInfoKHR { +pub struct VideoSessionParametersUpdateInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub update_sequence_count: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR { +impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, p_next: ::std::ptr::null(), update_sequence_count: u32::default(), + _marker: PhantomData, } } } -impl VideoSessionParametersUpdateInfoKHR { - pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> { - VideoSessionParametersUpdateInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> { - inner: VideoSessionParametersUpdateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoSessionParametersUpdateInfoKHR {} -impl<'a> ::std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> { - type Target = VideoSessionParametersUpdateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> { +impl<'a> VideoSessionParametersUpdateInfoKHR<'a> { + #[inline] pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self { - self.inner.update_sequence_count = update_sequence_count; + self.update_sequence_count = update_sequence_count; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -50501,23 +33092,17 @@ impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoSessionParametersUpdateInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoBeginCodingInfoKHR { +pub struct VideoBeginCodingInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoBeginCodingFlagsKHR, @@ -50525,9 +33110,10 @@ pub struct VideoBeginCodingInfoKHR { pub video_session: VideoSessionKHR, pub video_session_parameters: VideoSessionParametersKHR, pub reference_slot_count: u32, - pub p_reference_slots: *const VideoReferenceSlotKHR, + pub p_reference_slots: *const VideoReferenceSlotKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoBeginCodingInfoKHR { +impl ::std::default::Default for VideoBeginCodingInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_BEGIN_CODING_INFO_KHR, @@ -50538,196 +33124,118 @@ impl ::std::default::Default for VideoBeginCodingInfoKHR { video_session_parameters: VideoSessionParametersKHR::default(), reference_slot_count: u32::default(), p_reference_slots: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoBeginCodingInfoKHR { - pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> { - VideoBeginCodingInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoBeginCodingInfoKHRBuilder<'a> { - inner: VideoBeginCodingInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> { - type Target = VideoBeginCodingInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoBeginCodingInfoKHRBuilder<'a> { +impl<'a> VideoBeginCodingInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn codec_quality_preset( mut self, codec_quality_preset: VideoCodingQualityPresetFlagsKHR, ) -> Self { - self.inner.codec_quality_preset = codec_quality_preset; + self.codec_quality_preset = codec_quality_preset; self } + #[inline] pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self { - self.inner.video_session = video_session; + self.video_session = video_session; self } + #[inline] pub fn video_session_parameters( mut self, video_session_parameters: VideoSessionParametersKHR, ) -> Self { - self.inner.video_session_parameters = video_session_parameters; + self.video_session_parameters = video_session_parameters; self } + #[inline] pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self { - self.inner.reference_slot_count = reference_slots.len() as _; - self.inner.p_reference_slots = reference_slots.as_ptr(); + self.reference_slot_count = reference_slots.len() as _; + self.p_reference_slots = reference_slots.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoBeginCodingInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEndCodingInfoKHR { +pub struct VideoEndCodingInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEndCodingFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEndCodingInfoKHR { +impl ::std::default::Default for VideoEndCodingInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_END_CODING_INFO_KHR, p_next: ::std::ptr::null(), flags: VideoEndCodingFlagsKHR::default(), + _marker: PhantomData, } } } -impl VideoEndCodingInfoKHR { - pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> { - VideoEndCodingInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEndCodingInfoKHRBuilder<'a> { - inner: VideoEndCodingInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> { - type Target = VideoEndCodingInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEndCodingInfoKHRBuilder<'a> { +impl<'a> VideoEndCodingInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEndCodingInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoCodingControlInfoKHR { +pub struct VideoCodingControlInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoCodingControlFlagsKHR, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoCodingControlInfoKHR { +impl ::std::default::Default for VideoCodingControlInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_CODING_CONTROL_INFO_KHR, p_next: ::std::ptr::null(), flags: VideoCodingControlFlagsKHR::default(), + _marker: PhantomData, } } } -impl VideoCodingControlInfoKHR { - pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> { - VideoCodingControlInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoCodingControlInfoKHRBuilder<'a> { - inner: VideoCodingControlInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoCodingControlInfoKHR {} -impl<'a> ::std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> { - type Target = VideoCodingControlInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoCodingControlInfoKHRBuilder<'a> { +impl<'a> VideoCodingControlInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoCodingControlInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeInfoKHR { +pub struct VideoEncodeInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeFlagsKHR, @@ -50736,13 +33244,14 @@ pub struct VideoEncodeInfoKHR { pub dst_bitstream_buffer: Buffer, pub dst_bitstream_buffer_offset: DeviceSize, pub dst_bitstream_buffer_max_range: DeviceSize, - pub src_picture_resource: VideoPictureResourceKHR, - pub p_setup_reference_slot: *const VideoReferenceSlotKHR, + pub src_picture_resource: VideoPictureResourceKHR<'a>, + pub p_setup_reference_slot: *const VideoReferenceSlotKHR<'a>, pub reference_slot_count: u32, - pub p_reference_slots: *const VideoReferenceSlotKHR, + pub p_reference_slots: *const VideoReferenceSlotKHR<'a>, pub preceding_externally_encoded_bytes: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeInfoKHR { +impl ::std::default::Default for VideoEncodeInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_INFO_KHR, @@ -50758,116 +33267,104 @@ impl ::std::default::Default for VideoEncodeInfoKHR { reference_slot_count: u32::default(), p_reference_slots: ::std::ptr::null(), preceding_externally_encoded_bytes: u32::default(), + _marker: PhantomData, } } } -impl VideoEncodeInfoKHR { - pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> { - VideoEncodeInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeInfoKHRBuilder<'a> { - inner: VideoEncodeInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsVideoEncodeInfoKHR {} -impl<'a> ::std::ops::Deref for VideoEncodeInfoKHRBuilder<'a> { - type Target = VideoEncodeInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeInfoKHRBuilder<'a> { +impl<'a> VideoEncodeInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn quality_level(mut self, quality_level: u32) -> Self { - self.inner.quality_level = quality_level; + self.quality_level = quality_level; self } + #[inline] pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self { - self.inner.coded_extent = coded_extent; + self.coded_extent = coded_extent; self } + #[inline] pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self { - self.inner.dst_bitstream_buffer = dst_bitstream_buffer; + self.dst_bitstream_buffer = dst_bitstream_buffer; self } + #[inline] pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self { - self.inner.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset; + self.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset; self } + #[inline] pub fn dst_bitstream_buffer_max_range( mut self, dst_bitstream_buffer_max_range: DeviceSize, ) -> Self { - self.inner.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range; + self.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range; self } - pub fn src_picture_resource(mut self, src_picture_resource: VideoPictureResourceKHR) -> Self { - self.inner.src_picture_resource = src_picture_resource; + #[inline] + pub fn src_picture_resource( + mut self, + src_picture_resource: VideoPictureResourceKHR<'a>, + ) -> Self { + self.src_picture_resource = src_picture_resource; self } - pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self { - self.inner.p_setup_reference_slot = setup_reference_slot; + #[inline] + pub fn setup_reference_slot( + mut self, + setup_reference_slot: &'a VideoReferenceSlotKHR<'a>, + ) -> Self { + self.p_setup_reference_slot = setup_reference_slot; self } + #[inline] pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self { - self.inner.reference_slot_count = reference_slots.len() as _; - self.inner.p_reference_slots = reference_slots.as_ptr(); + self.reference_slot_count = reference_slots.len() as _; + self.p_reference_slots = reference_slots.as_ptr(); self } + #[inline] pub fn preceding_externally_encoded_bytes( mut self, preceding_externally_encoded_bytes: u32, ) -> Self { - self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes; + self.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeRateControlInfoKHR { +pub struct VideoEncodeRateControlInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeRateControlFlagsKHR, pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR, pub layer_count: u8, - pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR, + pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeRateControlInfoKHR { +impl ::std::default::Default for VideoEncodeRateControlInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, @@ -50876,82 +33373,55 @@ impl ::std::default::Default for VideoEncodeRateControlInfoKHR { rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(), layer_count: u8::default(), p_layer_configs: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeRateControlInfoKHR { - pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> { - VideoEncodeRateControlInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeRateControlInfoKHRBuilder<'a> { - inner: VideoEncodeRateControlInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {} -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR<'_> {} pub unsafe trait ExtendsVideoEncodeRateControlInfoKHR {} -impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> { - type Target = VideoEncodeRateControlInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> { +impl<'a> VideoEncodeRateControlInfoKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn rate_control_mode( mut self, rate_control_mode: VideoEncodeRateControlModeFlagsKHR, ) -> Self { - self.inner.rate_control_mode = rate_control_mode; + self.rate_control_mode = rate_control_mode; self } + #[inline] pub fn layer_configs( mut self, layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR], ) -> Self { - self.inner.layer_count = layer_configs.len() as _; - self.inner.p_layer_configs = layer_configs.as_ptr(); + self.layer_count = layer_configs.len() as _; + self.p_layer_configs = layer_configs.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeRateControlInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeRateControlLayerInfoKHR { +pub struct VideoEncodeRateControlLayerInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub average_bitrate: u32, @@ -50960,8 +33430,9 @@ pub struct VideoEncodeRateControlLayerInfoKHR { pub frame_rate_denominator: u32, pub virtual_buffer_size_in_ms: u32, pub initial_virtual_buffer_size_in_ms: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR { +impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR, @@ -50972,68 +33443,50 @@ impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR { frame_rate_denominator: u32::default(), virtual_buffer_size_in_ms: u32::default(), initial_virtual_buffer_size_in_ms: u32::default(), + _marker: PhantomData, } } } -impl VideoEncodeRateControlLayerInfoKHR { - pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { - VideoEncodeRateControlLayerInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> { - inner: VideoEncodeRateControlLayerInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {} -unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR<'_> {} pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {} -impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> { - type Target = VideoEncodeRateControlLayerInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { +impl<'a> VideoEncodeRateControlLayerInfoKHR<'a> { + #[inline] pub fn average_bitrate(mut self, average_bitrate: u32) -> Self { - self.inner.average_bitrate = average_bitrate; + self.average_bitrate = average_bitrate; self } + #[inline] pub fn max_bitrate(mut self, max_bitrate: u32) -> Self { - self.inner.max_bitrate = max_bitrate; + self.max_bitrate = max_bitrate; self } + #[inline] pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self { - self.inner.frame_rate_numerator = frame_rate_numerator; + self.frame_rate_numerator = frame_rate_numerator; self } + #[inline] pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self { - self.inner.frame_rate_denominator = frame_rate_denominator; + self.frame_rate_denominator = frame_rate_denominator; self } + #[inline] pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self { - self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; + self.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; self } + #[inline] pub fn initial_virtual_buffer_size_in_ms( mut self, initial_virtual_buffer_size_in_ms: u32, ) -> Self { - self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; + self.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next( mut self, @@ -51042,23 +33495,17 @@ impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeCapabilitiesKHR { +pub struct VideoEncodeCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeCapabilityFlagsKHR, @@ -51066,8 +33513,9 @@ pub struct VideoEncodeCapabilitiesKHR { pub rate_control_layer_count: u8, pub quality_level_count: u8, pub input_image_data_fill_alignment: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeCapabilitiesKHR { +impl ::std::default::Default for VideoEncodeCapabilitiesKHR<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_CAPABILITIES_KHR, @@ -51077,89 +33525,64 @@ impl ::std::default::Default for VideoEncodeCapabilitiesKHR { rate_control_layer_count: u8::default(), quality_level_count: u8::default(), input_image_data_fill_alignment: Extent2D::default(), + _marker: PhantomData, } } } -impl VideoEncodeCapabilitiesKHR { - pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> { - VideoEncodeCapabilitiesKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeCapabilitiesKHRBuilder<'a> { - inner: VideoEncodeCapabilitiesKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {} -unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR<'_> {} pub unsafe trait ExtendsVideoEncodeCapabilitiesKHR {} -impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> { - type Target = VideoEncodeCapabilitiesKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> { +impl<'a> VideoEncodeCapabilitiesKHR<'a> { + #[inline] pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn rate_control_modes( mut self, rate_control_modes: VideoEncodeRateControlModeFlagsKHR, ) -> Self { - self.inner.rate_control_modes = rate_control_modes; + self.rate_control_modes = rate_control_modes; self } + #[inline] pub fn rate_control_layer_count(mut self, rate_control_layer_count: u8) -> Self { - self.inner.rate_control_layer_count = rate_control_layer_count; + self.rate_control_layer_count = rate_control_layer_count; self } + #[inline] pub fn quality_level_count(mut self, quality_level_count: u8) -> Self { - self.inner.quality_level_count = quality_level_count; + self.quality_level_count = quality_level_count; self } + #[inline] pub fn input_image_data_fill_alignment( mut self, input_image_data_fill_alignment: Extent2D, ) -> Self { - self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment; + self.input_image_data_fill_alignment = input_image_data_fill_alignment; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeCapabilitiesKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264CapabilitiesEXT { +pub struct VideoEncodeH264CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeH264CapabilityFlagsEXT, @@ -51173,8 +33596,9 @@ pub struct VideoEncodeH264CapabilitiesEXT { pub max_bits_per_mb_denom: u32, pub log2_max_mv_length_horizontal: u32, pub log2_max_mv_length_vertical: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT { +impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT, @@ -51190,113 +33614,95 @@ impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT { max_bits_per_mb_denom: u32::default(), log2_max_mv_length_horizontal: u32::default(), log2_max_mv_length_vertical: u32::default(), + _marker: PhantomData, } } } -impl VideoEncodeH264CapabilitiesEXT { - pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> { - VideoEncodeH264CapabilitiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> { - inner: VideoEncodeH264CapabilitiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> { - type Target = VideoEncodeH264CapabilitiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT<'_> {} +impl<'a> VideoEncodeH264CapabilitiesEXT<'a> { + #[inline] pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self { - self.inner.input_mode_flags = input_mode_flags; + self.input_mode_flags = input_mode_flags; self } + #[inline] pub fn output_mode_flags( mut self, output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, ) -> Self { - self.inner.output_mode_flags = output_mode_flags; + self.output_mode_flags = output_mode_flags; self } + #[inline] pub fn max_p_picture_l0_reference_count( mut self, max_p_picture_l0_reference_count: u8, ) -> Self { - self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; self } + #[inline] pub fn max_b_picture_l0_reference_count( mut self, max_b_picture_l0_reference_count: u8, ) -> Self { - self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; self } + #[inline] pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self { - self.inner.max_l1_reference_count = max_l1_reference_count; + self.max_l1_reference_count = max_l1_reference_count; self } + #[inline] pub fn motion_vectors_over_pic_boundaries_flag( mut self, motion_vectors_over_pic_boundaries_flag: bool, ) -> Self { - self.inner.motion_vectors_over_pic_boundaries_flag = + self.motion_vectors_over_pic_boundaries_flag = motion_vectors_over_pic_boundaries_flag.into(); self } + #[inline] pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self { - self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom; + self.max_bytes_per_pic_denom = max_bytes_per_pic_denom; self } + #[inline] pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self { - self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom; + self.max_bits_per_mb_denom = max_bits_per_mb_denom; self } + #[inline] pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self { - self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; + self.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; self } + #[inline] pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self { - self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical; + self.log2_max_mv_length_vertical = log2_max_mv_length_vertical; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264CapabilitiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264SessionParametersAddInfoEXT { +pub struct VideoEncodeH264SessionParametersAddInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub sps_std_count: u32, pub p_sps_std: *const StdVideoH264SequenceParameterSet, pub pps_std_count: u32, pub p_pps_std: *const StdVideoH264PictureParameterSet, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT { +impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT, @@ -51305,71 +33711,41 @@ impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT { p_sps_std: ::std::ptr::null(), pps_std_count: u32::default(), p_pps_std: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264SessionParametersAddInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { - VideoEncodeH264SessionParametersAddInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { - inner: VideoEncodeH264SessionParametersAddInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'_> + for VideoEncodeH264SessionParametersAddInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoEncodeH264SessionParametersAddInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { - type Target = VideoEncodeH264SessionParametersAddInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH264SessionParametersAddInfoEXT<'a> { + #[inline] pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self { - self.inner.sps_std_count = sps_std.len() as _; - self.inner.p_sps_std = sps_std.as_ptr(); + self.sps_std_count = sps_std.len() as _; + self.p_sps_std = sps_std.as_ptr(); self } + #[inline] pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self { - self.inner.pps_std_count = pps_std.len() as _; - self.inner.p_pps_std = pps_std.as_ptr(); + self.pps_std_count = pps_std.len() as _; + self.p_pps_std = pps_std.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264SessionParametersAddInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264SessionParametersCreateInfoEXT { +pub struct VideoEncodeH264SessionParametersCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_sps_std_count: u32, pub max_pps_std_count: u32, - pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT, + pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT { +impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT, @@ -51377,140 +33753,85 @@ impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT { max_sps_std_count: u32::default(), max_pps_std_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264SessionParametersCreateInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { - VideoEncodeH264SessionParametersCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { - inner: VideoEncodeH264SessionParametersCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'_> + for VideoEncodeH264SessionParametersCreateInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoEncodeH264SessionParametersCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { - type Target = VideoEncodeH264SessionParametersCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH264SessionParametersCreateInfoEXT<'a> { + #[inline] pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.inner.max_sps_std_count = max_sps_std_count; + self.max_sps_std_count = max_sps_std_count; self } + #[inline] pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.inner.max_pps_std_count = max_pps_std_count; + self.max_pps_std_count = max_pps_std_count; self } + #[inline] pub fn parameters_add_info( mut self, - parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT, + parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT<'a>, ) -> Self { - self.inner.p_parameters_add_info = parameters_add_info; + self.p_parameters_add_info = parameters_add_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264DpbSlotInfoEXT { +pub struct VideoEncodeH264DpbSlotInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub slot_index: i8, pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT { +impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT, p_next: ::std::ptr::null(), slot_index: i8::default(), p_std_reference_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264DpbSlotInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { - VideoEncodeH264DpbSlotInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { - inner: VideoEncodeH264DpbSlotInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { - type Target = VideoEncodeH264DpbSlotInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH264DpbSlotInfoEXT<'a> { + #[inline] pub fn slot_index(mut self, slot_index: i8) -> Self { - self.inner.slot_index = slot_index; + self.slot_index = slot_index; self } + #[inline] pub fn std_reference_info( mut self, std_reference_info: &'a StdVideoEncodeH264ReferenceInfo, ) -> Self { - self.inner.p_std_reference_info = std_reference_info; + self.p_std_reference_info = std_reference_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264DpbSlotInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264VclFrameInfoEXT { +pub struct VideoEncodeH264VclFrameInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT, + pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT<'a>, pub nalu_slice_entry_count: u32, - pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceEXT, + pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceEXT<'a>, pub p_current_picture_info: *const StdVideoEncodeH264PictureInfo, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT { +impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT, @@ -51519,79 +33840,53 @@ impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT { nalu_slice_entry_count: u32::default(), p_nalu_slice_entries: ::std::ptr::null(), p_current_picture_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264VclFrameInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> { - VideoEncodeH264VclFrameInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264VclFrameInfoEXTBuilder<'a> { - inner: VideoEncodeH264VclFrameInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264VclFrameInfoEXTBuilder<'a> { - type Target = VideoEncodeH264VclFrameInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT<'_> {} +impl<'a> VideoEncodeH264VclFrameInfoEXT<'a> { + #[inline] pub fn reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT, + reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT<'a>, ) -> Self { - self.inner.p_reference_final_lists = reference_final_lists; + self.p_reference_final_lists = reference_final_lists; self } + #[inline] pub fn nalu_slice_entries( mut self, nalu_slice_entries: &'a [VideoEncodeH264NaluSliceEXT], ) -> Self { - self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _; - self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr(); + self.nalu_slice_entry_count = nalu_slice_entries.len() as _; + self.p_nalu_slice_entries = nalu_slice_entries.as_ptr(); self } + #[inline] pub fn current_picture_info( mut self, current_picture_info: &'a StdVideoEncodeH264PictureInfo, ) -> Self { - self.inner.p_current_picture_info = current_picture_info; + self.p_current_picture_info = current_picture_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264ReferenceListsEXT { +pub struct VideoEncodeH264ReferenceListsEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub reference_list0_entry_count: u8, - pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT, + pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT<'a>, pub reference_list1_entry_count: u8, - pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT, + pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT<'a>, pub p_mem_mgmt_ctrl_operations: *const StdVideoEncodeH264RefMemMgmtCtrlOperations, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264ReferenceListsEXT { +impl ::std::default::Default for VideoEncodeH264ReferenceListsEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT, @@ -51601,77 +33896,52 @@ impl ::std::default::Default for VideoEncodeH264ReferenceListsEXT { reference_list1_entry_count: u8::default(), p_reference_list1_entries: ::std::ptr::null(), p_mem_mgmt_ctrl_operations: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264ReferenceListsEXT { - pub fn builder<'a>() -> VideoEncodeH264ReferenceListsEXTBuilder<'a> { - VideoEncodeH264ReferenceListsEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264ReferenceListsEXTBuilder<'a> { - inner: VideoEncodeH264ReferenceListsEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH264ReferenceListsEXTBuilder<'a> { - type Target = VideoEncodeH264ReferenceListsEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264ReferenceListsEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264ReferenceListsEXTBuilder<'a> { +impl<'a> VideoEncodeH264ReferenceListsEXT<'a> { + #[inline] pub fn reference_list0_entries( mut self, reference_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], ) -> Self { - self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; - self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self.reference_list0_entry_count = reference_list0_entries.len() as _; + self.p_reference_list0_entries = reference_list0_entries.as_ptr(); self } + #[inline] pub fn reference_list1_entries( mut self, reference_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], ) -> Self { - self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; - self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self.reference_list1_entry_count = reference_list1_entries.len() as _; + self.p_reference_list1_entries = reference_list1_entries.as_ptr(); self } + #[inline] pub fn mem_mgmt_ctrl_operations( mut self, mem_mgmt_ctrl_operations: &'a StdVideoEncodeH264RefMemMgmtCtrlOperations, ) -> Self { - self.inner.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations; + self.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264ReferenceListsEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264EmitPictureParametersEXT { +pub struct VideoEncodeH264EmitPictureParametersEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub sps_id: u8, pub emit_sps_enable: Bool32, pub pps_id_entry_count: u32, pub pps_id_entries: *const u8, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264EmitPictureParametersEXT { +impl ::std::default::Default for VideoEncodeH264EmitPictureParametersEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT, @@ -51680,134 +33950,75 @@ impl ::std::default::Default for VideoEncodeH264EmitPictureParametersEXT { emit_sps_enable: Bool32::default(), pps_id_entry_count: u32::default(), pps_id_entries: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264EmitPictureParametersEXT { - pub fn builder<'a>() -> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> { - VideoEncodeH264EmitPictureParametersEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264EmitPictureParametersEXTBuilder<'a> { - inner: VideoEncodeH264EmitPictureParametersEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> { - type Target = VideoEncodeH264EmitPictureParametersEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXT<'_> {} +impl<'a> VideoEncodeH264EmitPictureParametersEXT<'a> { + #[inline] pub fn sps_id(mut self, sps_id: u8) -> Self { - self.inner.sps_id = sps_id; + self.sps_id = sps_id; self } + #[inline] pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { - self.inner.emit_sps_enable = emit_sps_enable.into(); + self.emit_sps_enable = emit_sps_enable.into(); self } + #[inline] pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { - self.inner.pps_id_entry_count = pps_id_entries.len() as _; - self.inner.pps_id_entries = pps_id_entries.as_ptr(); + self.pps_id_entry_count = pps_id_entries.len() as _; + self.pps_id_entries = pps_id_entries.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264EmitPictureParametersEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264ProfileEXT { +pub struct VideoEncodeH264ProfileEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_profile_idc: StdVideoH264ProfileIdc, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264ProfileEXT { +impl ::std::default::Default for VideoEncodeH264ProfileEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_PROFILE_EXT, p_next: ::std::ptr::null(), std_profile_idc: StdVideoH264ProfileIdc::default(), + _marker: PhantomData, } } } -impl VideoEncodeH264ProfileEXT { - pub fn builder<'a>() -> VideoEncodeH264ProfileEXTBuilder<'a> { - VideoEncodeH264ProfileEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264ProfileEXTBuilder<'a> { - inner: VideoEncodeH264ProfileEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> { - type Target = VideoEncodeH264ProfileEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264ProfileEXTBuilder<'a> { +unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileEXT<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoEncodeH264ProfileEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoEncodeH264ProfileEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH264ProfileEXT<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoEncodeH264ProfileEXT<'_> {} +impl<'a> VideoEncodeH264ProfileEXT<'a> { + #[inline] pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { - self.inner.std_profile_idc = std_profile_idc; + self.std_profile_idc = std_profile_idc; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264ProfileEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264NaluSliceEXT { +pub struct VideoEncodeH264NaluSliceEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub mb_count: u32, - pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT, + pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsEXT<'a>, pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264NaluSliceEXT { +impl ::std::default::Default for VideoEncodeH264NaluSliceEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_NALU_SLICE_EXT, @@ -51815,61 +34026,35 @@ impl ::std::default::Default for VideoEncodeH264NaluSliceEXT { mb_count: u32::default(), p_reference_final_lists: ::std::ptr::null(), p_slice_header_std: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH264NaluSliceEXT { - pub fn builder<'a>() -> VideoEncodeH264NaluSliceEXTBuilder<'a> { - VideoEncodeH264NaluSliceEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264NaluSliceEXTBuilder<'a> { - inner: VideoEncodeH264NaluSliceEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceEXTBuilder<'a> { - type Target = VideoEncodeH264NaluSliceEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> { +impl<'a> VideoEncodeH264NaluSliceEXT<'a> { + #[inline] pub fn mb_count(mut self, mb_count: u32) -> Self { - self.inner.mb_count = mb_count; + self.mb_count = mb_count; self } + #[inline] pub fn reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT, + reference_final_lists: &'a VideoEncodeH264ReferenceListsEXT<'a>, ) -> Self { - self.inner.p_reference_final_lists = reference_final_lists; + self.p_reference_final_lists = reference_final_lists; self } + #[inline] pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self { - self.inner.p_slice_header_std = slice_header_std; + self.p_slice_header_std = slice_header_std; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264NaluSliceEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264RateControlInfoEXT { +pub struct VideoEncodeH264RateControlInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub gop_frame_count: u32, @@ -51877,8 +34062,9 @@ pub struct VideoEncodeH264RateControlInfoEXT { pub consecutive_b_frame_count: u32, pub rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT, pub temporal_layer_count: u8, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT { +impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT, @@ -51888,65 +34074,40 @@ impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT { consecutive_b_frame_count: u32::default(), rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT::default(), temporal_layer_count: u8::default(), + _marker: PhantomData, } } } -impl VideoEncodeH264RateControlInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> { - VideoEncodeH264RateControlInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> { - inner: VideoEncodeH264RateControlInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> { - type Target = VideoEncodeH264RateControlInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH264RateControlInfoEXT<'_> {} +impl<'a> VideoEncodeH264RateControlInfoEXT<'a> { + #[inline] pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { - self.inner.gop_frame_count = gop_frame_count; + self.gop_frame_count = gop_frame_count; self } + #[inline] pub fn idr_period(mut self, idr_period: u32) -> Self { - self.inner.idr_period = idr_period; + self.idr_period = idr_period; self } + #[inline] pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { - self.inner.consecutive_b_frame_count = consecutive_b_frame_count; + self.consecutive_b_frame_count = consecutive_b_frame_count; self } + #[inline] pub fn rate_control_structure( mut self, rate_control_structure: VideoEncodeH264RateControlStructureFlagsEXT, ) -> Self { - self.inner.rate_control_structure = rate_control_structure; + self.rate_control_structure = rate_control_structure; self } + #[inline] pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self { - self.inner.temporal_layer_count = temporal_layer_count; + self.temporal_layer_count = temporal_layer_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264RateControlInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -51958,48 +34119,21 @@ pub struct VideoEncodeH264QpEXT { pub qp_b: i32, } impl VideoEncodeH264QpEXT { - pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> { - VideoEncodeH264QpEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264QpEXTBuilder<'a> { - inner: VideoEncodeH264QpEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> { - type Target = VideoEncodeH264QpEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264QpEXTBuilder<'a> { + #[inline] pub fn qp_i(mut self, qp_i: i32) -> Self { - self.inner.qp_i = qp_i; + self.qp_i = qp_i; self } + #[inline] pub fn qp_p(mut self, qp_p: i32) -> Self { - self.inner.qp_p = qp_p; + self.qp_p = qp_p; self } + #[inline] pub fn qp_b(mut self, qp_b: i32) -> Self { - self.inner.qp_b = qp_b; + self.qp_b = qp_b; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264QpEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -52011,54 +34145,27 @@ pub struct VideoEncodeH264FrameSizeEXT { pub frame_b_size: u32, } impl VideoEncodeH264FrameSizeEXT { - pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> { - VideoEncodeH264FrameSizeEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> { - inner: VideoEncodeH264FrameSizeEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> { - type Target = VideoEncodeH264FrameSizeEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> { + #[inline] pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { - self.inner.frame_i_size = frame_i_size; + self.frame_i_size = frame_i_size; self } + #[inline] pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { - self.inner.frame_p_size = frame_p_size; + self.frame_p_size = frame_p_size; self } + #[inline] pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { - self.inner.frame_b_size = frame_b_size; + self.frame_b_size = frame_b_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264FrameSizeEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH264RateControlLayerInfoEXT { +pub struct VideoEncodeH264RateControlLayerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub temporal_layer_id: u8, @@ -52070,8 +34177,9 @@ pub struct VideoEncodeH264RateControlLayerInfoEXT { pub max_qp: VideoEncodeH264QpEXT, pub use_max_frame_size: Bool32, pub max_frame_size: VideoEncodeH264FrameSizeEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT { +impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT, @@ -52085,87 +34193,66 @@ impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT { max_qp: VideoEncodeH264QpEXT::default(), use_max_frame_size: Bool32::default(), max_frame_size: VideoEncodeH264FrameSizeEXT::default(), + _marker: PhantomData, } } } -impl VideoEncodeH264RateControlLayerInfoEXT { - pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { - VideoEncodeH264RateControlLayerInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { - inner: VideoEncodeH264RateControlLayerInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR - for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> + for VideoEncodeH264RateControlLayerInfoEXT<'_> { } -unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { - type Target = VideoEncodeH264RateControlLayerInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH264RateControlLayerInfoEXT<'a> { + #[inline] pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self { - self.inner.temporal_layer_id = temporal_layer_id; + self.temporal_layer_id = temporal_layer_id; self } + #[inline] pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { - self.inner.use_initial_rc_qp = use_initial_rc_qp.into(); + self.use_initial_rc_qp = use_initial_rc_qp.into(); self } + #[inline] pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self { - self.inner.initial_rc_qp = initial_rc_qp; + self.initial_rc_qp = initial_rc_qp; self } + #[inline] pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { - self.inner.use_min_qp = use_min_qp.into(); + self.use_min_qp = use_min_qp.into(); self } + #[inline] pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self { - self.inner.min_qp = min_qp; + self.min_qp = min_qp; self } + #[inline] pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { - self.inner.use_max_qp = use_max_qp.into(); + self.use_max_qp = use_max_qp.into(); self } + #[inline] pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self { - self.inner.max_qp = max_qp; + self.max_qp = max_qp; self } + #[inline] pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { - self.inner.use_max_frame_size = use_max_frame_size.into(); + self.use_max_frame_size = use_max_frame_size.into(); self } + #[inline] pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self { - self.inner.max_frame_size = max_frame_size; + self.max_frame_size = max_frame_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265CapabilitiesEXT { +pub struct VideoEncodeH265CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: VideoEncodeH265CapabilityFlagsEXT, @@ -52188,8 +34275,9 @@ pub struct VideoEncodeH265CapabilitiesEXT { pub max_diff_cu_qp_delta_depth: u8, pub min_max_num_merge_cand: u8, pub max_max_num_merge_cand: u8, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { +impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT, @@ -52214,172 +34302,158 @@ impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { max_diff_cu_qp_delta_depth: u8::default(), min_max_num_merge_cand: u8::default(), max_max_num_merge_cand: u8::default(), + _marker: PhantomData, } } } -impl VideoEncodeH265CapabilitiesEXT { - pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> { - VideoEncodeH265CapabilitiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> { - inner: VideoEncodeH265CapabilitiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> { - type Target = VideoEncodeH265CapabilitiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT<'_> {} +impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { + #[inline] pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self { - self.inner.input_mode_flags = input_mode_flags; + self.input_mode_flags = input_mode_flags; self } + #[inline] pub fn output_mode_flags( mut self, output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, ) -> Self { - self.inner.output_mode_flags = output_mode_flags; + self.output_mode_flags = output_mode_flags; self } + #[inline] pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self { - self.inner.ctb_sizes = ctb_sizes; + self.ctb_sizes = ctb_sizes; self } + #[inline] pub fn transform_block_sizes( mut self, transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, ) -> Self { - self.inner.transform_block_sizes = transform_block_sizes; + self.transform_block_sizes = transform_block_sizes; self } + #[inline] pub fn max_p_picture_l0_reference_count( mut self, max_p_picture_l0_reference_count: u8, ) -> Self { - self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; self } + #[inline] pub fn max_b_picture_l0_reference_count( mut self, max_b_picture_l0_reference_count: u8, ) -> Self { - self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; self } + #[inline] pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self { - self.inner.max_l1_reference_count = max_l1_reference_count; + self.max_l1_reference_count = max_l1_reference_count; self } + #[inline] pub fn max_sub_layers_count(mut self, max_sub_layers_count: u8) -> Self { - self.inner.max_sub_layers_count = max_sub_layers_count; + self.max_sub_layers_count = max_sub_layers_count; self } + #[inline] pub fn min_log2_min_luma_coding_block_size_minus3( mut self, min_log2_min_luma_coding_block_size_minus3: u8, ) -> Self { - self.inner.min_log2_min_luma_coding_block_size_minus3 = + self.min_log2_min_luma_coding_block_size_minus3 = min_log2_min_luma_coding_block_size_minus3; self } + #[inline] pub fn max_log2_min_luma_coding_block_size_minus3( mut self, max_log2_min_luma_coding_block_size_minus3: u8, ) -> Self { - self.inner.max_log2_min_luma_coding_block_size_minus3 = + self.max_log2_min_luma_coding_block_size_minus3 = max_log2_min_luma_coding_block_size_minus3; self } + #[inline] pub fn min_log2_min_luma_transform_block_size_minus2( mut self, min_log2_min_luma_transform_block_size_minus2: u8, ) -> Self { - self.inner.min_log2_min_luma_transform_block_size_minus2 = + self.min_log2_min_luma_transform_block_size_minus2 = min_log2_min_luma_transform_block_size_minus2; self } + #[inline] pub fn max_log2_min_luma_transform_block_size_minus2( mut self, max_log2_min_luma_transform_block_size_minus2: u8, ) -> Self { - self.inner.max_log2_min_luma_transform_block_size_minus2 = + self.max_log2_min_luma_transform_block_size_minus2 = max_log2_min_luma_transform_block_size_minus2; self } + #[inline] pub fn min_max_transform_hierarchy_depth_inter( mut self, min_max_transform_hierarchy_depth_inter: u8, ) -> Self { - self.inner.min_max_transform_hierarchy_depth_inter = - min_max_transform_hierarchy_depth_inter; + self.min_max_transform_hierarchy_depth_inter = min_max_transform_hierarchy_depth_inter; self } + #[inline] pub fn max_max_transform_hierarchy_depth_inter( mut self, max_max_transform_hierarchy_depth_inter: u8, ) -> Self { - self.inner.max_max_transform_hierarchy_depth_inter = - max_max_transform_hierarchy_depth_inter; + self.max_max_transform_hierarchy_depth_inter = max_max_transform_hierarchy_depth_inter; self } + #[inline] pub fn min_max_transform_hierarchy_depth_intra( mut self, min_max_transform_hierarchy_depth_intra: u8, ) -> Self { - self.inner.min_max_transform_hierarchy_depth_intra = - min_max_transform_hierarchy_depth_intra; + self.min_max_transform_hierarchy_depth_intra = min_max_transform_hierarchy_depth_intra; self } + #[inline] pub fn max_max_transform_hierarchy_depth_intra( mut self, max_max_transform_hierarchy_depth_intra: u8, ) -> Self { - self.inner.max_max_transform_hierarchy_depth_intra = - max_max_transform_hierarchy_depth_intra; + self.max_max_transform_hierarchy_depth_intra = max_max_transform_hierarchy_depth_intra; self } + #[inline] pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u8) -> Self { - self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth; + self.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth; self } + #[inline] pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u8) -> Self { - self.inner.min_max_num_merge_cand = min_max_num_merge_cand; + self.min_max_num_merge_cand = min_max_num_merge_cand; self } + #[inline] pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u8) -> Self { - self.inner.max_max_num_merge_cand = max_max_num_merge_cand; + self.max_max_num_merge_cand = max_max_num_merge_cand; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265CapabilitiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265SessionParametersAddInfoEXT { +pub struct VideoEncodeH265SessionParametersAddInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vps_std_count: u32, @@ -52388,8 +34462,9 @@ pub struct VideoEncodeH265SessionParametersAddInfoEXT { pub p_sps_std: *const StdVideoH265SequenceParameterSet, pub pps_std_count: u32, pub p_pps_std: *const StdVideoH265PictureParameterSet, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT { +impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT, @@ -52400,77 +34475,48 @@ impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT { p_sps_std: ::std::ptr::null(), pps_std_count: u32::default(), p_pps_std: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265SessionParametersAddInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { - VideoEncodeH265SessionParametersAddInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { - inner: VideoEncodeH265SessionParametersAddInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_> + for VideoEncodeH265SessionParametersAddInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR - for VideoEncodeH265SessionParametersAddInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { - type Target = VideoEncodeH265SessionParametersAddInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH265SessionParametersAddInfoEXT<'a> { + #[inline] pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self { - self.inner.vps_std_count = vps_std.len() as _; - self.inner.p_vps_std = vps_std.as_ptr(); + self.vps_std_count = vps_std.len() as _; + self.p_vps_std = vps_std.as_ptr(); self } + #[inline] pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self { - self.inner.sps_std_count = sps_std.len() as _; - self.inner.p_sps_std = sps_std.as_ptr(); + self.sps_std_count = sps_std.len() as _; + self.p_sps_std = sps_std.as_ptr(); self } + #[inline] pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self { - self.inner.pps_std_count = pps_std.len() as _; - self.inner.p_pps_std = pps_std.as_ptr(); + self.pps_std_count = pps_std.len() as _; + self.p_pps_std = pps_std.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265SessionParametersCreateInfoEXT { +pub struct VideoEncodeH265SessionParametersCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_vps_std_count: u32, pub max_sps_std_count: u32, pub max_pps_std_count: u32, - pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT, + pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT { +impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT, @@ -52479,81 +34525,53 @@ impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT { max_sps_std_count: u32::default(), max_pps_std_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265SessionParametersCreateInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { - VideoEncodeH265SessionParametersCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { - inner: VideoEncodeH265SessionParametersCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_> + for VideoEncodeH265SessionParametersCreateInfoEXT<'_> { } -unsafe impl ExtendsVideoSessionParametersCreateInfoKHR - for VideoEncodeH265SessionParametersCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { - type Target = VideoEncodeH265SessionParametersCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH265SessionParametersCreateInfoEXT<'a> { + #[inline] pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self { - self.inner.max_vps_std_count = max_vps_std_count; + self.max_vps_std_count = max_vps_std_count; self } + #[inline] pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.inner.max_sps_std_count = max_sps_std_count; + self.max_sps_std_count = max_sps_std_count; self } + #[inline] pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.inner.max_pps_std_count = max_pps_std_count; + self.max_pps_std_count = max_pps_std_count; self } + #[inline] pub fn parameters_add_info( mut self, - parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT, + parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT<'a>, ) -> Self { - self.inner.p_parameters_add_info = parameters_add_info; + self.p_parameters_add_info = parameters_add_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265VclFrameInfoEXT { +pub struct VideoEncodeH265VclFrameInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT<'a>, pub nalu_slice_segment_entry_count: u32, - pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentEXT, + pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentEXT<'a>, pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT { +impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT, @@ -52562,70 +34580,43 @@ impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT { nalu_slice_segment_entry_count: u32::default(), p_nalu_slice_segment_entries: ::std::ptr::null(), p_current_picture_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265VclFrameInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { - VideoEncodeH265VclFrameInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> { - inner: VideoEncodeH265VclFrameInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { - type Target = VideoEncodeH265VclFrameInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT<'_> {} +impl<'a> VideoEncodeH265VclFrameInfoEXT<'a> { + #[inline] pub fn reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT, + reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT<'a>, ) -> Self { - self.inner.p_reference_final_lists = reference_final_lists; + self.p_reference_final_lists = reference_final_lists; self } + #[inline] pub fn nalu_slice_segment_entries( mut self, nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentEXT], ) -> Self { - self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _; - self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr(); + self.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _; + self.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr(); self } + #[inline] pub fn current_picture_info( mut self, current_picture_info: &'a StdVideoEncodeH265PictureInfo, ) -> Self { - self.inner.p_current_picture_info = current_picture_info; + self.p_current_picture_info = current_picture_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265EmitPictureParametersEXT { +pub struct VideoEncodeH265EmitPictureParametersEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vps_id: u8, @@ -52634,8 +34625,9 @@ pub struct VideoEncodeH265EmitPictureParametersEXT { pub emit_sps_enable: Bool32, pub pps_id_entry_count: u32, pub pps_id_entries: *const u8, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265EmitPictureParametersEXT { +impl ::std::default::Default for VideoEncodeH265EmitPictureParametersEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT, @@ -52646,76 +34638,52 @@ impl ::std::default::Default for VideoEncodeH265EmitPictureParametersEXT { emit_sps_enable: Bool32::default(), pps_id_entry_count: u32::default(), pps_id_entries: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265EmitPictureParametersEXT { - pub fn builder<'a>() -> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { - VideoEncodeH265EmitPictureParametersEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { - inner: VideoEncodeH265EmitPictureParametersEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { - type Target = VideoEncodeH265EmitPictureParametersEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265EmitPictureParametersEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersEXT<'_> {} +impl<'a> VideoEncodeH265EmitPictureParametersEXT<'a> { + #[inline] pub fn vps_id(mut self, vps_id: u8) -> Self { - self.inner.vps_id = vps_id; + self.vps_id = vps_id; self } + #[inline] pub fn sps_id(mut self, sps_id: u8) -> Self { - self.inner.sps_id = sps_id; + self.sps_id = sps_id; self } + #[inline] pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self { - self.inner.emit_vps_enable = emit_vps_enable.into(); + self.emit_vps_enable = emit_vps_enable.into(); self } + #[inline] pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { - self.inner.emit_sps_enable = emit_sps_enable.into(); + self.emit_sps_enable = emit_sps_enable.into(); self } + #[inline] pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { - self.inner.pps_id_entry_count = pps_id_entries.len() as _; - self.inner.pps_id_entries = pps_id_entries.as_ptr(); + self.pps_id_entry_count = pps_id_entries.len() as _; + self.pps_id_entries = pps_id_entries.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265EmitPictureParametersEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265NaluSliceSegmentEXT { +pub struct VideoEncodeH265NaluSliceSegmentEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub ctb_count: u32, - pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsEXT<'a>, pub p_slice_segment_header_std: *const StdVideoEncodeH265SliceSegmentHeader, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentEXT { +impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT, @@ -52723,64 +34691,38 @@ impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentEXT { ctb_count: u32::default(), p_reference_final_lists: ::std::ptr::null(), p_slice_segment_header_std: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265NaluSliceSegmentEXT { - pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> { - VideoEncodeH265NaluSliceSegmentEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> { - inner: VideoEncodeH265NaluSliceSegmentEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> { - type Target = VideoEncodeH265NaluSliceSegmentEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265NaluSliceSegmentEXTBuilder<'a> { +impl<'a> VideoEncodeH265NaluSliceSegmentEXT<'a> { + #[inline] pub fn ctb_count(mut self, ctb_count: u32) -> Self { - self.inner.ctb_count = ctb_count; + self.ctb_count = ctb_count; self } + #[inline] pub fn reference_final_lists( mut self, - reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT, + reference_final_lists: &'a VideoEncodeH265ReferenceListsEXT<'a>, ) -> Self { - self.inner.p_reference_final_lists = reference_final_lists; + self.p_reference_final_lists = reference_final_lists; self } + #[inline] pub fn slice_segment_header_std( mut self, slice_segment_header_std: &'a StdVideoEncodeH265SliceSegmentHeader, ) -> Self { - self.inner.p_slice_segment_header_std = slice_segment_header_std; + self.p_slice_segment_header_std = slice_segment_header_std; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265NaluSliceSegmentEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265RateControlInfoEXT { +pub struct VideoEncodeH265RateControlInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub gop_frame_count: u32, @@ -52788,8 +34730,9 @@ pub struct VideoEncodeH265RateControlInfoEXT { pub consecutive_b_frame_count: u32, pub rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT, pub sub_layer_count: u8, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT { +impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT, @@ -52799,65 +34742,40 @@ impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT { consecutive_b_frame_count: u32::default(), rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT::default(), sub_layer_count: u8::default(), + _marker: PhantomData, } } } -impl VideoEncodeH265RateControlInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> { - VideoEncodeH265RateControlInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> { - inner: VideoEncodeH265RateControlInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {} -unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> { - type Target = VideoEncodeH265RateControlInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> { +unsafe impl ExtendsVideoEncodeRateControlInfoKHR for VideoEncodeH265RateControlInfoEXT<'_> {} +impl<'a> VideoEncodeH265RateControlInfoEXT<'a> { + #[inline] pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { - self.inner.gop_frame_count = gop_frame_count; + self.gop_frame_count = gop_frame_count; self } + #[inline] pub fn idr_period(mut self, idr_period: u32) -> Self { - self.inner.idr_period = idr_period; + self.idr_period = idr_period; self } + #[inline] pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { - self.inner.consecutive_b_frame_count = consecutive_b_frame_count; + self.consecutive_b_frame_count = consecutive_b_frame_count; self } + #[inline] pub fn rate_control_structure( mut self, rate_control_structure: VideoEncodeH265RateControlStructureFlagsEXT, ) -> Self { - self.inner.rate_control_structure = rate_control_structure; + self.rate_control_structure = rate_control_structure; self } + #[inline] pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self { - self.inner.sub_layer_count = sub_layer_count; + self.sub_layer_count = sub_layer_count; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265RateControlInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -52869,48 +34787,21 @@ pub struct VideoEncodeH265QpEXT { pub qp_b: i32, } impl VideoEncodeH265QpEXT { - pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> { - VideoEncodeH265QpEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265QpEXTBuilder<'a> { - inner: VideoEncodeH265QpEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> { - type Target = VideoEncodeH265QpEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265QpEXTBuilder<'a> { + #[inline] pub fn qp_i(mut self, qp_i: i32) -> Self { - self.inner.qp_i = qp_i; + self.qp_i = qp_i; self } + #[inline] pub fn qp_p(mut self, qp_p: i32) -> Self { - self.inner.qp_p = qp_p; + self.qp_p = qp_p; self } + #[inline] pub fn qp_b(mut self, qp_b: i32) -> Self { - self.inner.qp_b = qp_b; + self.qp_b = qp_b; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265QpEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -52922,54 +34813,27 @@ pub struct VideoEncodeH265FrameSizeEXT { pub frame_b_size: u32, } impl VideoEncodeH265FrameSizeEXT { - pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> { - VideoEncodeH265FrameSizeEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> { - inner: VideoEncodeH265FrameSizeEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> { - type Target = VideoEncodeH265FrameSizeEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> { + #[inline] pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { - self.inner.frame_i_size = frame_i_size; + self.frame_i_size = frame_i_size; self } + #[inline] pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { - self.inner.frame_p_size = frame_p_size; + self.frame_p_size = frame_p_size; self } + #[inline] pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { - self.inner.frame_b_size = frame_b_size; + self.frame_b_size = frame_b_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265FrameSizeEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265RateControlLayerInfoEXT { +pub struct VideoEncodeH265RateControlLayerInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub temporal_id: u8, @@ -52981,8 +34845,9 @@ pub struct VideoEncodeH265RateControlLayerInfoEXT { pub max_qp: VideoEncodeH265QpEXT, pub use_max_frame_size: Bool32, pub max_frame_size: VideoEncodeH265FrameSizeEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT { +impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT, @@ -52996,225 +34861,146 @@ impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT { max_qp: VideoEncodeH265QpEXT::default(), use_max_frame_size: Bool32::default(), max_frame_size: VideoEncodeH265FrameSizeEXT::default(), + _marker: PhantomData, } } } -impl VideoEncodeH265RateControlLayerInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { - VideoEncodeH265RateControlLayerInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { - inner: VideoEncodeH265RateControlLayerInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR - for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> + for VideoEncodeH265RateControlLayerInfoEXT<'_> { } -unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { - type Target = VideoEncodeH265RateControlLayerInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH265RateControlLayerInfoEXT<'a> { + #[inline] pub fn temporal_id(mut self, temporal_id: u8) -> Self { - self.inner.temporal_id = temporal_id; + self.temporal_id = temporal_id; self } + #[inline] pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { - self.inner.use_initial_rc_qp = use_initial_rc_qp.into(); + self.use_initial_rc_qp = use_initial_rc_qp.into(); self } + #[inline] pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self { - self.inner.initial_rc_qp = initial_rc_qp; + self.initial_rc_qp = initial_rc_qp; self } + #[inline] pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { - self.inner.use_min_qp = use_min_qp.into(); + self.use_min_qp = use_min_qp.into(); self } + #[inline] pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self { - self.inner.min_qp = min_qp; + self.min_qp = min_qp; self } + #[inline] pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { - self.inner.use_max_qp = use_max_qp.into(); + self.use_max_qp = use_max_qp.into(); self } + #[inline] pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self { - self.inner.max_qp = max_qp; + self.max_qp = max_qp; self } + #[inline] pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { - self.inner.use_max_frame_size = use_max_frame_size.into(); + self.use_max_frame_size = use_max_frame_size.into(); self } + #[inline] pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self { - self.inner.max_frame_size = max_frame_size; + self.max_frame_size = max_frame_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265ProfileEXT { +pub struct VideoEncodeH265ProfileEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub std_profile_idc: StdVideoH265ProfileIdc, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265ProfileEXT { +impl ::std::default::Default for VideoEncodeH265ProfileEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_PROFILE_EXT, p_next: ::std::ptr::null(), std_profile_idc: StdVideoH265ProfileIdc::default(), + _marker: PhantomData, } } } -impl VideoEncodeH265ProfileEXT { - pub fn builder<'a>() -> VideoEncodeH265ProfileEXTBuilder<'a> { - VideoEncodeH265ProfileEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265ProfileEXTBuilder<'a> { - inner: VideoEncodeH265ProfileEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXT {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXTBuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXT {} -impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileEXTBuilder<'a> { - type Target = VideoEncodeH265ProfileEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265ProfileEXTBuilder<'a> { +unsafe impl ExtendsVideoProfileKHR for VideoEncodeH265ProfileEXT<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileEXT<'_> {} +unsafe impl ExtendsFormatProperties2 for VideoEncodeH265ProfileEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoEncodeH265ProfileEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for VideoEncodeH265ProfileEXT<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoEncodeH265ProfileEXT<'_> {} +impl<'a> VideoEncodeH265ProfileEXT<'a> { + #[inline] pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { - self.inner.std_profile_idc = std_profile_idc; + self.std_profile_idc = std_profile_idc; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265ProfileEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265DpbSlotInfoEXT { +pub struct VideoEncodeH265DpbSlotInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub slot_index: i8, pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT { +impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT, p_next: ::std::ptr::null(), slot_index: i8::default(), p_std_reference_info: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265DpbSlotInfoEXT { - pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { - VideoEncodeH265DpbSlotInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { - inner: VideoEncodeH265DpbSlotInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { - type Target = VideoEncodeH265DpbSlotInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { +impl<'a> VideoEncodeH265DpbSlotInfoEXT<'a> { + #[inline] pub fn slot_index(mut self, slot_index: i8) -> Self { - self.inner.slot_index = slot_index; + self.slot_index = slot_index; self } + #[inline] pub fn std_reference_info( mut self, std_reference_info: &'a StdVideoEncodeH265ReferenceInfo, ) -> Self { - self.inner.p_std_reference_info = std_reference_info; + self.p_std_reference_info = std_reference_info; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct VideoEncodeH265ReferenceListsEXT { +pub struct VideoEncodeH265ReferenceListsEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub reference_list0_entry_count: u8, - pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT<'a>, pub reference_list1_entry_count: u8, - pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT<'a>, pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for VideoEncodeH265ReferenceListsEXT { +impl ::std::default::Default for VideoEncodeH265ReferenceListsEXT<'_> { fn default() -> Self { Self { s_type: StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT, @@ -53224,140 +35010,83 @@ impl ::std::default::Default for VideoEncodeH265ReferenceListsEXT { reference_list1_entry_count: u8::default(), p_reference_list1_entries: ::std::ptr::null(), p_reference_modifications: ::std::ptr::null(), + _marker: PhantomData, } } } -impl VideoEncodeH265ReferenceListsEXT { - pub fn builder<'a>() -> VideoEncodeH265ReferenceListsEXTBuilder<'a> { - VideoEncodeH265ReferenceListsEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct VideoEncodeH265ReferenceListsEXTBuilder<'a> { - inner: VideoEncodeH265ReferenceListsEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for VideoEncodeH265ReferenceListsEXTBuilder<'a> { - type Target = VideoEncodeH265ReferenceListsEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for VideoEncodeH265ReferenceListsEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> VideoEncodeH265ReferenceListsEXTBuilder<'a> { +impl<'a> VideoEncodeH265ReferenceListsEXT<'a> { + #[inline] pub fn reference_list0_entries( mut self, reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], ) -> Self { - self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; - self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self.reference_list0_entry_count = reference_list0_entries.len() as _; + self.p_reference_list0_entries = reference_list0_entries.as_ptr(); self } + #[inline] pub fn reference_list1_entries( mut self, reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], ) -> Self { - self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; - self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self.reference_list1_entry_count = reference_list1_entries.len() as _; + self.p_reference_list1_entries = reference_list1_entries.as_ptr(); self } + #[inline] pub fn reference_modifications( mut self, reference_modifications: &'a StdVideoEncodeH265ReferenceModifications, ) -> Self { - self.inner.p_reference_modifications = reference_modifications; + self.p_reference_modifications = reference_modifications; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> VideoEncodeH265ReferenceListsEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV { +pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub inherited_viewport_scissor2_d: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV { +impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, p_next: ::std::ptr::null_mut(), inherited_viewport_scissor2_d: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceInheritedViewportScissorFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { - PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { - inner: PhysicalDeviceInheritedViewportScissorFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> + for PhysicalDeviceInheritedViewportScissorFeaturesNV<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV<'_> {} +impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { + #[inline] pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self { - self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into(); + self.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferInheritanceViewportScissorInfoNV { +pub struct CommandBufferInheritanceViewportScissorInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub viewport_scissor2_d: Bool32, pub viewport_depth_count: u32, pub p_viewport_depths: *const Viewport, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV { +impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV, @@ -53365,446 +35094,242 @@ impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV { viewport_scissor2_d: Bool32::default(), viewport_depth_count: u32::default(), p_viewport_depths: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CommandBufferInheritanceViewportScissorInfoNV { - pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { - CommandBufferInheritanceViewportScissorInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { - inner: CommandBufferInheritanceViewportScissorInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsCommandBufferInheritanceInfo - for CommandBufferInheritanceViewportScissorInfoNVBuilder<'_> + for CommandBufferInheritanceViewportScissorInfoNV<'_> { } -unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV {} -impl<'a> ::std::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { - type Target = CommandBufferInheritanceViewportScissorInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { +impl<'a> CommandBufferInheritanceViewportScissorInfoNV<'a> { + #[inline] pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self { - self.inner.viewport_scissor2_d = viewport_scissor2_d.into(); + self.viewport_scissor2_d = viewport_scissor2_d.into(); self } + #[inline] pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self { - self.inner.viewport_depth_count = viewport_depth_count; + self.viewport_depth_count = viewport_depth_count; self } + #[inline] pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self { - self.inner.p_viewport_depths = viewport_depths; + self.p_viewport_depths = viewport_depths; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferInheritanceViewportScissorInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { +pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub ycbcr2plane444_formats: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, p_next: ::std::ptr::null_mut(), ycbcr2plane444_formats: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { - PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> { + #[inline] pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self { - self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into(); + self.ycbcr2plane444_formats = ycbcr2plane444_formats.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceProvokingVertexFeaturesEXT { +pub struct PhysicalDeviceProvokingVertexFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub provoking_vertex_last: Bool32, pub transform_feedback_preserves_provoking_vertex: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, p_next: ::std::ptr::null_mut(), provoking_vertex_last: Bool32::default(), transform_feedback_preserves_provoking_vertex: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceProvokingVertexFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { - PhysicalDeviceProvokingVertexFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceProvokingVertexFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceProvokingVertexFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceProvokingVertexFeaturesEXT<'a> { + #[inline] pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self { - self.inner.provoking_vertex_last = provoking_vertex_last.into(); + self.provoking_vertex_last = provoking_vertex_last.into(); self } + #[inline] pub fn transform_feedback_preserves_provoking_vertex( mut self, transform_feedback_preserves_provoking_vertex: bool, ) -> Self { - self.inner.transform_feedback_preserves_provoking_vertex = + self.transform_feedback_preserves_provoking_vertex = transform_feedback_preserves_provoking_vertex.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceProvokingVertexPropertiesEXT { +pub struct PhysicalDeviceProvokingVertexPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub provoking_vertex_mode_per_pipeline: Bool32, pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, p_next: ::std::ptr::null_mut(), provoking_vertex_mode_per_pipeline: Bool32::default(), transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceProvokingVertexPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { - PhysicalDeviceProvokingVertexPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceProvokingVertexPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceProvokingVertexPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceProvokingVertexPropertiesEXT<'a> { + #[inline] pub fn provoking_vertex_mode_per_pipeline( mut self, provoking_vertex_mode_per_pipeline: bool, ) -> Self { - self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into(); + self.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into(); self } + #[inline] pub fn transform_feedback_preserves_triangle_fan_provoking_vertex( mut self, transform_feedback_preserves_triangle_fan_provoking_vertex: bool, ) -> Self { - self.inner - .transform_feedback_preserves_triangle_fan_provoking_vertex = + self.transform_feedback_preserves_triangle_fan_provoking_vertex = transform_feedback_preserves_triangle_fan_provoking_vertex.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT { +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub provoking_vertex_mode: ProvokingVertexModeEXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT { +impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, p_next: ::std::ptr::null(), provoking_vertex_mode: ProvokingVertexModeEXT::default(), + _marker: PhantomData, } } } -impl PipelineRasterizationProvokingVertexStateCreateInfoEXT { - pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { - PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { - inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_> + for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'_> { } -unsafe impl ExtendsPipelineRasterizationStateCreateInfo - for PipelineRasterizationProvokingVertexStateCreateInfoEXT -{ -} -impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { - type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut - for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> -{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { +impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { + #[inline] pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self { - self.inner.provoking_vertex_mode = provoking_vertex_mode; + self.provoking_vertex_mode = provoking_vertex_mode; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CuModuleCreateInfoNVX { +pub struct CuModuleCreateInfoNVX<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub data_size: usize, pub p_data: *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CuModuleCreateInfoNVX { +impl ::std::default::Default for CuModuleCreateInfoNVX<'_> { fn default() -> Self { Self { s_type: StructureType::CU_MODULE_CREATE_INFO_NVX, p_next: ::std::ptr::null(), data_size: usize::default(), p_data: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CuModuleCreateInfoNVX { - pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> { - CuModuleCreateInfoNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CuModuleCreateInfoNVXBuilder<'a> { - inner: CuModuleCreateInfoNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> { - type Target = CuModuleCreateInfoNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CuModuleCreateInfoNVXBuilder<'a> { +impl<'a> CuModuleCreateInfoNVX<'a> { + #[inline] pub fn data(mut self, data: &'a [u8]) -> Self { - self.inner.data_size = data.len(); - self.inner.p_data = data.as_ptr() as *const c_void; + self.data_size = data.len(); + self.p_data = data.as_ptr() as *const c_void; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CuModuleCreateInfoNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CuFunctionCreateInfoNVX { +pub struct CuFunctionCreateInfoNVX<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub module: CuModuleNVX, pub p_name: *const c_char, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CuFunctionCreateInfoNVX { +impl ::std::default::Default for CuFunctionCreateInfoNVX<'_> { fn default() -> Self { Self { s_type: StructureType::CU_FUNCTION_CREATE_INFO_NVX, p_next: ::std::ptr::null(), module: CuModuleNVX::default(), p_name: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CuFunctionCreateInfoNVX { - pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> { - CuFunctionCreateInfoNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CuFunctionCreateInfoNVXBuilder<'a> { - inner: CuFunctionCreateInfoNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> { - type Target = CuFunctionCreateInfoNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CuFunctionCreateInfoNVXBuilder<'a> { +impl<'a> CuFunctionCreateInfoNVX<'a> { + #[inline] pub fn module(mut self, module: CuModuleNVX) -> Self { - self.inner.module = module; + self.module = module; self } + #[inline] pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { - self.inner.p_name = name.as_ptr(); + self.p_name = name.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CuFunctionCreateInfoNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CuLaunchInfoNVX { +pub struct CuLaunchInfoNVX<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub function: CuFunctionNVX, @@ -53819,8 +35344,9 @@ pub struct CuLaunchInfoNVX { pub p_params: *const *const c_void, pub extra_count: usize, pub p_extras: *const *const c_void, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CuLaunchInfoNVX { +impl ::std::default::Default for CuLaunchInfoNVX<'_> { fn default() -> Self { Self { s_type: StructureType::CU_LAUNCH_INFO_NVX, @@ -53837,149 +35363,98 @@ impl ::std::default::Default for CuLaunchInfoNVX { p_params: ::std::ptr::null(), extra_count: usize::default(), p_extras: ::std::ptr::null(), + _marker: PhantomData, } } } -impl CuLaunchInfoNVX { - pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> { - CuLaunchInfoNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CuLaunchInfoNVXBuilder<'a> { - inner: CuLaunchInfoNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> { - type Target = CuLaunchInfoNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CuLaunchInfoNVXBuilder<'a> { +impl<'a> CuLaunchInfoNVX<'a> { + #[inline] pub fn function(mut self, function: CuFunctionNVX) -> Self { - self.inner.function = function; + self.function = function; self } + #[inline] pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { - self.inner.grid_dim_x = grid_dim_x; + self.grid_dim_x = grid_dim_x; self } + #[inline] pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { - self.inner.grid_dim_y = grid_dim_y; + self.grid_dim_y = grid_dim_y; self } + #[inline] pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { - self.inner.grid_dim_z = grid_dim_z; + self.grid_dim_z = grid_dim_z; self } + #[inline] pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { - self.inner.block_dim_x = block_dim_x; + self.block_dim_x = block_dim_x; self } + #[inline] pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { - self.inner.block_dim_y = block_dim_y; + self.block_dim_y = block_dim_y; self } + #[inline] pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { - self.inner.block_dim_z = block_dim_z; + self.block_dim_z = block_dim_z; self } + #[inline] pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { - self.inner.shared_mem_bytes = shared_mem_bytes; + self.shared_mem_bytes = shared_mem_bytes; self } + #[inline] pub fn params(mut self, params: &'a [*const c_void]) -> Self { - self.inner.param_count = params.len(); - self.inner.p_params = params.as_ptr(); + self.param_count = params.len(); + self.p_params = params.as_ptr(); self } + #[inline] pub fn extras(mut self, extras: &'a [*const c_void]) -> Self { - self.inner.extra_count = extras.len(); - self.inner.p_extras = extras.as_ptr(); + self.extra_count = extras.len(); + self.p_extras = extras.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CuLaunchInfoNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderIntegerDotProductFeatures { +pub struct PhysicalDeviceShaderIntegerDotProductFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub shader_integer_dot_product: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures { +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, p_next: ::std::ptr::null_mut(), shader_integer_dot_product: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceShaderIntegerDotProductFeatures { - pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { - PhysicalDeviceShaderIntegerDotProductFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { - inner: PhysicalDeviceShaderIntegerDotProductFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { - type Target = PhysicalDeviceShaderIntegerDotProductFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {} +impl<'a> PhysicalDeviceShaderIntegerDotProductFeatures<'a> { + #[inline] pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { - self.inner.shader_integer_dot_product = shader_integer_dot_product.into(); + self.shader_integer_dot_product = shader_integer_dot_product.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceShaderIntegerDotProductProperties { +pub struct PhysicalDeviceShaderIntegerDotProductProperties<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub integer_dot_product8_bit_unsigned_accelerated: Bool32, @@ -54013,314 +35488,293 @@ pub struct PhysicalDeviceShaderIntegerDotProductProperties { pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties { +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties<'_> { fn default() -> Self { - Self { s_type : StructureType :: PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () } + Self { s_type : StructureType :: PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , _marker : PhantomData , } } } -impl PhysicalDeviceShaderIntegerDotProductProperties { - pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { - PhysicalDeviceShaderIntegerDotProductPropertiesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { - inner: PhysicalDeviceShaderIntegerDotProductProperties, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_> + for PhysicalDeviceShaderIntegerDotProductProperties<'_> { } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {} -impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { - type Target = PhysicalDeviceShaderIntegerDotProductProperties; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { +impl<'a> PhysicalDeviceShaderIntegerDotProductProperties<'a> { + #[inline] pub fn integer_dot_product8_bit_unsigned_accelerated( mut self, integer_dot_product8_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product8_bit_unsigned_accelerated = + self.integer_dot_product8_bit_unsigned_accelerated = integer_dot_product8_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product8_bit_signed_accelerated( mut self, integer_dot_product8_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product8_bit_signed_accelerated = + self.integer_dot_product8_bit_signed_accelerated = integer_dot_product8_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product8_bit_mixed_signedness_accelerated( mut self, integer_dot_product8_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product8_bit_mixed_signedness_accelerated = + self.integer_dot_product8_bit_mixed_signedness_accelerated = integer_dot_product8_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product4x8_bit_packed_unsigned_accelerated = + self.integer_dot_product4x8_bit_packed_unsigned_accelerated = integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product4x8_bit_packed_signed_accelerated( mut self, integer_dot_product4x8_bit_packed_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product4x8_bit_packed_signed_accelerated = + self.integer_dot_product4x8_bit_packed_signed_accelerated = integer_dot_product4x8_bit_packed_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + self.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product16_bit_unsigned_accelerated( mut self, integer_dot_product16_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product16_bit_unsigned_accelerated = + self.integer_dot_product16_bit_unsigned_accelerated = integer_dot_product16_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product16_bit_signed_accelerated( mut self, integer_dot_product16_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product16_bit_signed_accelerated = + self.integer_dot_product16_bit_signed_accelerated = integer_dot_product16_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product16_bit_mixed_signedness_accelerated( mut self, integer_dot_product16_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product16_bit_mixed_signedness_accelerated = + self.integer_dot_product16_bit_mixed_signedness_accelerated = integer_dot_product16_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product32_bit_unsigned_accelerated( mut self, integer_dot_product32_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product32_bit_unsigned_accelerated = + self.integer_dot_product32_bit_unsigned_accelerated = integer_dot_product32_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product32_bit_signed_accelerated( mut self, integer_dot_product32_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product32_bit_signed_accelerated = + self.integer_dot_product32_bit_signed_accelerated = integer_dot_product32_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product32_bit_mixed_signedness_accelerated( mut self, integer_dot_product32_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product32_bit_mixed_signedness_accelerated = + self.integer_dot_product32_bit_mixed_signedness_accelerated = integer_dot_product32_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product64_bit_unsigned_accelerated( mut self, integer_dot_product64_bit_unsigned_accelerated: bool, ) -> Self { - self.inner.integer_dot_product64_bit_unsigned_accelerated = + self.integer_dot_product64_bit_unsigned_accelerated = integer_dot_product64_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product64_bit_signed_accelerated( mut self, integer_dot_product64_bit_signed_accelerated: bool, ) -> Self { - self.inner.integer_dot_product64_bit_signed_accelerated = + self.integer_dot_product64_bit_signed_accelerated = integer_dot_product64_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product64_bit_mixed_signedness_accelerated( mut self, integer_dot_product64_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product64_bit_mixed_signedness_accelerated = + self.integer_dot_product64_bit_mixed_signedness_accelerated = integer_dot_product64_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + self.integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, ) -> Self { - self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; self } + #[inline] pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating16_bit_signed_accelerated = integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating32_bit_signed_accelerated = integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + self.integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + self.integer_dot_product_accumulating_saturating64_bit_signed_accelerated = integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); self } + #[inline] pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( mut self, integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, ) -> Self { - self.inner - .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + self.integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDrmPropertiesEXT { +pub struct PhysicalDeviceDrmPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub has_primary: Bool32, @@ -54329,8 +35783,9 @@ pub struct PhysicalDeviceDrmPropertiesEXT { pub primary_minor: i64, pub render_major: i64, pub render_minor: i64, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT { +impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT, @@ -54341,149 +35796,94 @@ impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT { primary_minor: i64::default(), render_major: i64::default(), render_minor: i64::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDrmPropertiesEXT { - pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { - PhysicalDeviceDrmPropertiesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> { - inner: PhysicalDeviceDrmPropertiesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> { - type Target = PhysicalDeviceDrmPropertiesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceDrmPropertiesEXT<'a> { + #[inline] pub fn has_primary(mut self, has_primary: bool) -> Self { - self.inner.has_primary = has_primary.into(); + self.has_primary = has_primary.into(); self } + #[inline] pub fn has_render(mut self, has_render: bool) -> Self { - self.inner.has_render = has_render.into(); + self.has_render = has_render.into(); self } + #[inline] pub fn primary_major(mut self, primary_major: i64) -> Self { - self.inner.primary_major = primary_major; + self.primary_major = primary_major; self } + #[inline] pub fn primary_minor(mut self, primary_minor: i64) -> Self { - self.inner.primary_minor = primary_minor; + self.primary_minor = primary_minor; self } + #[inline] pub fn render_major(mut self, render_major: i64) -> Self { - self.inner.render_major = render_major; + self.render_major = render_major; self } + #[inline] pub fn render_minor(mut self, render_minor: i64) -> Self { - self.inner.render_minor = render_minor; + self.render_minor = render_minor; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDrmPropertiesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV { +pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub ray_tracing_motion_blur: Bool32, pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV { +impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, p_next: ::std::ptr::null_mut(), ray_tracing_motion_blur: Bool32::default(), ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRayTracingMotionBlurFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { - PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { - inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {} +impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + #[inline] pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self { - self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); + self.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); self } + #[inline] pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect( mut self, ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, ) -> Self { - self.inner - .ray_tracing_motion_blur_pipeline_trace_rays_indirect = + self.ray_tracing_motion_blur_pipeline_trace_rays_indirect = ray_tracing_motion_blur_pipeline_trace_rays_indirect.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureGeometryMotionTrianglesDataNV { +pub struct AccelerationStructureGeometryMotionTrianglesDataNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub vertex_data: DeviceOrHostAddressConstKHR, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV { +impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV") .field("s_type", &self.s_type) @@ -54492,123 +35892,61 @@ impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV { .finish() } } -impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV { +impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV, p_next: ::std::ptr::null(), vertex_data: DeviceOrHostAddressConstKHR::default(), + _marker: PhantomData, } } } -impl AccelerationStructureGeometryMotionTrianglesDataNV { - pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { - AccelerationStructureGeometryMotionTrianglesDataNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { - inner: AccelerationStructureGeometryMotionTrianglesDataNV, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR - for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'_> + for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { } -unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR - for AccelerationStructureGeometryMotionTrianglesDataNV -{ -} -impl<'a> ::std::ops::Deref for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { - type Target = AccelerationStructureGeometryMotionTrianglesDataNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { +impl<'a> AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + #[inline] pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { - self.inner.vertex_data = vertex_data; + self.vertex_data = vertex_data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AccelerationStructureMotionInfoNV { +pub struct AccelerationStructureMotionInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub max_instances: u32, pub flags: AccelerationStructureMotionInfoFlagsNV, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureMotionInfoNV { +impl ::std::default::Default for AccelerationStructureMotionInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV, p_next: ::std::ptr::null(), max_instances: u32::default(), flags: AccelerationStructureMotionInfoFlagsNV::default(), + _marker: PhantomData, } } } -impl AccelerationStructureMotionInfoNV { - pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> { - AccelerationStructureMotionInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureMotionInfoNVBuilder<'a> { - inner: AccelerationStructureMotionInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsAccelerationStructureCreateInfoKHR - for AccelerationStructureMotionInfoNVBuilder<'_> -{ -} -unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV {} -impl<'a> ::std::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> { - type Target = AccelerationStructureMotionInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> { +unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV<'_> {} +impl<'a> AccelerationStructureMotionInfoNV<'a> { + #[inline] pub fn max_instances(mut self, max_instances: u32) -> Self { - self.inner.max_instances = max_instances; + self.max_instances = max_instances; self } + #[inline] pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureMotionInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -54633,100 +35971,86 @@ pub struct SRTDataNV { pub tz: f32, } impl SRTDataNV { - pub fn builder<'a>() -> SRTDataNVBuilder<'a> { - SRTDataNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SRTDataNVBuilder<'a> { - inner: SRTDataNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SRTDataNVBuilder<'a> { - type Target = SRTDataNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SRTDataNVBuilder<'a> { + #[inline] pub fn sx(mut self, sx: f32) -> Self { - self.inner.sx = sx; + self.sx = sx; self } + #[inline] pub fn a(mut self, a: f32) -> Self { - self.inner.a = a; + self.a = a; self } + #[inline] pub fn b(mut self, b: f32) -> Self { - self.inner.b = b; + self.b = b; self } + #[inline] pub fn pvx(mut self, pvx: f32) -> Self { - self.inner.pvx = pvx; + self.pvx = pvx; self } + #[inline] pub fn sy(mut self, sy: f32) -> Self { - self.inner.sy = sy; + self.sy = sy; self } + #[inline] pub fn c(mut self, c: f32) -> Self { - self.inner.c = c; + self.c = c; self } + #[inline] pub fn pvy(mut self, pvy: f32) -> Self { - self.inner.pvy = pvy; + self.pvy = pvy; self } + #[inline] pub fn sz(mut self, sz: f32) -> Self { - self.inner.sz = sz; + self.sz = sz; self } + #[inline] pub fn pvz(mut self, pvz: f32) -> Self { - self.inner.pvz = pvz; + self.pvz = pvz; self } + #[inline] pub fn qx(mut self, qx: f32) -> Self { - self.inner.qx = qx; + self.qx = qx; self } + #[inline] pub fn qy(mut self, qy: f32) -> Self { - self.inner.qy = qy; + self.qy = qy; self } + #[inline] pub fn qz(mut self, qz: f32) -> Self { - self.inner.qz = qz; + self.qz = qz; self } + #[inline] pub fn qw(mut self, qw: f32) -> Self { - self.inner.qw = qw; + self.qw = qw; self } + #[inline] pub fn tx(mut self, tx: f32) -> Self { - self.inner.tx = tx; + self.tx = tx; self } + #[inline] pub fn ty(mut self, ty: f32) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn tz(mut self, tz: f32) -> Self { - self.inner.tz = tz; + self.tz = tz; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SRTDataNV { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] @@ -54784,48 +36108,21 @@ impl fmt::Debug for AccelerationStructureMotionInstanceNV { } } impl AccelerationStructureMotionInstanceNV { - pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> { - AccelerationStructureMotionInstanceNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureMotionInstanceNVBuilder<'a> { - inner: AccelerationStructureMotionInstanceNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AccelerationStructureMotionInstanceNVBuilder<'a> { - type Target = AccelerationStructureMotionInstanceNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> { + #[inline] pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self { - self.inner.ty = ty; + self.ty = ty; self } + #[inline] pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self { - self.inner.data = data; + self.data = data; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureMotionInstanceNV { - self.inner - } } #[doc = ""] pub type RemoteAddressNV = c_void; @@ -54833,307 +36130,173 @@ pub type RemoteAddressNV = c_void; #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MemoryGetRemoteAddressInfoNV { +pub struct MemoryGetRemoteAddressInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub memory: DeviceMemory, pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryGetRemoteAddressInfoNV { +impl ::std::default::Default for MemoryGetRemoteAddressInfoNV<'_> { fn default() -> Self { Self { s_type: StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV, p_next: ::std::ptr::null(), memory: DeviceMemory::default(), handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, } } } -impl MemoryGetRemoteAddressInfoNV { - pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> { - MemoryGetRemoteAddressInfoNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> { - inner: MemoryGetRemoteAddressInfoNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> { - type Target = MemoryGetRemoteAddressInfoNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> { +impl<'a> MemoryGetRemoteAddressInfoNV<'a> { + #[inline] pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.inner.memory = memory; + self.memory = memory; self } + #[inline] pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.inner.handle_type = handle_type; + self.handle_type = handle_type; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MemoryGetRemoteAddressInfoNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImportMemoryBufferCollectionFUCHSIA { +pub struct ImportMemoryBufferCollectionFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub collection: BufferCollectionFUCHSIA, pub index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA { +impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, p_next: ::std::ptr::null(), collection: BufferCollectionFUCHSIA::default(), index: u32::default(), + _marker: PhantomData, } } } -impl ImportMemoryBufferCollectionFUCHSIA { - pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { - ImportMemoryBufferCollectionFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> { - inner: ImportMemoryBufferCollectionFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {} -impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { - type Target = ImportMemoryBufferCollectionFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA<'_> {} +impl<'a> ImportMemoryBufferCollectionFUCHSIA<'a> { + #[inline] pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { - self.inner.collection = collection; + self.collection = collection; self } + #[inline] pub fn index(mut self, index: u32) -> Self { - self.inner.index = index; + self.index = index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCollectionImageCreateInfoFUCHSIA { +pub struct BufferCollectionImageCreateInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub collection: BufferCollectionFUCHSIA, pub index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA { +impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, p_next: ::std::ptr::null(), collection: BufferCollectionFUCHSIA::default(), index: u32::default(), + _marker: PhantomData, } } } -impl BufferCollectionImageCreateInfoFUCHSIA { - pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { - BufferCollectionImageCreateInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { - inner: BufferCollectionImageCreateInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {} -unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {} -impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { - type Target = BufferCollectionImageCreateInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA<'_> {} +impl<'a> BufferCollectionImageCreateInfoFUCHSIA<'a> { + #[inline] pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { - self.inner.collection = collection; + self.collection = collection; self } + #[inline] pub fn index(mut self, index: u32) -> Self { - self.inner.index = index; + self.index = index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCollectionBufferCreateInfoFUCHSIA { +pub struct BufferCollectionBufferCreateInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub collection: BufferCollectionFUCHSIA, pub index: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA { +impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, p_next: ::std::ptr::null(), collection: BufferCollectionFUCHSIA::default(), index: u32::default(), + _marker: PhantomData, } } } -impl BufferCollectionBufferCreateInfoFUCHSIA { - pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { - BufferCollectionBufferCreateInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { - inner: BufferCollectionBufferCreateInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {} -unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {} -impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { - type Target = BufferCollectionBufferCreateInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA<'_> {} +impl<'a> BufferCollectionBufferCreateInfoFUCHSIA<'a> { + #[inline] pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { - self.inner.collection = collection; + self.collection = collection; self } + #[inline] pub fn index(mut self, index: u32) -> Self { - self.inner.index = index; + self.index = index; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCollectionCreateInfoFUCHSIA { +pub struct BufferCollectionCreateInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub collection_token: zx_handle_t, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA { +impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA, p_next: ::std::ptr::null(), collection_token: zx_handle_t::default(), + _marker: PhantomData, } } } -impl BufferCollectionCreateInfoFUCHSIA { - pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> { - BufferCollectionCreateInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> { - inner: BufferCollectionCreateInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> { - type Target = BufferCollectionCreateInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> { +impl<'a> BufferCollectionCreateInfoFUCHSIA<'a> { + #[inline] pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self { - self.inner.collection_token = collection_token; + self.collection_token = collection_token; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCollectionPropertiesFUCHSIA { +pub struct BufferCollectionPropertiesFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub memory_type_bits: u32, @@ -55141,14 +36304,15 @@ pub struct BufferCollectionPropertiesFUCHSIA { pub create_info_index: u32, pub sysmem_pixel_format: u64, pub format_features: FormatFeatureFlags, - pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>, pub sampler_ycbcr_conversion_components: ComponentMapping, pub suggested_ycbcr_model: SamplerYcbcrModelConversion, pub suggested_ycbcr_range: SamplerYcbcrRange, pub suggested_x_chroma_offset: ChromaLocation, pub suggested_y_chroma_offset: ChromaLocation, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA { +impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA, @@ -55164,106 +36328,89 @@ impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA { suggested_ycbcr_range: SamplerYcbcrRange::default(), suggested_x_chroma_offset: ChromaLocation::default(), suggested_y_chroma_offset: ChromaLocation::default(), + _marker: PhantomData, } } } -impl BufferCollectionPropertiesFUCHSIA { - pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> { - BufferCollectionPropertiesFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> { - inner: BufferCollectionPropertiesFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> { - type Target = BufferCollectionPropertiesFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> { +impl<'a> BufferCollectionPropertiesFUCHSIA<'a> { + #[inline] pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.inner.memory_type_bits = memory_type_bits; + self.memory_type_bits = memory_type_bits; self } + #[inline] pub fn buffer_count(mut self, buffer_count: u32) -> Self { - self.inner.buffer_count = buffer_count; + self.buffer_count = buffer_count; self } + #[inline] pub fn create_info_index(mut self, create_info_index: u32) -> Self { - self.inner.create_info_index = create_info_index; + self.create_info_index = create_info_index; self } + #[inline] pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { - self.inner.sysmem_pixel_format = sysmem_pixel_format; + self.sysmem_pixel_format = sysmem_pixel_format; self } + #[inline] pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { - self.inner.format_features = format_features; + self.format_features = format_features; self } + #[inline] pub fn sysmem_color_space_index( mut self, - sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>, ) -> Self { - self.inner.sysmem_color_space_index = sysmem_color_space_index; + self.sysmem_color_space_index = sysmem_color_space_index; self } + #[inline] pub fn sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> Self { - self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; self } + #[inline] pub fn suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> Self { - self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self.suggested_ycbcr_model = suggested_ycbcr_model; self } + #[inline] pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { - self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self.suggested_ycbcr_range = suggested_ycbcr_range; self } + #[inline] pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { - self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self.suggested_x_chroma_offset = suggested_x_chroma_offset; self } + #[inline] pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { - self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self.suggested_y_chroma_offset = suggested_y_chroma_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCollectionPropertiesFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferConstraintsInfoFUCHSIA { +pub struct BufferConstraintsInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub create_info: BufferCreateInfo, + pub create_info: BufferCreateInfo<'a>, pub required_format_features: FormatFeatureFlags, - pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferConstraintsInfoFUCHSIA { +impl ::std::default::Default for BufferConstraintsInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA, @@ -55271,128 +36418,76 @@ impl ::std::default::Default for BufferConstraintsInfoFUCHSIA { create_info: BufferCreateInfo::default(), required_format_features: FormatFeatureFlags::default(), buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + _marker: PhantomData, } } } -impl BufferConstraintsInfoFUCHSIA { - pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> { - BufferConstraintsInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferConstraintsInfoFUCHSIABuilder<'a> { - inner: BufferConstraintsInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> { - type Target = BufferConstraintsInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> { - pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self { - self.inner.create_info = create_info; +impl<'a> BufferConstraintsInfoFUCHSIA<'a> { + #[inline] + pub fn create_info(mut self, create_info: BufferCreateInfo<'a>) -> Self { + self.create_info = create_info; self } + #[inline] pub fn required_format_features( mut self, required_format_features: FormatFeatureFlags, ) -> Self { - self.inner.required_format_features = required_format_features; + self.required_format_features = required_format_features; self } + #[inline] pub fn buffer_collection_constraints( mut self, - buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, ) -> Self { - self.inner.buffer_collection_constraints = buffer_collection_constraints; + self.buffer_collection_constraints = buffer_collection_constraints; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferConstraintsInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct SysmemColorSpaceFUCHSIA { +pub struct SysmemColorSpaceFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub color_space: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SysmemColorSpaceFUCHSIA { +impl ::std::default::Default for SysmemColorSpaceFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::SYSMEM_COLOR_SPACE_FUCHSIA, p_next: ::std::ptr::null(), color_space: u32::default(), + _marker: PhantomData, } } } -impl SysmemColorSpaceFUCHSIA { - pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> { - SysmemColorSpaceFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct SysmemColorSpaceFUCHSIABuilder<'a> { - inner: SysmemColorSpaceFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> { - type Target = SysmemColorSpaceFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> { +impl<'a> SysmemColorSpaceFUCHSIA<'a> { + #[inline] pub fn color_space(mut self, color_space: u32) -> Self { - self.inner.color_space = color_space; + self.color_space = color_space; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> SysmemColorSpaceFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageFormatConstraintsInfoFUCHSIA { +pub struct ImageFormatConstraintsInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub image_create_info: ImageCreateInfo, + pub image_create_info: ImageCreateInfo<'a>, pub required_format_features: FormatFeatureFlags, pub flags: ImageFormatConstraintsFlagsFUCHSIA, pub sysmem_pixel_format: u64, pub color_space_count: u32, - pub p_color_spaces: *const SysmemColorSpaceFUCHSIA, + pub p_color_spaces: *const SysmemColorSpaceFUCHSIA<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA { +impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA, @@ -55403,78 +36498,55 @@ impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA { sysmem_pixel_format: u64::default(), color_space_count: u32::default(), p_color_spaces: ::std::ptr::null(), + _marker: PhantomData, } } } -impl ImageFormatConstraintsInfoFUCHSIA { - pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { - ImageFormatConstraintsInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> { - inner: ImageFormatConstraintsInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { - type Target = ImageFormatConstraintsInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { - pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self { - self.inner.image_create_info = image_create_info; +impl<'a> ImageFormatConstraintsInfoFUCHSIA<'a> { + #[inline] + pub fn image_create_info(mut self, image_create_info: ImageCreateInfo<'a>) -> Self { + self.image_create_info = image_create_info; self } + #[inline] pub fn required_format_features( mut self, required_format_features: FormatFeatureFlags, ) -> Self { - self.inner.required_format_features = required_format_features; + self.required_format_features = required_format_features; self } + #[inline] pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { - self.inner.sysmem_pixel_format = sysmem_pixel_format; + self.sysmem_pixel_format = sysmem_pixel_format; self } + #[inline] pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self { - self.inner.color_space_count = color_spaces.len() as _; - self.inner.p_color_spaces = color_spaces.as_ptr(); + self.color_space_count = color_spaces.len() as _; + self.p_color_spaces = color_spaces.as_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageConstraintsInfoFUCHSIA { +pub struct ImageConstraintsInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub format_constraints_count: u32, - pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA, - pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA<'a>, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, pub flags: ImageConstraintsInfoFlagsFUCHSIA, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageConstraintsInfoFUCHSIA { +impl ::std::default::Default for ImageConstraintsInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA, @@ -55483,65 +36555,39 @@ impl ::std::default::Default for ImageConstraintsInfoFUCHSIA { p_format_constraints: ::std::ptr::null(), buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), flags: ImageConstraintsInfoFlagsFUCHSIA::default(), + _marker: PhantomData, } } } -impl ImageConstraintsInfoFUCHSIA { - pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> { - ImageConstraintsInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageConstraintsInfoFUCHSIABuilder<'a> { - inner: ImageConstraintsInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> { - type Target = ImageConstraintsInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> { +impl<'a> ImageConstraintsInfoFUCHSIA<'a> { + #[inline] pub fn format_constraints( mut self, format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], ) -> Self { - self.inner.format_constraints_count = format_constraints.len() as _; - self.inner.p_format_constraints = format_constraints.as_ptr(); + self.format_constraints_count = format_constraints.len() as _; + self.p_format_constraints = format_constraints.as_ptr(); self } + #[inline] pub fn buffer_collection_constraints( mut self, - buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, ) -> Self { - self.inner.buffer_collection_constraints = buffer_collection_constraints; + self.buffer_collection_constraints = buffer_collection_constraints; self } + #[inline] pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self { - self.inner.flags = flags; + self.flags = flags; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageConstraintsInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct BufferCollectionConstraintsInfoFUCHSIA { +pub struct BufferCollectionConstraintsInfoFUCHSIA<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub min_buffer_count: u32, @@ -55549,8 +36595,9 @@ pub struct BufferCollectionConstraintsInfoFUCHSIA { pub min_buffer_count_for_camping: u32, pub min_buffer_count_for_dedicated_slack: u32, pub min_buffer_count_for_shared_slack: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA { +impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA<'_> { fn default() -> Self { Self { s_type: StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA, @@ -55560,141 +36607,89 @@ impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA { min_buffer_count_for_camping: u32::default(), min_buffer_count_for_dedicated_slack: u32::default(), min_buffer_count_for_shared_slack: u32::default(), + _marker: PhantomData, } } } -impl BufferCollectionConstraintsInfoFUCHSIA { - pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { - BufferCollectionConstraintsInfoFUCHSIABuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { - inner: BufferCollectionConstraintsInfoFUCHSIA, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { - type Target = BufferCollectionConstraintsInfoFUCHSIA; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { +impl<'a> BufferCollectionConstraintsInfoFUCHSIA<'a> { + #[inline] pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { - self.inner.min_buffer_count = min_buffer_count; + self.min_buffer_count = min_buffer_count; self } + #[inline] pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { - self.inner.max_buffer_count = max_buffer_count; + self.max_buffer_count = max_buffer_count; self } + #[inline] pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self { - self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping; + self.min_buffer_count_for_camping = min_buffer_count_for_camping; self } + #[inline] pub fn min_buffer_count_for_dedicated_slack( mut self, min_buffer_count_for_dedicated_slack: u32, ) -> Self { - self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; + self.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; self } + #[inline] pub fn min_buffer_count_for_shared_slack( mut self, min_buffer_count_for_shared_slack: u32, ) -> Self { - self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT { +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub format_rgba10x6_without_y_cb_cr_sampler: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, p_next: ::std::ptr::null_mut(), format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { - PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + #[inline] pub fn format_rgba10x6_without_y_cb_cr_sampler( mut self, format_rgba10x6_without_y_cb_cr_sampler: bool, ) -> Self { - self.inner.format_rgba10x6_without_y_cb_cr_sampler = + self.format_rgba10x6_without_y_cb_cr_sampler = format_rgba10x6_without_y_cb_cr_sampler.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct FormatProperties3 { +pub struct FormatProperties3<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub linear_tiling_features: FormatFeatureFlags2, pub optimal_tiling_features: FormatFeatureFlags2, pub buffer_features: FormatFeatureFlags2, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FormatProperties3 { +impl ::std::default::Default for FormatProperties3<'_> { fn default() -> Self { Self { s_type: StructureType::FORMAT_PROPERTIES_3, @@ -55702,116 +36697,61 @@ impl ::std::default::Default for FormatProperties3 { linear_tiling_features: FormatFeatureFlags2::default(), optimal_tiling_features: FormatFeatureFlags2::default(), buffer_features: FormatFeatureFlags2::default(), + _marker: PhantomData, } } } -impl FormatProperties3 { - pub fn builder<'a>() -> FormatProperties3Builder<'a> { - FormatProperties3Builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct FormatProperties3Builder<'a> { - inner: FormatProperties3, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {} -unsafe impl ExtendsFormatProperties2 for FormatProperties3 {} -impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> { - type Target = FormatProperties3; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> FormatProperties3Builder<'a> { +unsafe impl ExtendsFormatProperties2 for FormatProperties3<'_> {} +impl<'a> FormatProperties3<'a> { + #[inline] pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self { - self.inner.linear_tiling_features = linear_tiling_features; + self.linear_tiling_features = linear_tiling_features; self } + #[inline] pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self { - self.inner.optimal_tiling_features = optimal_tiling_features; + self.optimal_tiling_features = optimal_tiling_features; self } + #[inline] pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self { - self.inner.buffer_features = buffer_features; + self.buffer_features = buffer_features; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> FormatProperties3 { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DrmFormatModifierPropertiesList2EXT { +pub struct DrmFormatModifierPropertiesList2EXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub drm_format_modifier_count: u32, pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT { +impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT<'_> { fn default() -> Self { Self { s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, p_next: ::std::ptr::null_mut(), drm_format_modifier_count: u32::default(), p_drm_format_modifier_properties: ::std::ptr::null_mut(), + _marker: PhantomData, } } } -impl DrmFormatModifierPropertiesList2EXT { - pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> { - DrmFormatModifierPropertiesList2EXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> { - inner: DrmFormatModifierPropertiesList2EXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {} -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {} -impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> { - type Target = DrmFormatModifierPropertiesList2EXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> { +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT<'_> {} +impl<'a> DrmFormatModifierPropertiesList2EXT<'a> { + #[inline] pub fn drm_format_modifier_properties( mut self, drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], ) -> Self { - self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _; - self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrmFormatModifierPropertiesList2EXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -55823,57 +36763,30 @@ pub struct DrmFormatModifierProperties2EXT { pub drm_format_modifier_tiling_features: FormatFeatureFlags2, } impl DrmFormatModifierProperties2EXT { - pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> { - DrmFormatModifierProperties2EXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DrmFormatModifierProperties2EXTBuilder<'a> { - inner: DrmFormatModifierProperties2EXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> { - type Target = DrmFormatModifierProperties2EXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> { + #[inline] pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { - self.inner.drm_format_modifier = drm_format_modifier; + self.drm_format_modifier = drm_format_modifier; self } + #[inline] pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { - self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; self } + #[inline] pub fn drm_format_modifier_tiling_features( mut self, drm_format_modifier_tiling_features: FormatFeatureFlags2, ) -> Self { - self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DrmFormatModifierProperties2EXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AndroidHardwareBufferFormatProperties2ANDROID { +pub struct AndroidHardwareBufferFormatProperties2ANDROID<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub format: Format, @@ -55884,8 +36797,9 @@ pub struct AndroidHardwareBufferFormatProperties2ANDROID { pub suggested_ycbcr_range: SamplerYcbcrRange, pub suggested_x_chroma_offset: ChromaLocation, pub suggested_y_chroma_offset: ChromaLocation, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID { +impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID<'_> { fn default() -> Self { Self { s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID, @@ -55898,92 +36812,67 @@ impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID { suggested_ycbcr_range: SamplerYcbcrRange::default(), suggested_x_chroma_offset: ChromaLocation::default(), suggested_y_chroma_offset: ChromaLocation::default(), + _marker: PhantomData, } } } -impl AndroidHardwareBufferFormatProperties2ANDROID { - pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { - AndroidHardwareBufferFormatProperties2ANDROIDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { - inner: AndroidHardwareBufferFormatProperties2ANDROID, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID - for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_> + for AndroidHardwareBufferFormatProperties2ANDROID<'_> { } -unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID - for AndroidHardwareBufferFormatProperties2ANDROID -{ -} -impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { - type Target = AndroidHardwareBufferFormatProperties2ANDROID; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { +impl<'a> AndroidHardwareBufferFormatProperties2ANDROID<'a> { + #[inline] pub fn format(mut self, format: Format) -> Self { - self.inner.format = format; + self.format = format; self } + #[inline] pub fn external_format(mut self, external_format: u64) -> Self { - self.inner.external_format = external_format; + self.external_format = external_format; self } + #[inline] pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self { - self.inner.format_features = format_features; + self.format_features = format_features; self } + #[inline] pub fn sampler_ycbcr_conversion_components( mut self, sampler_ycbcr_conversion_components: ComponentMapping, ) -> Self { - self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; self } + #[inline] pub fn suggested_ycbcr_model( mut self, suggested_ycbcr_model: SamplerYcbcrModelConversion, ) -> Self { - self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self.suggested_ycbcr_model = suggested_ycbcr_model; self } + #[inline] pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { - self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self.suggested_ycbcr_range = suggested_ycbcr_range; self } + #[inline] pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { - self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self.suggested_x_chroma_offset = suggested_x_chroma_offset; self } + #[inline] pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { - self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self.suggested_y_chroma_offset = suggested_y_chroma_offset; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PipelineRenderingCreateInfo { +pub struct PipelineRenderingCreateInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub view_mask: u32, @@ -55991,8 +36880,9 @@ pub struct PipelineRenderingCreateInfo { pub p_color_attachment_formats: *const Format, pub depth_attachment_format: Format, pub stencil_attachment_format: Format, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRenderingCreateInfo { +impl ::std::default::Default for PipelineRenderingCreateInfo<'_> { fn default() -> Self { Self { s_type: StructureType::PIPELINE_RENDERING_CREATE_INFO, @@ -56002,65 +36892,39 @@ impl ::std::default::Default for PipelineRenderingCreateInfo { p_color_attachment_formats: ::std::ptr::null(), depth_attachment_format: Format::default(), stencil_attachment_format: Format::default(), + _marker: PhantomData, } } } -impl PipelineRenderingCreateInfo { - pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> { - PipelineRenderingCreateInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PipelineRenderingCreateInfoBuilder<'a> { - inner: PipelineRenderingCreateInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {} -impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> { - type Target = PipelineRenderingCreateInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PipelineRenderingCreateInfoBuilder<'a> { +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo<'_> {} +impl<'a> PipelineRenderingCreateInfo<'a> { + #[inline] pub fn view_mask(mut self, view_mask: u32) -> Self { - self.inner.view_mask = view_mask; + self.view_mask = view_mask; self } + #[inline] pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { - self.inner.color_attachment_count = color_attachment_formats.len() as _; - self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self.color_attachment_count = color_attachment_formats.len() as _; + self.p_color_attachment_formats = color_attachment_formats.as_ptr(); self } + #[inline] pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { - self.inner.depth_attachment_format = depth_attachment_format; + self.depth_attachment_format = depth_attachment_format; self } + #[inline] pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { - self.inner.stencil_attachment_format = stencil_attachment_format; + self.stencil_attachment_format = stencil_attachment_format; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PipelineRenderingCreateInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderingInfo { +pub struct RenderingInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: RenderingFlags, @@ -56068,11 +36932,12 @@ pub struct RenderingInfo { pub layer_count: u32, pub view_mask: u32, pub color_attachment_count: u32, - pub p_color_attachments: *const RenderingAttachmentInfo, - pub p_depth_attachment: *const RenderingAttachmentInfo, - pub p_stencil_attachment: *const RenderingAttachmentInfo, + pub p_color_attachments: *const RenderingAttachmentInfo<'a>, + pub p_depth_attachment: *const RenderingAttachmentInfo<'a>, + pub p_stencil_attachment: *const RenderingAttachmentInfo<'a>, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderingInfo { +impl ::std::default::Default for RenderingInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDERING_INFO, @@ -56085,89 +36950,70 @@ impl ::std::default::Default for RenderingInfo { p_color_attachments: ::std::ptr::null(), p_depth_attachment: ::std::ptr::null(), p_stencil_attachment: ::std::ptr::null(), + _marker: PhantomData, } } } -impl RenderingInfo { - pub fn builder<'a>() -> RenderingInfoBuilder<'a> { - RenderingInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderingInfoBuilder<'a> { - inner: RenderingInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} pub unsafe trait ExtendsRenderingInfo {} -impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> { - type Target = RenderingInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderingInfoBuilder<'a> { +impl<'a> RenderingInfo<'a> { + #[inline] pub fn flags(mut self, flags: RenderingFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn render_area(mut self, render_area: Rect2D) -> Self { - self.inner.render_area = render_area; + self.render_area = render_area; self } + #[inline] pub fn layer_count(mut self, layer_count: u32) -> Self { - self.inner.layer_count = layer_count; + self.layer_count = layer_count; self } + #[inline] pub fn view_mask(mut self, view_mask: u32) -> Self { - self.inner.view_mask = view_mask; + self.view_mask = view_mask; self } + #[inline] pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self { - self.inner.color_attachment_count = color_attachments.len() as _; - self.inner.p_color_attachments = color_attachments.as_ptr(); + self.color_attachment_count = color_attachments.len() as _; + self.p_color_attachments = color_attachments.as_ptr(); self } - pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self { - self.inner.p_depth_attachment = depth_attachment; + #[inline] + pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo<'a>) -> Self { + self.p_depth_attachment = depth_attachment; self } - pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self { - self.inner.p_stencil_attachment = stencil_attachment; + #[inline] + pub fn stencil_attachment( + mut self, + stencil_attachment: &'a RenderingAttachmentInfo<'a>, + ) -> Self { + self.p_stencil_attachment = stencil_attachment; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] #[doc = r" method only exists on structs that can be passed to a function directly. Only"] #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { let next_ptr = <*const T>::cast(next); let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderingInfo { - self.inner - } } #[repr(C)] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderingAttachmentInfo { +pub struct RenderingAttachmentInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image_view: ImageView, @@ -56178,9 +37024,10 @@ pub struct RenderingAttachmentInfo { pub load_op: AttachmentLoadOp, pub store_op: AttachmentStoreOp, pub clear_value: ClearValue, + pub _marker: PhantomData<&'a ()>, } #[cfg(feature = "debug")] -impl fmt::Debug for RenderingAttachmentInfo { +impl fmt::Debug for RenderingAttachmentInfo<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct("RenderingAttachmentInfo") .field("s_type", &self.s_type) @@ -56196,7 +37043,7 @@ impl fmt::Debug for RenderingAttachmentInfo { .finish() } } -impl ::std::default::Default for RenderingAttachmentInfo { +impl ::std::default::Default for RenderingAttachmentInfo<'_> { fn default() -> Self { Self { s_type: StructureType::RENDERING_ATTACHMENT_INFO, @@ -56209,85 +37056,65 @@ impl ::std::default::Default for RenderingAttachmentInfo { load_op: AttachmentLoadOp::default(), store_op: AttachmentStoreOp::default(), clear_value: ClearValue::default(), + _marker: PhantomData, } } } -impl RenderingAttachmentInfo { - pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> { - RenderingAttachmentInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderingAttachmentInfoBuilder<'a> { - inner: RenderingAttachmentInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> { - type Target = RenderingAttachmentInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderingAttachmentInfoBuilder<'a> { +impl<'a> RenderingAttachmentInfo<'a> { + #[inline] pub fn image_view(mut self, image_view: ImageView) -> Self { - self.inner.image_view = image_view; + self.image_view = image_view; self } + #[inline] pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.inner.image_layout = image_layout; + self.image_layout = image_layout; self } + #[inline] pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self { - self.inner.resolve_mode = resolve_mode; + self.resolve_mode = resolve_mode; self } + #[inline] pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self { - self.inner.resolve_image_view = resolve_image_view; + self.resolve_image_view = resolve_image_view; self } + #[inline] pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self { - self.inner.resolve_image_layout = resolve_image_layout; + self.resolve_image_layout = resolve_image_layout; self } + #[inline] pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { - self.inner.load_op = load_op; + self.load_op = load_op; self } + #[inline] pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { - self.inner.store_op = store_op; + self.store_op = store_op; self } + #[inline] pub fn clear_value(mut self, clear_value: ClearValue) -> Self { - self.inner.clear_value = clear_value; + self.clear_value = clear_value; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderingAttachmentInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderingFragmentShadingRateAttachmentInfoKHR { +pub struct RenderingFragmentShadingRateAttachmentInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image_view: ImageView, pub image_layout: ImageLayout, pub shading_rate_attachment_texel_size: Extent2D, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR { +impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR<'_> { fn default() -> Self { Self { s_type: StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, @@ -56295,183 +37122,100 @@ impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR { image_view: ImageView::default(), image_layout: ImageLayout::default(), shading_rate_attachment_texel_size: Extent2D::default(), + _marker: PhantomData, } } } -impl RenderingFragmentShadingRateAttachmentInfoKHR { - pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { - RenderingFragmentShadingRateAttachmentInfoKHRBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { - inner: RenderingFragmentShadingRateAttachmentInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {} -unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {} -impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { - type Target = RenderingFragmentShadingRateAttachmentInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { +unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR<'_> {} +impl<'a> RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + #[inline] pub fn image_view(mut self, image_view: ImageView) -> Self { - self.inner.image_view = image_view; + self.image_view = image_view; self } + #[inline] pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.inner.image_layout = image_layout; + self.image_layout = image_layout; self } + #[inline] pub fn shading_rate_attachment_texel_size( mut self, shading_rate_attachment_texel_size: Extent2D, ) -> Self { - self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct RenderingFragmentDensityMapAttachmentInfoEXT { +pub struct RenderingFragmentDensityMapAttachmentInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub image_view: ImageView, pub image_layout: ImageLayout, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT { +impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, p_next: ::std::ptr::null(), image_view: ImageView::default(), image_layout: ImageLayout::default(), + _marker: PhantomData, } } } -impl RenderingFragmentDensityMapAttachmentInfoEXT { - pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { - RenderingFragmentDensityMapAttachmentInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { - inner: RenderingFragmentDensityMapAttachmentInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {} -unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {} -impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { - type Target = RenderingFragmentDensityMapAttachmentInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { +unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT<'_> {} +impl<'a> RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + #[inline] pub fn image_view(mut self, image_view: ImageView) -> Self { - self.inner.image_view = image_view; + self.image_view = image_view; self } + #[inline] pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.inner.image_layout = image_layout; + self.image_layout = image_layout; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDynamicRenderingFeatures { +pub struct PhysicalDeviceDynamicRenderingFeatures<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub dynamic_rendering: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures { +impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, p_next: ::std::ptr::null_mut(), dynamic_rendering: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDynamicRenderingFeatures { - pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { - PhysicalDeviceDynamicRenderingFeaturesBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { - inner: PhysicalDeviceDynamicRenderingFeatures, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { - type Target = PhysicalDeviceDynamicRenderingFeatures; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures<'_> {} +impl<'a> PhysicalDeviceDynamicRenderingFeatures<'a> { + #[inline] pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { - self.inner.dynamic_rendering = dynamic_rendering.into(); + self.dynamic_rendering = dynamic_rendering.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct CommandBufferInheritanceRenderingInfo { +pub struct CommandBufferInheritanceRenderingInfo<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub flags: RenderingFlags, @@ -56481,8 +37225,9 @@ pub struct CommandBufferInheritanceRenderingInfo { pub depth_attachment_format: Format, pub stencil_attachment_format: Format, pub rasterization_samples: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferInheritanceRenderingInfo { +impl ::std::default::Default for CommandBufferInheritanceRenderingInfo<'_> { fn default() -> Self { Self { s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, @@ -56494,83 +37239,57 @@ impl ::std::default::Default for CommandBufferInheritanceRenderingInfo { depth_attachment_format: Format::default(), stencil_attachment_format: Format::default(), rasterization_samples: SampleCountFlags::default(), + _marker: PhantomData, } } } -impl CommandBufferInheritanceRenderingInfo { - pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> { - CommandBufferInheritanceRenderingInfoBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> { - inner: CommandBufferInheritanceRenderingInfo, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsCommandBufferInheritanceInfo - for CommandBufferInheritanceRenderingInfoBuilder<'_> -{ -} -unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {} -impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> { - type Target = CommandBufferInheritanceRenderingInfo; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> { +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo<'_> {} +impl<'a> CommandBufferInheritanceRenderingInfo<'a> { + #[inline] pub fn flags(mut self, flags: RenderingFlags) -> Self { - self.inner.flags = flags; + self.flags = flags; self } + #[inline] pub fn view_mask(mut self, view_mask: u32) -> Self { - self.inner.view_mask = view_mask; + self.view_mask = view_mask; self } + #[inline] pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { - self.inner.color_attachment_count = color_attachment_formats.len() as _; - self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self.color_attachment_count = color_attachment_formats.len() as _; + self.p_color_attachment_formats = color_attachment_formats.as_ptr(); self } + #[inline] pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { - self.inner.depth_attachment_format = depth_attachment_format; + self.depth_attachment_format = depth_attachment_format; self } + #[inline] pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { - self.inner.stencil_attachment_format = stencil_attachment_format; + self.stencil_attachment_format = stencil_attachment_format; self } + #[inline] pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { - self.inner.rasterization_samples = rasterization_samples; + self.rasterization_samples = rasterization_samples; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> CommandBufferInheritanceRenderingInfo { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct AttachmentSampleCountInfoAMD { +pub struct AttachmentSampleCountInfoAMD<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub color_attachment_count: u32, pub p_color_attachment_samples: *const SampleCountFlags, pub depth_stencil_attachment_samples: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AttachmentSampleCountInfoAMD { +impl ::std::default::Default for AttachmentSampleCountInfoAMD<'_> { fn default() -> Self { Self { s_type: StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD, @@ -56578,255 +37297,141 @@ impl ::std::default::Default for AttachmentSampleCountInfoAMD { color_attachment_count: u32::default(), p_color_attachment_samples: ::std::ptr::null(), depth_stencil_attachment_samples: SampleCountFlags::default(), + _marker: PhantomData, } } } -impl AttachmentSampleCountInfoAMD { - pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> { - AttachmentSampleCountInfoAMDBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AttachmentSampleCountInfoAMDBuilder<'a> { - inner: AttachmentSampleCountInfoAMD, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} -unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {} -impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> { - type Target = AttachmentSampleCountInfoAMD; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> { +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD<'_> {} +impl<'a> AttachmentSampleCountInfoAMD<'a> { + #[inline] pub fn color_attachment_samples( mut self, color_attachment_samples: &'a [SampleCountFlags], ) -> Self { - self.inner.color_attachment_count = color_attachment_samples.len() as _; - self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr(); + self.color_attachment_count = color_attachment_samples.len() as _; + self.p_color_attachment_samples = color_attachment_samples.as_ptr(); self } + #[inline] pub fn depth_stencil_attachment_samples( mut self, depth_stencil_attachment_samples: SampleCountFlags, ) -> Self { - self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples; + self.depth_stencil_attachment_samples = depth_stencil_attachment_samples; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AttachmentSampleCountInfoAMD { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct MultiviewPerViewAttributesInfoNVX { +pub struct MultiviewPerViewAttributesInfoNVX<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub per_view_attributes: Bool32, pub per_view_attributes_position_x_only: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX { +impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX<'_> { fn default() -> Self { Self { s_type: StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX, p_next: ::std::ptr::null(), per_view_attributes: Bool32::default(), per_view_attributes_position_x_only: Bool32::default(), + _marker: PhantomData, } } } -impl MultiviewPerViewAttributesInfoNVX { - pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> { - MultiviewPerViewAttributesInfoNVXBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> { - inner: MultiviewPerViewAttributesInfoNVX, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} -unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {} -unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} -unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {} -impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> { - type Target = MultiviewPerViewAttributesInfoNVX; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> { +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX<'_> {} +unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX<'_> {} +impl<'a> MultiviewPerViewAttributesInfoNVX<'a> { + #[inline] pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { - self.inner.per_view_attributes = per_view_attributes.into(); + self.per_view_attributes = per_view_attributes.into(); self } + #[inline] pub fn per_view_attributes_position_x_only( mut self, per_view_attributes_position_x_only: bool, ) -> Self { - self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into(); + self.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> MultiviewPerViewAttributesInfoNVX { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceImageViewMinLodFeaturesEXT { +pub struct PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub min_lod: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT { +impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, p_next: ::std::ptr::null_mut(), min_lod: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceImageViewMinLodFeaturesEXT { - pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { - PhysicalDeviceImageViewMinLodFeaturesEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { - inner: PhysicalDeviceImageViewMinLodFeaturesEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {} -impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { - type Target = PhysicalDeviceImageViewMinLodFeaturesEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + #[inline] pub fn min_lod(mut self, min_lod: bool) -> Self { - self.inner.min_lod = min_lod.into(); + self.min_lod = min_lod.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct ImageViewMinLodCreateInfoEXT { +pub struct ImageViewMinLodCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub min_lod: f32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageViewMinLodCreateInfoEXT { +impl ::std::default::Default for ImageViewMinLodCreateInfoEXT<'_> { fn default() -> Self { Self { s_type: StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, p_next: ::std::ptr::null(), min_lod: f32::default(), + _marker: PhantomData, } } } -impl ImageViewMinLodCreateInfoEXT { - pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> { - ImageViewMinLodCreateInfoEXTBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> { - inner: ImageViewMinLodCreateInfoEXT, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {} -unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {} -impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> { - type Target = ImageViewMinLodCreateInfoEXT; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> { +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT<'_> {} +impl<'a> ImageViewMinLodCreateInfoEXT<'a> { + #[inline] pub fn min_lod(mut self, min_lod: f32) -> Self { - self.inner.min_lod = min_lod; + self.min_lod = min_lod; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> ImageViewMinLodCreateInfoEXT { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub rasterization_order_color_attachment_access: Bool32, pub rasterization_order_depth_attachment_access: Bool32, pub rasterization_order_stencil_attachment_access: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { +impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'_> { fn default() -> Self { Self { s_type: @@ -56835,327 +37440,173 @@ impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAcces rasterization_order_color_attachment_access: Bool32::default(), rasterization_order_depth_attachment_access: Bool32::default(), rasterization_order_stencil_attachment_access: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { - pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> { - PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> { - inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'_> { } unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'_> + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'_> { } -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM -{ -} -impl<'a> ::std::ops::Deref - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> -{ - type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> -{ - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARMBuilder<'a> { +impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM<'a> { + #[inline] pub fn rasterization_order_color_attachment_access( mut self, rasterization_order_color_attachment_access: bool, ) -> Self { - self.inner.rasterization_order_color_attachment_access = + self.rasterization_order_color_attachment_access = rasterization_order_color_attachment_access.into(); self } + #[inline] pub fn rasterization_order_depth_attachment_access( mut self, rasterization_order_depth_attachment_access: bool, ) -> Self { - self.inner.rasterization_order_depth_attachment_access = + self.rasterization_order_depth_attachment_access = rasterization_order_depth_attachment_access.into(); self } + #[inline] pub fn rasterization_order_stencil_attachment_access( mut self, rasterization_order_stencil_attachment_access: bool, ) -> Self { - self.inner.rasterization_order_stencil_attachment_access = + self.rasterization_order_stencil_attachment_access = rasterization_order_stencil_attachment_access.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV { +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub linear_color_attachment: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV { +impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, p_next: ::std::ptr::null_mut(), linear_color_attachment: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceLinearColorAttachmentFeaturesNV { - pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { - PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { - inner: PhysicalDeviceLinearColorAttachmentFeaturesNV, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> -{ -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {} -impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { - type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {} +impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { + #[inline] pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { - self.inner.linear_color_attachment = linear_color_attachment.into(); + self.linear_color_attachment = linear_color_attachment.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub descriptor_set_host_mapping: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { +impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> { fn default() -> Self { Self { s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, p_next: ::std::ptr::null_mut(), descriptor_set_host_mapping: Bool32::default(), + _marker: PhantomData, } } } -impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { - pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { - PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { - inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, - marker: ::std::marker::PhantomData<&'a ()>, -} unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> { } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} -impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { - type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> {} +impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { + #[inline] pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self { - self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); + self.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetBindingReferenceVALVE { +pub struct DescriptorSetBindingReferenceVALVE<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub descriptor_set_layout: DescriptorSetLayout, pub binding: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetBindingReferenceVALVE { +impl ::std::default::Default for DescriptorSetBindingReferenceVALVE<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, p_next: ::std::ptr::null(), descriptor_set_layout: DescriptorSetLayout::default(), binding: u32::default(), + _marker: PhantomData, } } } -impl DescriptorSetBindingReferenceVALVE { - pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> { - DescriptorSetBindingReferenceVALVEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> { - inner: DescriptorSetBindingReferenceVALVE, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> { - type Target = DescriptorSetBindingReferenceVALVE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> { +impl<'a> DescriptorSetBindingReferenceVALVE<'a> { + #[inline] pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { - self.inner.descriptor_set_layout = descriptor_set_layout; + self.descriptor_set_layout = descriptor_set_layout; self } + #[inline] pub fn binding(mut self, binding: u32) -> Self { - self.inner.binding = binding; + self.binding = binding; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetBindingReferenceVALVE { - self.inner - } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] -pub struct DescriptorSetLayoutHostMappingInfoVALVE { +pub struct DescriptorSetLayoutHostMappingInfoVALVE<'a> { pub s_type: StructureType, pub p_next: *mut c_void, pub descriptor_offset: usize, pub descriptor_size: u32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE { +impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE<'_> { fn default() -> Self { Self { s_type: StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, p_next: ::std::ptr::null_mut(), descriptor_offset: usize::default(), descriptor_size: u32::default(), + _marker: PhantomData, } } } -impl DescriptorSetLayoutHostMappingInfoVALVE { - pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { - DescriptorSetLayoutHostMappingInfoVALVEBuilder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { - inner: DescriptorSetLayoutHostMappingInfoVALVE, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { - type Target = DescriptorSetLayoutHostMappingInfoVALVE; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { +impl<'a> DescriptorSetLayoutHostMappingInfoVALVE<'a> { + #[inline] pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { - self.inner.descriptor_offset = descriptor_offset; + self.descriptor_offset = descriptor_offset; self } + #[inline] pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { - self.inner.descriptor_size = descriptor_size; + self.descriptor_size = descriptor_size; self } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE { - self.inner - } } diff --git a/ash/tests/constant_size_arrays.rs b/ash/tests/constant_size_arrays.rs index a756f34..826180b 100644 --- a/ash/tests/constant_size_arrays.rs +++ b/ash/tests/constant_size_arrays.rs @@ -4,7 +4,7 @@ use ash::vk::{PhysicalDeviceProperties, PipelineColorBlendStateCreateInfo}; fn assert_struct_field_is_array() { let pipeline_cache_uuid: [u8; 16] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; - let _ = PhysicalDeviceProperties::builder().pipeline_cache_uuid(pipeline_cache_uuid); + let _ = PhysicalDeviceProperties::default().pipeline_cache_uuid(pipeline_cache_uuid); let _ = PhysicalDeviceProperties { pipeline_cache_uuid, @@ -13,7 +13,7 @@ fn assert_struct_field_is_array() { let blend_constants: [f32; 4] = [0.0, 0.0, 0.0, 0.0]; - let _ = PipelineColorBlendStateCreateInfo::builder().blend_constants(blend_constants); + let _ = PipelineColorBlendStateCreateInfo::default().blend_constants(blend_constants); let _ = PipelineColorBlendStateCreateInfo { blend_constants, diff --git a/examples/src/bin/texture.rs b/examples/src/bin/texture.rs index 497ff31..cdba888 100644 --- a/examples/src/bin/texture.rs +++ b/examples/src/bin/texture.rs @@ -62,12 +62,12 @@ fn main() { ..Default::default() }]; - let subpass = vk::SubpassDescription::builder() + let subpass = vk::SubpassDescription::default() .color_attachments(&color_attachment_refs) .depth_stencil_attachment(&depth_attachment_ref) .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS); - let renderpass_create_info = vk::RenderPassCreateInfo::builder() + let renderpass_create_info = vk::RenderPassCreateInfo::default() .attachments(&renderpass_attachments) .subpasses(std::slice::from_ref(&subpass)) .dependencies(&dependencies); @@ -82,7 +82,7 @@ fn main() { .iter() .map(|&present_image_view| { let framebuffer_attachments = [present_image_view, base.depth_image_view]; - let frame_buffer_create_info = vk::FramebufferCreateInfo::builder() + let frame_buffer_create_info = vk::FramebufferCreateInfo::default() .render_pass(renderpass) .attachments(&framebuffer_attachments) .width(base.surface_resolution.width) @@ -378,12 +378,11 @@ fn main() { &[], &[texture_barrier], ); - let buffer_copy_regions = vk::BufferImageCopy::builder() + let buffer_copy_regions = vk::BufferImageCopy::default() .image_subresource( - vk::ImageSubresourceLayers::builder() + vk::ImageSubresourceLayers::default() .aspect_mask(vk::ImageAspectFlags::COLOR) - .layer_count(1) - .build(), + .layer_count(1), ) .image_extent(image_extent.into()); @@ -392,7 +391,7 @@ fn main() { image_buffer, texture_image, vk::ImageLayout::TRANSFER_DST_OPTIMAL, - &[buffer_copy_regions.build()], + &[buffer_copy_regions], ); let texture_barrier_end = vk::ImageMemoryBarrier { src_access_mask: vk::AccessFlags::TRANSFER_WRITE, @@ -467,7 +466,7 @@ fn main() { descriptor_count: 1, }, ]; - let descriptor_pool_info = vk::DescriptorPoolCreateInfo::builder() + let descriptor_pool_info = vk::DescriptorPoolCreateInfo::default() .pool_sizes(&descriptor_sizes) .max_sets(1); @@ -491,14 +490,14 @@ fn main() { }, ]; let descriptor_info = - vk::DescriptorSetLayoutCreateInfo::builder().bindings(&desc_layout_bindings); + vk::DescriptorSetLayoutCreateInfo::default().bindings(&desc_layout_bindings); let desc_set_layouts = [base .device .create_descriptor_set_layout(&descriptor_info, None) .unwrap()]; - let desc_alloc_info = vk::DescriptorSetAllocateInfo::builder() + let desc_alloc_info = vk::DescriptorSetAllocateInfo::default() .descriptor_pool(descriptor_pool) .set_layouts(&desc_set_layouts); let descriptor_sets = base @@ -542,11 +541,11 @@ fn main() { let vertex_code = read_spv(&mut vertex_spv_file).expect("Failed to read vertex shader spv file"); - let vertex_shader_info = vk::ShaderModuleCreateInfo::builder().code(&vertex_code); + let vertex_shader_info = vk::ShaderModuleCreateInfo::default().code(&vertex_code); let frag_code = read_spv(&mut frag_spv_file).expect("Failed to read fragment shader spv file"); - let frag_shader_info = vk::ShaderModuleCreateInfo::builder().code(&frag_code); + let frag_shader_info = vk::ShaderModuleCreateInfo::default().code(&frag_code); let vertex_shader_module = base .device @@ -559,7 +558,7 @@ fn main() { .expect("Fragment shader module error"); let layout_create_info = - vk::PipelineLayoutCreateInfo::builder().set_layouts(&desc_set_layouts); + vk::PipelineLayoutCreateInfo::default().set_layouts(&desc_set_layouts); let pipeline_layout = base .device @@ -600,7 +599,7 @@ fn main() { offset: offset_of!(Vertex, uv) as u32, }, ]; - let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo::builder() + let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo::default() .vertex_attribute_descriptions(&vertex_input_attribute_descriptions) .vertex_binding_descriptions(&vertex_input_binding_descriptions); @@ -617,7 +616,7 @@ fn main() { max_depth: 1.0, }]; let scissors = [base.surface_resolution.into()]; - let viewport_state_info = vk::PipelineViewportStateCreateInfo::builder() + let viewport_state_info = vk::PipelineViewportStateCreateInfo::default() .scissors(&scissors) .viewports(&viewports); @@ -628,7 +627,7 @@ fn main() { ..Default::default() }; - let multisample_state_info = vk::PipelineMultisampleStateCreateInfo::builder() + let multisample_state_info = vk::PipelineMultisampleStateCreateInfo::default() .rasterization_samples(vk::SampleCountFlags::TYPE_1); let noop_stencil_state = vk::StencilOpState { @@ -658,15 +657,15 @@ fn main() { alpha_blend_op: vk::BlendOp::ADD, color_write_mask: vk::ColorComponentFlags::RGBA, }]; - let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder() + let color_blend_state = vk::PipelineColorBlendStateCreateInfo::default() .logic_op(vk::LogicOp::CLEAR) .attachments(&color_blend_attachment_states); let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]; let dynamic_state_info = - vk::PipelineDynamicStateCreateInfo::builder().dynamic_states(&dynamic_state); + vk::PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_state); - let graphic_pipeline_infos = vk::GraphicsPipelineCreateInfo::builder() + let graphic_pipeline_infos = vk::GraphicsPipelineCreateInfo::default() .stages(&shader_stage_create_infos) .vertex_input_state(&vertex_input_state_info) .input_assembly_state(&vertex_input_assembly_state_info) @@ -681,11 +680,7 @@ fn main() { let graphics_pipelines = base .device - .create_graphics_pipelines( - vk::PipelineCache::null(), - &[graphic_pipeline_infos.build()], - None, - ) + .create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_infos], None) .unwrap(); let graphic_pipeline = graphics_pipelines[0]; @@ -714,7 +709,7 @@ fn main() { }, ]; - let render_pass_begin_info = vk::RenderPassBeginInfo::builder() + let render_pass_begin_info = vk::RenderPassBeginInfo::default() .render_pass(renderpass) .framebuffer(framebuffers[present_index as usize]) .render_area(base.surface_resolution.into()) diff --git a/examples/src/bin/triangle.rs b/examples/src/bin/triangle.rs index bb8361c..46eb1ce 100644 --- a/examples/src/bin/triangle.rs +++ b/examples/src/bin/triangle.rs @@ -51,12 +51,12 @@ fn main() { ..Default::default() }]; - let subpass = vk::SubpassDescription::builder() + let subpass = vk::SubpassDescription::default() .color_attachments(&color_attachment_refs) .depth_stencil_attachment(&depth_attachment_ref) .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS); - let renderpass_create_info = vk::RenderPassCreateInfo::builder() + let renderpass_create_info = vk::RenderPassCreateInfo::default() .attachments(&renderpass_attachments) .subpasses(std::slice::from_ref(&subpass)) .dependencies(&dependencies); @@ -71,7 +71,7 @@ fn main() { .iter() .map(|&present_image_view| { let framebuffer_attachments = [present_image_view, base.depth_image_view]; - let frame_buffer_create_info = vk::FramebufferCreateInfo::builder() + let frame_buffer_create_info = vk::FramebufferCreateInfo::default() .render_pass(renderpass) .attachments(&framebuffer_attachments) .width(base.surface_resolution.width) @@ -85,7 +85,7 @@ fn main() { .collect(); let index_buffer_data = [0u32, 1, 2]; - let index_buffer_info = vk::BufferCreateInfo::builder() + let index_buffer_info = vk::BufferCreateInfo::default() .size(std::mem::size_of_val(&index_buffer_data) as u64) .usage(vk::BufferUsageFlags::INDEX_BUFFER) .sharing_mode(vk::SharingMode::EXCLUSIVE); @@ -203,11 +203,11 @@ fn main() { let vertex_code = read_spv(&mut vertex_spv_file).expect("Failed to read vertex shader spv file"); - let vertex_shader_info = vk::ShaderModuleCreateInfo::builder().code(&vertex_code); + let vertex_shader_info = vk::ShaderModuleCreateInfo::default().code(&vertex_code); let frag_code = read_spv(&mut frag_spv_file).expect("Failed to read fragment shader spv file"); - let frag_shader_info = vk::ShaderModuleCreateInfo::builder().code(&frag_code); + let frag_shader_info = vk::ShaderModuleCreateInfo::default().code(&frag_code); let vertex_shader_module = base .device @@ -262,7 +262,7 @@ fn main() { }, ]; - let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo::builder() + let vertex_input_state_info = vk::PipelineVertexInputStateCreateInfo::default() .vertex_attribute_descriptions(&vertex_input_attribute_descriptions) .vertex_binding_descriptions(&vertex_input_binding_descriptions); let vertex_input_assembly_state_info = vk::PipelineInputAssemblyStateCreateInfo { @@ -278,7 +278,7 @@ fn main() { max_depth: 1.0, }]; let scissors = [base.surface_resolution.into()]; - let viewport_state_info = vk::PipelineViewportStateCreateInfo::builder() + let viewport_state_info = vk::PipelineViewportStateCreateInfo::default() .scissors(&scissors) .viewports(&viewports); @@ -318,15 +318,15 @@ fn main() { alpha_blend_op: vk::BlendOp::ADD, color_write_mask: vk::ColorComponentFlags::RGBA, }]; - let color_blend_state = vk::PipelineColorBlendStateCreateInfo::builder() + let color_blend_state = vk::PipelineColorBlendStateCreateInfo::default() .logic_op(vk::LogicOp::CLEAR) .attachments(&color_blend_attachment_states); let dynamic_state = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR]; let dynamic_state_info = - vk::PipelineDynamicStateCreateInfo::builder().dynamic_states(&dynamic_state); + vk::PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_state); - let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo::builder() + let graphic_pipeline_info = vk::GraphicsPipelineCreateInfo::default() .stages(&shader_stage_create_infos) .vertex_input_state(&vertex_input_state_info) .input_assembly_state(&vertex_input_assembly_state_info) @@ -341,11 +341,7 @@ fn main() { let graphics_pipelines = base .device - .create_graphics_pipelines( - vk::PipelineCache::null(), - &[graphic_pipeline_info.build()], - None, - ) + .create_graphics_pipelines(vk::PipelineCache::null(), &[graphic_pipeline_info], None) .expect("Unable to create graphics pipeline"); let graphic_pipeline = graphics_pipelines[0]; @@ -374,7 +370,7 @@ fn main() { }, ]; - let render_pass_begin_info = vk::RenderPassBeginInfo::builder() + let render_pass_begin_info = vk::RenderPassBeginInfo::default() .render_pass(renderpass) .framebuffer(framebuffers[present_index as usize]) .render_area(base.surface_resolution.into()) @@ -430,7 +426,7 @@ fn main() { let wait_semaphors = [base.rendering_complete_semaphore]; let swapchains = [base.swapchain]; let image_indices = [present_index]; - let present_info = vk::PresentInfoKHR::builder() + let present_info = vk::PresentInfoKHR::default() .wait_semaphores(&wait_semaphors) // &base.rendering_complete_semaphore) .swapchains(&swapchains) .image_indices(&image_indices); diff --git a/examples/src/lib.rs b/examples/src/lib.rs index 25a577d..5583da3 100644 --- a/examples/src/lib.rs +++ b/examples/src/lib.rs @@ -63,7 +63,7 @@ pub fn record_submit_commandbuffer( ) .expect("Reset command buffer failed."); - let command_buffer_begin_info = vk::CommandBufferBeginInfo::builder() + let command_buffer_begin_info = vk::CommandBufferBeginInfo::default() .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT); device @@ -76,18 +76,14 @@ pub fn record_submit_commandbuffer( let command_buffers = vec![command_buffer]; - let submit_info = vk::SubmitInfo::builder() + let submit_info = vk::SubmitInfo::default() .wait_semaphores(wait_semaphores) .wait_dst_stage_mask(wait_mask) .command_buffers(&command_buffers) .signal_semaphores(signal_semaphores); device - .queue_submit( - submit_queue, - &[submit_info.build()], - command_buffer_reuse_fence, - ) + .queue_submit(submit_queue, &[submit_info], command_buffer_reuse_fence) .expect("queue submit failed."); } } @@ -233,14 +229,14 @@ impl ExampleBase { .to_vec(); extension_names.push(DebugUtils::name().as_ptr()); - let appinfo = vk::ApplicationInfo::builder() + let appinfo = vk::ApplicationInfo::default() .application_name(app_name) .application_version(0) .engine_name(app_name) .engine_version(0) .api_version(vk::make_api_version(0, 1, 0, 0)); - let create_info = vk::InstanceCreateInfo::builder() + let create_info = vk::InstanceCreateInfo::default() .application_info(&appinfo) .enabled_layer_names(&layers_names_raw) .enabled_extension_names(&extension_names); @@ -249,7 +245,7 @@ impl ExampleBase { .create_instance(&create_info, None) .expect("Instance creation error"); - let debug_info = vk::DebugUtilsMessengerCreateInfoEXT::builder() + let debug_info = vk::DebugUtilsMessengerCreateInfoEXT::default() .message_severity( vk::DebugUtilsMessageSeverityFlagsEXT::ERROR | vk::DebugUtilsMessageSeverityFlagsEXT::WARNING @@ -304,11 +300,11 @@ impl ExampleBase { }; let priorities = [1.0]; - let queue_info = vk::DeviceQueueCreateInfo::builder() + let queue_info = vk::DeviceQueueCreateInfo::default() .queue_family_index(queue_family_index) .queue_priorities(&priorities); - let device_create_info = vk::DeviceCreateInfo::builder() + let device_create_info = vk::DeviceCreateInfo::default() .queue_create_infos(std::slice::from_ref(&queue_info)) .enabled_extension_names(&device_extension_names_raw) .enabled_features(&features); @@ -357,7 +353,7 @@ impl ExampleBase { .unwrap_or(vk::PresentModeKHR::FIFO); let swapchain_loader = Swapchain::new(&instance, &device); - let swapchain_create_info = vk::SwapchainCreateInfoKHR::builder() + let swapchain_create_info = vk::SwapchainCreateInfoKHR::default() .surface(surface) .min_image_count(desired_image_count) .image_color_space(surface_format.color_space) @@ -375,13 +371,13 @@ impl ExampleBase { .create_swapchain(&swapchain_create_info, None) .unwrap(); - let pool_create_info = vk::CommandPoolCreateInfo::builder() + let pool_create_info = vk::CommandPoolCreateInfo::default() .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER) .queue_family_index(queue_family_index); let pool = device.create_command_pool(&pool_create_info, None).unwrap(); - let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::builder() + let command_buffer_allocate_info = vk::CommandBufferAllocateInfo::default() .command_buffer_count(2) .command_pool(pool) .level(vk::CommandBufferLevel::PRIMARY); @@ -396,7 +392,7 @@ impl ExampleBase { let present_image_views: Vec = present_images .iter() .map(|&image| { - let create_view_info = vk::ImageViewCreateInfo::builder() + let create_view_info = vk::ImageViewCreateInfo::default() .view_type(vk::ImageViewType::TYPE_2D) .format(surface_format.format) .components(vk::ComponentMapping { @@ -417,7 +413,7 @@ impl ExampleBase { }) .collect(); let device_memory_properties = instance.get_physical_device_memory_properties(pdevice); - let depth_image_create_info = vk::ImageCreateInfo::builder() + let depth_image_create_info = vk::ImageCreateInfo::default() .image_type(vk::ImageType::TYPE_2D) .format(vk::Format::D16_UNORM) .extent(surface_resolution.into()) @@ -437,7 +433,7 @@ impl ExampleBase { ) .expect("Unable to find suitable memory index for depth image."); - let depth_image_allocate_info = vk::MemoryAllocateInfo::builder() + let depth_image_allocate_info = vk::MemoryAllocateInfo::default() .allocation_size(depth_image_memory_req.size) .memory_type_index(depth_image_memory_index); @@ -450,7 +446,7 @@ impl ExampleBase { .expect("Unable to bind depth image memory"); let fence_create_info = - vk::FenceCreateInfo::builder().flags(vk::FenceCreateFlags::SIGNALED); + vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED); let draw_commands_reuse_fence = device .create_fence(&fence_create_info, None) @@ -468,7 +464,7 @@ impl ExampleBase { &[], &[], |device, setup_command_buffer| { - let layout_transition_barriers = vk::ImageMemoryBarrier::builder() + let layout_transition_barriers = vk::ImageMemoryBarrier::default() .image(depth_image) .dst_access_mask( vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ @@ -477,11 +473,10 @@ impl ExampleBase { .new_layout(vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL) .old_layout(vk::ImageLayout::UNDEFINED) .subresource_range( - vk::ImageSubresourceRange::builder() + vk::ImageSubresourceRange::default() .aspect_mask(vk::ImageAspectFlags::DEPTH) .layer_count(1) - .level_count(1) - .build(), + .level_count(1), ); device.cmd_pipeline_barrier( @@ -491,18 +486,17 @@ impl ExampleBase { vk::DependencyFlags::empty(), &[], &[], - &[layout_transition_barriers.build()], + &[layout_transition_barriers], ); }, ); - let depth_image_view_info = vk::ImageViewCreateInfo::builder() + let depth_image_view_info = vk::ImageViewCreateInfo::default() .subresource_range( - vk::ImageSubresourceRange::builder() + vk::ImageSubresourceRange::default() .aspect_mask(vk::ImageAspectFlags::DEPTH) .level_count(1) - .layer_count(1) - .build(), + .layer_count(1), ) .image(depth_image) .format(depth_image_create_info.format) diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 877d3e4..30ed9f1 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -1375,7 +1375,7 @@ fn is_static_array(field: &vkxml::Field) -> bool { .map(|ty| matches!(ty, vkxml::ArrayType::Static)) .unwrap_or(false) } -pub fn derive_default(_struct: &vkxml::Struct) -> Option { +pub fn derive_default(_struct: &vkxml::Struct, has_lifetime: bool) -> Option { let name = name_to_tokens(&_struct.name); let members = _struct .elements @@ -1427,20 +1427,27 @@ pub fn derive_default(_struct: &vkxml::Struct) -> Option { } } }); + let lifetime = has_lifetime.then(|| quote!(<'_>)); + let marker = has_lifetime.then(|| quote!(_marker: PhantomData,)); let q = quote! { - impl ::std::default::Default for #name { + impl ::std::default::Default for #name #lifetime { fn default() -> Self { Self { #( - #default_fields - ),* + #default_fields, + )* + #marker } } } }; Some(q) } -pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Option { +pub fn derive_debug( + _struct: &vkxml::Struct, + union_types: &HashSet<&str>, + has_lifetime: bool, +) -> Option { let name = name_to_tokens(&_struct.name); let members = _struct .elements @@ -1487,9 +1494,10 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt } }); let name_str = name.to_string(); + let lifetime = has_lifetime.then(|| quote!(<'_>)); let q = quote! { #[cfg(feature = "debug")] - impl fmt::Debug for #name { + impl fmt::Debug for #name #lifetime { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt.debug_struct(#name_str) #(#debug_fields)* @@ -1503,6 +1511,7 @@ pub fn derive_debug(_struct: &vkxml::Struct, union_types: &HashSet<&str>) -> Opt pub fn derive_setters( struct_: &vkxml::Struct, root_structs: &HashSet, + has_lifetimes: &HashSet, ) -> Option { if &struct_.name == "VkBaseInStructure" || &struct_.name == "VkBaseOutStructure" @@ -1513,7 +1522,6 @@ pub fn derive_setters( } let name = name_to_tokens(&struct_.name); - let name_builder = name_to_tokens(&(struct_.name.clone() + "Builder")); let members = struct_ .elements @@ -1576,9 +1584,10 @@ pub fn derive_setters( // Unique cases if name == "pCode" { return Some(quote!{ + #[inline] pub fn code(mut self, code: &'a [u32]) -> Self { - self.inner.code_size = code.len() * 4; - self.inner.p_code = code.as_ptr(); + self.code_size = code.len() * 4; + self.p_code = code.as_ptr(); self } }); @@ -1591,8 +1600,9 @@ pub fn derive_setters( /// /// See /// for more details. + #[inline] pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self { - self.inner.p_sample_mask = if sample_mask.is_empty() { + self.p_sample_mask = if sample_mask.is_empty() { std::ptr::null() } else { sample_mask.as_ptr() @@ -1604,9 +1614,10 @@ pub fn derive_setters( if name == "ppGeometries" { return Some(quote!{ - pub fn geometries_ptrs(mut self, geometries: &'a [&'a AccelerationStructureGeometryKHR]) -> Self { - self.inner.geometry_count = geometries.len() as _; - self.inner.pp_geometries = geometries.as_ptr() as *const *const _; + #[inline] + pub fn geometries_ptrs(mut self, geometries: &'a [&'a AccelerationStructureGeometryKHR<'a>]) -> Self { + self.geometry_count = geometries.len() as _; + self.pp_geometries = geometries.as_ptr() as *const *const _; self } }); @@ -1619,8 +1630,9 @@ pub fn derive_setters( assert!(field.null_terminate); assert_eq!(field.size, None); return Some(quote!{ + #[inline] pub fn #param_ident_short(mut self, #param_ident_short: &'a ::std::ffi::CStr) -> Self { - self.inner.#param_ident = #param_ident_short.as_ptr(); + self.#param_ident = #param_ident_short.as_ptr(); self } }); @@ -1665,15 +1677,16 @@ pub fn derive_setters( quote!(as _) }; - quote!(self.inner.#array_size_ident = #param_ident_short.len()#cast;) + quote!(self.#array_size_ident = #param_ident_short.len()#cast;) }; let mutable = if field.is_const { quote!() } else { quote!(mut) }; return Some(quote! { + #[inline] pub fn #param_ident_short(mut self, #param_ident_short: &'a #mutable #slice_param_ty_tokens) -> Self { #set_size_stmt - self.inner.#param_ident = #param_ident_short#ptr; + self.#param_ident = #param_ident_short#ptr; self } }); @@ -1683,8 +1696,9 @@ pub fn derive_setters( if field.basetype == "VkBool32" { return Some(quote!{ + #[inline] pub fn #param_ident_short(mut self, #param_ident_short: bool) -> Self { - self.inner.#param_ident = #param_ident_short.into(); + self.#param_ident = #param_ident_short.into(); self } }); @@ -1697,9 +1711,14 @@ pub fn derive_setters( param_ty_tokens }; + let lifetime = has_lifetimes + .contains(&name_to_tokens(&field.basetype)) + .then(|| quote!(<'a>)); + Some(quote!{ - pub fn #param_ident_short(mut self, #param_ident_short: #param_ty_tokens) -> Self { - self.inner.#param_ident = #param_ident_short; + #[inline] + pub fn #param_ident_short(mut self, #param_ident_short: #param_ty_tokens #lifetime) -> Self { + self.#param_ident = #param_ident_short; self } }) @@ -1722,7 +1741,7 @@ pub fn derive_setters( /// Prepends the given extension struct between the root and the first pointer. This /// method only exists on structs that can be passed to a function directly. Only /// valid extension structs can be pushed into the chain. - /// If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the + /// If the chain looks like `A -> B -> C`, and you call `x.push_next(&mut D)`, then the /// chain will look like `A -> D -> B -> C`. pub fn push_next(mut self, next: &'a mut T) -> Self { unsafe { @@ -1737,8 +1756,8 @@ pub fn derive_setters( // ^^^^^^ // next chain let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr; + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; } self } @@ -1755,6 +1774,8 @@ pub fn derive_setters( quote!() }; + let lifetime = has_lifetimes.contains(&name).then(|| quote!(<'a>)); + // If the struct extends something we need to implement the traits. let impl_extend_trait = struct_ .extends @@ -1762,57 +1783,18 @@ pub fn derive_setters( .flat_map(|extends| extends.split(',')) .map(|extends| format_ident!("Extends{}", name_to_tokens(extends))) .map(|extends| { - quote! { - unsafe impl #extends for #name_builder<'_> {} - unsafe impl #extends for #name {} - } + // Extension structs always have a pNext, and therefore always have a lifetime. + quote!(unsafe impl #extends for #name<'_> {}) }); let q = quote! { - impl #name { - pub fn builder<'a>() -> #name_builder<'a> { - #name_builder { - inner: Self::default(), - marker: ::std::marker::PhantomData, - } - } - } - - #[repr(transparent)] - pub struct #name_builder<'a> { - inner: #name, - marker: ::std::marker::PhantomData<&'a ()>, - } - #(#impl_extend_trait)* #next_trait - - impl<'a> ::std::ops::Deref for #name_builder<'a> { - type Target = #name; - - fn deref(&self) -> &Self::Target { - &self.inner - } - } - - impl<'a> ::std::ops::DerefMut for #name_builder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } - } - - impl<'a> #name_builder<'a> { + impl #lifetime #name #lifetime { #(#setters)* #next_function - - /// Calling build will **discard** all the lifetime information. Only call this if - /// necessary! Builders implement `Deref` targeting their corresponding Vulkan struct, - /// so references to builders can be passed directly to Vulkan functions. - pub fn build(self) -> #name { - self.inner - } } }; @@ -1834,6 +1816,7 @@ pub fn generate_struct( _struct: &vkxml::Struct, root_structs: &HashSet, union_types: &HashSet<&str>, + has_lifetimes: &HashSet, ) -> TokenStream { let name = name_to_tokens(&_struct.name); if &_struct.name == "VkTransformMatrixKHR" { @@ -1916,14 +1899,24 @@ pub fn generate_struct( .map(|r| r.to_tokens(field.is_const)); quote!(#pointer Self) } else { - field.type_tokens(false) + let lifetime = has_lifetimes + .contains(&name_to_tokens(&field.basetype)) + .then(|| quote!(<'a>)); + let ty = field.type_tokens(false); + quote!(#ty #lifetime) }; quote! {pub #param_ident: #param_ty_tokens} }); - let debug_tokens = derive_debug(_struct, union_types); - let default_tokens = derive_default(_struct); - let setter_tokens = derive_setters(_struct, root_structs); + let has_lifetime = has_lifetimes.contains(&name); + let (lifetimes, marker) = match has_lifetime { + true => (quote!(<'a>), quote!(pub _marker: PhantomData<&'a ()>,)), + false => (quote!(), quote!()), + }; + + let debug_tokens = derive_debug(_struct, union_types, has_lifetime); + let default_tokens = derive_default(_struct, has_lifetime); + let setter_tokens = derive_setters(_struct, root_structs, has_lifetimes); let manual_derive_tokens = manual_derives(_struct); let dbg_str = if debug_tokens.is_none() { quote!(#[cfg_attr(feature = "debug", derive(Debug))]) @@ -1941,8 +1934,9 @@ pub fn generate_struct( #dbg_str #[derive(Copy, Clone, #default_str #manual_derive_tokens)] #[doc = #khronos_link] - pub struct #name { + pub struct #name #lifetimes { #(#params,)* + #marker } #debug_tokens #default_tokens @@ -1998,24 +1992,28 @@ fn generate_funcptr(fnptr: &vkxml::FunctionPointer) -> TokenStream { } } -fn generate_union(union: &vkxml::Union) -> TokenStream { +fn generate_union(union: &vkxml::Union, has_lifetimes: &HashSet) -> TokenStream { let name = name_to_tokens(&union.name); let fields = union.elements.iter().map(|field| { let name = field.param_ident(); let ty = field.type_tokens(false); + let lifetime = has_lifetimes + .contains(&name_to_tokens(&field.basetype)) + .then(|| quote!(<'a>)); quote! { - pub #name: #ty + pub #name: #ty #lifetime } }); let khronos_link = khronos_link(&union.name); + let lifetime = has_lifetimes.contains(&name).then(|| quote!(<'a>)); quote! { #[repr(C)] #[derive(Copy, Clone)] #[doc = #khronos_link] - pub union #name { + pub union #name #lifetime { #(#fields),* } - impl ::std::default::Default for #name { + impl #lifetime ::std::default::Default for #name #lifetime { fn default() -> Self { unsafe { ::std::mem::zeroed() } } @@ -2039,6 +2037,7 @@ pub fn generate_definition( definition: &vkxml::DefinitionsElement, union_types: &HashSet<&str>, root_structs: &HashSet, + has_lifetimes: &HashSet, bitflags_cache: &mut HashSet, const_values: &mut BTreeMap, identifier_renames: &mut BTreeMap, @@ -2048,15 +2047,18 @@ pub fn generate_definition( Some(generate_define(define, identifier_renames)) } vkxml::DefinitionsElement::Typedef(ref typedef) => Some(generate_typedef(typedef)), - vkxml::DefinitionsElement::Struct(ref _struct) => { - Some(generate_struct(_struct, root_structs, union_types)) - } + vkxml::DefinitionsElement::Struct(ref _struct) => Some(generate_struct( + _struct, + root_structs, + union_types, + has_lifetimes, + )), vkxml::DefinitionsElement::Bitmask(ref mask) => { generate_bitmask(mask, bitflags_cache, const_values) } vkxml::DefinitionsElement::Handle(ref handle) => generate_handle(handle), vkxml::DefinitionsElement::FuncPtr(ref fp) => Some(generate_funcptr(fp)), - vkxml::DefinitionsElement::Union(ref union) => Some(generate_union(union)), + vkxml::DefinitionsElement::Union(ref union) => Some(generate_union(union, has_lifetimes)), _ => None, } } @@ -2309,6 +2311,7 @@ pub fn extract_native_types(registry: &vk_parse::Registry) -> (Vec<(String, Stri } pub fn generate_aliases_of_types( types: &vk_parse::Types, + has_lifetimes: &HashSet, ty_cache: &mut HashSet, ) -> TokenStream { let aliases = types @@ -2323,8 +2326,10 @@ pub fn generate_aliases_of_types( return None; }; let alias_ident = name_to_tokens(alias); - let tokens = quote! { - pub type #name_ident = #alias_ident; + let tokens = if has_lifetimes.contains(&alias_ident) { + quote!(pub type #name_ident<'a> = #alias_ident<'a>;) + } else { + quote!(pub type #name_ident = #alias_ident;) }; Some(tokens) }); @@ -2343,13 +2348,6 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { .find_map(get_variant!(vk_parse::RegistryChild::Extensions)) .map(|ext| &ext.children) .expect("extension"); - let mut ty_cache = HashSet::new(); - let aliases: Vec<_> = spec2 - .0 - .iter() - .filter_map(get_variant!(vk_parse::RegistryChild::Types)) - .map(|ty| generate_aliases_of_types(ty, &mut ty_cache)) - .collect(); let spec = vk_parse::parse_file_as_vkxml(&vk_xml).expect("Invalid xml file."); let cmd_aliases: HashMap = spec2 @@ -2439,6 +2437,37 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { let mut identifier_renames = BTreeMap::new(); + // Identify structs that need a lifetime annotation + // Note that this relies on `vk.xml` defining types before they are used, + // as is required in C(++) too. + let mut has_lifetimes = definitions + .iter() + .filter_map(get_variant!(vkxml::DefinitionsElement::Struct)) + .filter_map(|s| { + s.elements + .iter() + .filter_map(get_variant!(vkxml::StructElement::Member)) + .any(|x| x.reference.is_some()) + .then(|| name_to_tokens(&s.name)) + }) + .collect::>(); + for def in &definitions { + match def { + vkxml::DefinitionsElement::Struct(s) => s + .elements + .iter() + .filter_map(get_variant!(vkxml::StructElement::Member)) + .any(|field| has_lifetimes.contains(&name_to_tokens(&field.basetype))) + .then(|| has_lifetimes.insert(name_to_tokens(&s.name))), + vkxml::DefinitionsElement::Union(u) => u + .elements + .iter() + .any(|field| has_lifetimes.contains(&name_to_tokens(&field.basetype))) + .then(|| has_lifetimes.insert(name_to_tokens(&u.name))), + _ => continue, + }; + } + let root_structs = root_structs(&definitions); let definition_code: Vec<_> = definitions .into_iter() @@ -2447,6 +2476,7 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { def, &union_types, &root_structs, + &has_lifetimes, &mut bitflags_cache, &mut const_values, &mut identifier_renames, @@ -2454,6 +2484,14 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { }) .collect(); + let mut ty_cache = HashSet::new(); + let aliases: Vec<_> = spec2 + .0 + .iter() + .filter_map(get_variant!(vk_parse::RegistryChild::Types)) + .map(|ty| generate_aliases_of_types(ty, &has_lifetimes, &mut ty_cache)) + .collect(); + let feature_code: Vec<_> = features .iter() .map(|feature| generate_feature(feature, &commands, &mut fn_cache)) @@ -2494,6 +2532,7 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { }; let definition_code = quote! { + use std::marker::PhantomData; use std::fmt; use std::os::raw::*; use crate::vk::{Handle, ptr_chain_iter};