vulkan-driver/src/pipeline.rs

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 // Copyright 2018 Jacob Lifshay
   3
   4 use api;
   5 use handle::{OwnedHandle, SharedHandle};
   6 use std::fmt;
   7 use std::ops::Deref;
   8
   9 #[derive(Debug)]
  10 pub struct PipelineLayout {
  11     pub push_constants_size: usize,
  12     pub push_constant_ranges: Vec<api::VkPushConstantRange>,
  13     pub descriptor_set_layouts: Vec<SharedHandle<api::VkDescriptorSetLayout>>,
  14 }
  15
  16 pub trait GenericPipeline: fmt::Debug + Sync + 'static {}
  17
  18 pub trait GenericPipelineSized: GenericPipeline + Sized {
  19     type PipelineCreateInfo;
  20     unsafe fn create(
  21         device: SharedHandle<api::VkDevice>,
  22         pipeline_cache: Option<SharedHandle<api::VkPipelineCache>>,
  23         create_info: &Self::PipelineCreateInfo,
  24     ) -> Self;
  25     fn to_pipeline(self) -> Pipeline;
  26 }
  27
  28 #[derive(Debug)]
  29 pub struct ComputePipeline {}
  30
  31 impl GenericPipeline for ComputePipeline {}
  32
  33 impl GenericPipelineSized for ComputePipeline {
  34     type PipelineCreateInfo = api::VkComputePipelineCreateInfo;
  35     unsafe fn create(
  36         _device: SharedHandle<api::VkDevice>,
  37         _pipeline_cache: Option<SharedHandle<api::VkPipelineCache>>,
  38         create_info: &api::VkComputePipelineCreateInfo,
  39     ) -> Self {
  40         parse_next_chain_const!{
  41             create_info,
  42             root = api::VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
  43         }
  44         if (create_info.flags & api::VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT) != 0 {
  45             unimplemented!();
  46         }
  47         unimplemented!()
  48     }
  49     fn to_pipeline(self) -> Pipeline {
  50         Pipeline::Compute(self)
  51     }
  52 }
  53
  54 #[derive(Debug)]
  55 pub struct GraphicsPipeline {}
  56
  57 impl GenericPipeline for GraphicsPipeline {}
  58
  59 impl GenericPipelineSized for GraphicsPipeline {
  60     type PipelineCreateInfo = api::VkGraphicsPipelineCreateInfo;
  61     unsafe fn create(
  62         _device: SharedHandle<api::VkDevice>,
  63         _pipeline_cache: Option<SharedHandle<api::VkPipelineCache>>,
  64         create_info: &api::VkGraphicsPipelineCreateInfo,
  65     ) -> Self {
  66         parse_next_chain_const!{
  67             create_info,
  68             root = api::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
  69         }
  70         unimplemented!()
  71     }
  72     fn to_pipeline(self) -> Pipeline {
  73         Pipeline::Graphics(self)
  74     }
  75 }
  76
  77 #[derive(Debug)]
  78 pub enum Pipeline {
  79     Compute(ComputePipeline),
  80     Graphics(GraphicsPipeline),
  81 }
  82
  83 impl Deref for Pipeline {
  84     type Target = dyn GenericPipeline;
  85     fn deref(&self) -> &dyn GenericPipeline {
  86         match self {
  87             Pipeline::Compute(v) => v,
  88             Pipeline::Graphics(v) => v,
  89         }
  90     }
  91 }
  92
  93 pub unsafe fn create_pipelines<T: GenericPipelineSized>(
  94     device: SharedHandle<api::VkDevice>,
  95     pipeline_cache: Option<SharedHandle<api::VkPipelineCache>>,
  96     create_infos: &[T::PipelineCreateInfo],
  97     pipelines: &mut [api::VkPipeline],
  98 ) -> api::VkResult {
  99     assert_eq!(create_infos.len(), pipelines.len());
 100     for (pipeline, create_info) in pipelines.iter_mut().zip(create_infos.iter()) {
 101         *pipeline = OwnedHandle::<api::VkPipeline>::new(
 102             T::create(device, pipeline_cache, create_info).to_pipeline(),
 103         )
 104         .take();
 105     }
 106     api::VK_SUCCESS
 107 }