Move shaders into pipeline description and unify base pipelines

Author: msiglreith

examples/hal/compute/main.rs

@@ -64,7 +64,7 @@ fn main() {
         let entry_point = pso::EntryPoint { entry: "main", module: &shader };
         let pipeline = gpu.device
             .create_compute_pipelines(&[
-                (entry_point, pso::ComputePipelineDesc::new(&pipeline_layout))
+                pso::ComputePipelineDesc::new(entry_point, &pipeline_layout)
             ])
             .remove(0)
             .expect("Error creating compute pipeline!");

examples/hal/quad/main.rs

@@ -232,6 +232,7 @@ fn main() {
         let subpass = Subpass { index: 0, main_pass: &render_pass };
 
         let mut pipeline_desc = pso::GraphicsPipelineDesc::new(
+            shader_entries,
             Primitive::TriangleList,
             pso::Rasterizer::FILL,
             &pipeline_layout,
@@ -264,9 +265,7 @@ fn main() {
         });
 
 
-        device.create_graphics_pipelines(&[
-            (shader_entries, pipeline_desc)
-        ])
+        device.create_graphics_pipelines(&[pipeline_desc])
     };
 
     println!("pipelines: {:?}", pipelines);

src/backend/dx12/src/device.rs

@@ -765,9 +765,9 @@ impl d::Device<B> for Device {
 
     fn create_graphics_pipelines<'a>(
         &self,
-        descs: &[(pso::GraphicsShaderSet<'a, B>, pso::GraphicsPipelineDesc<'a, B>)],
+        descs: &[pso::GraphicsPipelineDesc<'a, B>],
     ) -> Vec<Result<n::GraphicsPipeline, pso::CreationError>> {
-        descs.iter().map(|&(shaders, ref desc)| {
+        descs.iter().map(|desc| {
             let build_shader = |source: Option<pso::EntryPoint<'a, B>>| {
                 // TODO: better handle case where looking up shader fails
                 let shader = source.and_then(|src| src.module.shaders.get(src.entry));
@@ -787,11 +787,11 @@ impl d::Device<B> for Device {
                 }
             };
 
-            let vs = build_shader(Some(shaders.vertex));
-            let fs = build_shader(shaders.fragment);
-            let gs = build_shader(shaders.geometry);
-            let ds = build_shader(shaders.domain);
-            let hs = build_shader(shaders.hull);
+            let vs = build_shader(Some(desc.shaders.vertex));
+            let fs = build_shader(desc.shaders.fragment);
+            let gs = build_shader(desc.shaders.geometry);
+            let ds = build_shader(desc.shaders.domain);
+            let hs = build_shader(desc.shaders.hull);
 
             // Define input element descriptions
             let mut vs_reflect = shade::reflect_shader(&vs);
@@ -936,12 +936,12 @@ impl d::Device<B> for Device {
 
     fn create_compute_pipelines<'a>(
         &self,
-        descs: &[(pso::EntryPoint<'a, B>, pso::ComputePipelineDesc<'a, B>)],
+        descs: &[pso::ComputePipelineDesc<'a, B>],
     ) -> Vec<Result<n::ComputePipeline, pso::CreationError>> {
-        descs.iter().map(|&(shader, ref desc)| {
+        descs.iter().map(|desc| {
             let cs = {
                 // TODO: better handle case where looking up shader fails
-                match shader.module.shaders.get(shader.entry) {
+                match desc.shader.module.shaders.get(desc.shader.entry) {
                     Some(shader) => {
                         winapi::D3D12_SHADER_BYTECODE {
                             pShaderBytecode: unsafe { (**shader).GetBufferPointer() as *const _ },

src/backend/empty/src/lib.rs

@@ -97,14 +97,14 @@ impl hal::Device<Backend> for Device {
 
     fn create_graphics_pipelines<'a>(
         &self,
-        _: &[(pso::GraphicsShaderSet<'a, Backend>, pso::GraphicsPipelineDesc<'a, Backend>)],
+        _: &[pso::GraphicsPipelineDesc<'a, Backend>],
     ) -> Vec<Result<(), pso::CreationError>> {
         unimplemented!()
     }
 
     fn create_compute_pipelines<'a>(
         &self,
-        _: &[(pso::EntryPoint<'a, Backend>, pso::ComputePipelineDesc<'a, Backend>)],
+        _: &[pso::ComputePipelineDesc<'a, Backend>],
     ) -> Vec<Result<(), pso::CreationError>> {
         unimplemented!()
     }

src/backend/gl/src/device.rs

@@ -233,13 +233,13 @@ impl d::Device<B> for Device {
 
     fn create_graphics_pipelines<'a>(
         &self,
-        descs: &[(pso::GraphicsShaderSet<'a, B>, pso::GraphicsPipelineDesc<'a, B>)],
+        descs: &[pso::GraphicsPipelineDesc<'a, B>],
     ) -> Vec<Result<n::GraphicsPipeline, pso::CreationError>> {
         let gl = &self.share.context;
         let priv_caps = &self.share.private_caps;
         let share = &self.share;
         descs.iter()
-             .map(|&(shaders, ref desc)| {
+             .map(|desc| {
                 let subpass = {
                     let subpass = desc.subpass;
                     match subpass.main_pass.subpasses.get(subpass.index) {
@@ -259,11 +259,11 @@ impl d::Device<B> for Device {
                     };
 
                     // Attach shaders to program
-                    attach_shader(Some(shaders.vertex));
-                    attach_shader(shaders.hull);
-                    attach_shader(shaders.domain);
-                    attach_shader(shaders.geometry);
-                    attach_shader(shaders.fragment);
+                    attach_shader(Some(desc.shaders.vertex));
+                    attach_shader(desc.shaders.hull);
+                    attach_shader(desc.shaders.domain);
+                    attach_shader(desc.shaders.geometry);
+                    attach_shader(desc.shaders.fragment);
 
                     if !priv_caps.program_interface && priv_caps.frag_data_location {
                         for i in 0..subpass.color_attachments.len() {
@@ -302,7 +302,7 @@ impl d::Device<B> for Device {
 
     fn create_compute_pipelines<'a>(
         &self,
-        _descs: &[(pso::EntryPoint<'a, B>, pso::ComputePipelineDesc<'a, B>)],
+        _descs: &[pso::ComputePipelineDesc<'a, B>],
     ) -> Vec<Result<n::ComputePipeline, pso::CreationError>> {
         unimplemented!()
     }

src/backend/metal/src/device.rs

@@ -257,8 +257,7 @@ impl Device {
 
     fn create_graphics_pipeline<'a>(
         &self,
-        &(ref shader_set, ref pipeline_desc):
-        &(pso::GraphicsShaderSet<'a, Backend>, pso::GraphicsPipelineDesc<'a, Backend>),
+        pipeline_desc: &pso::GraphicsPipelineDesc<'a, Backend>,
     ) -> Result<n::GraphicsPipeline, pso::CreationError> {
         let pipeline = metal::RenderPipelineDescriptor::new();
         let pipeline_layout = &pipeline_desc.layout;
@@ -277,21 +276,21 @@ impl Device {
         pipeline.set_input_primitive_topology(primitive_class);
 
         // Shaders
-        let vs_lib = match shader_set.vertex.module {
+        let vs_lib = match pipeline_desc.shaders.vertex.module {
             &n::ShaderModule::Compiled(ref lib) => lib.to_owned(),
             &n::ShaderModule::Raw(ref data) => {
                 //TODO: cache them all somewhere!
                 self.compile_shader_library(data, &pipeline_layout.res_overrides).unwrap()
             },
         };
         let mtl_vertex_function = vs_lib
-            .get_function(shader_set.vertex.entry)
+            .get_function(pipeline_desc.shaders.vertex.entry)
             .ok_or_else(|| {
                 error!("invalid vertex shader entry point");
                 pso::CreationError::Other
             })?;
         pipeline.set_vertex_function(Some(&mtl_vertex_function));
-        let fs_lib = if let Some(fragment_entry) = shader_set.fragment {
+        let fs_lib = if let Some(fragment_entry) = pipeline_desc.shaders.fragment {
             let fs_lib = match fragment_entry.module {
                 &n::ShaderModule::Compiled(ref lib) => lib.to_owned(),
                 &n::ShaderModule::Raw(ref data) => {
@@ -309,15 +308,15 @@ impl Device {
         } else {
             None
         };
-        if shader_set.hull.is_some() {
+        if pipeline_desc.shaders.hull.is_some() {
             error!("Metal tesselation shaders are not supported");
             return Err(pso::CreationError::Other);
         }
-        if shader_set.domain.is_some() {
+        if pipeline_desc.shaders.domain.is_some() {
             error!("Metal tesselation shaders are not supported");
             return Err(pso::CreationError::Other);
         }
-        if shader_set.geometry.is_some() {
+        if pipeline_desc.shaders.geometry.is_some() {
             error!("Metal geometry shaders are not supported");
             return Err(pso::CreationError::Other);
         }
@@ -544,7 +543,7 @@ impl hal::Device<Backend> for Device {
 
     fn create_graphics_pipelines<'a>(
         &self,
-        params: &[(pso::GraphicsShaderSet<'a, Backend>, pso::GraphicsPipelineDesc<'a, Backend>)],
+        params: &[pso::GraphicsPipelineDesc<'a, Backend>],
     ) -> Vec<Result<n::GraphicsPipeline, pso::CreationError>> {
         let mut output = Vec::with_capacity(params.len());
         for param in params {
@@ -555,7 +554,7 @@ impl hal::Device<Backend> for Device {
 
     fn create_compute_pipelines<'a>(
         &self,
-        _pipelines: &[(pso::EntryPoint<'a, Backend>, pso::ComputePipelineDesc<'a, Backend>)],
+        _pipelines: &[pso::ComputePipelineDesc<'a, Backend>],
     ) -> Vec<Result<n::ComputePipeline, pso::CreationError>> {
         unimplemented!()
     }

src/backend/vulkan/src/device.rs

@@ -249,7 +249,7 @@ impl d::Device<B> for Device {
 
     fn create_graphics_pipelines<'a>(
         &self,
-        descs: &[(pso::GraphicsShaderSet<'a, B>, pso::GraphicsPipelineDesc<'a, B>)],
+        descs: &[pso::GraphicsPipelineDesc<'a, B>],
     ) -> Vec<Result<n::GraphicsPipeline, pso::CreationError>> {
         debug!("create_graphics_pipelines {:?}", descs);
         // Store pipeline parameters to avoid stack usage
@@ -283,26 +283,26 @@ impl d::Device<B> for Device {
             }
         };
 
-        let infos = descs.iter().map(|&(shaders, ref desc)| {
+        let infos = descs.iter().map(|desc| {
             let mut stages = Vec::new();
             // Vertex stage
             if true { //vertex shader is required
-                stages.push(make_stage(vk::SHADER_STAGE_VERTEX_BIT, shaders.vertex));
+                stages.push(make_stage(vk::SHADER_STAGE_VERTEX_BIT, desc.shaders.vertex));
             }
             // Pixel stage
-            if let Some(entry) = shaders.fragment {
+            if let Some(entry) = desc.shaders.fragment {
                 stages.push(make_stage(vk::SHADER_STAGE_FRAGMENT_BIT, entry));
             }
             // Geometry stage
-            if let Some(entry) = shaders.geometry {
+            if let Some(entry) = desc.shaders.geometry {
                 stages.push(make_stage(vk::SHADER_STAGE_GEOMETRY_BIT, entry));
             }
             // Domain stage
-            if let Some(entry) = shaders.domain {
+            if let Some(entry) = desc.shaders.domain {
                 stages.push(make_stage(vk::SHADER_STAGE_TESSELLATION_EVALUATION_BIT, entry));
             }
             // Hull stage
-            if let Some(entry) = shaders.hull {
+            if let Some(entry) = desc.shaders.hull {
                 stages.push(make_stage(vk::SHADER_STAGE_TESSELLATION_CONTROL_BIT, entry));
             }
 
@@ -363,7 +363,7 @@ impl d::Device<B> for Device {
                 p_next: ptr::null(),
                 flags: vk::PipelineRasterizationStateCreateFlags::empty(),
                 depth_clamp_enable: if desc.rasterizer.depth_clamping { vk::VK_TRUE } else { vk::VK_FALSE },
-                rasterizer_discard_enable: if shaders.fragment.is_none() { vk::VK_TRUE } else { vk::VK_FALSE },
+                rasterizer_discard_enable: if desc.shaders.fragment.is_none() { vk::VK_TRUE } else { vk::VK_FALSE },
                 polygon_mode: polygon_mode,
                 cull_mode: desc.rasterizer.cull_face.map(conv::map_cull_face).unwrap_or(vk::CULL_MODE_NONE),
                 front_face: conv::map_front_face(desc.rasterizer.front_face),
@@ -374,7 +374,7 @@ impl d::Device<B> for Device {
                 line_width: line_width,
             });
 
-            let is_tessellated = shaders.hull.is_some() && shaders.domain.is_some();
+            let is_tessellated = desc.shaders.hull.is_some() && desc.shaders.domain.is_some();
             if is_tessellated {
                 info_tessellation_states.push(vk::PipelineTessellationStateCreateInfo {
                     s_type: vk::StructureType::PipelineTessellationStateCreateInfo,
@@ -484,13 +484,13 @@ impl d::Device<B> for Device {
             });
 
             let (base_handle, base_index) = match desc.parent {
-                pso::BaseGraphics::Pipeline(pipeline) => (pipeline.0, -1),
-                pso::BaseGraphics::Index(index) => (vk::Pipeline::null(), index as _),
-                pso::BaseGraphics::None => (vk::Pipeline::null(), -1),
+                pso::BasePipeline::Pipeline(pipeline) => (pipeline.0, -1),
+                pso::BasePipeline::Index(index) => (vk::Pipeline::null(), index as _),
+                pso::BasePipeline::None => (vk::Pipeline::null(), -1),
             };
 
             let mut flags = vk::PipelineCreateFlags::empty();
-            if let pso::BaseGraphics::None = desc.parent {
+            if let pso::BasePipeline::None = desc.parent {
                 flags |= vk::PIPELINE_CREATE_DERIVATIVE_BIT;
             }
             if desc.flags.contains(pso::PipelineCreationFlags::DISABLE_OPTIMIZATION) {
@@ -557,11 +557,11 @@ impl d::Device<B> for Device {
 
     fn create_compute_pipelines<'a>(
         &self,
-        descs: &[(pso::EntryPoint<'a, B>, pso::ComputePipelineDesc<'a, B>)],
+        descs: &[pso::ComputePipelineDesc<'a, B>],
     ) -> Vec<Result<n::ComputePipeline, pso::CreationError>> {
         let mut c_strings = Vec::new(); // hold the C strings temporarily
-        let infos = descs.iter().map(|&(entry_point, ref desc)| {
-            let string = CString::new(entry_point.entry).unwrap();
+        let infos = descs.iter().map(|desc| {
+            let string = CString::new(desc.shader.entry).unwrap();
             let p_name = string.as_ptr();
             c_strings.push(string);
 
@@ -570,19 +570,19 @@ impl d::Device<B> for Device {
                 p_next: ptr::null(),
                 flags: vk::PipelineShaderStageCreateFlags::empty(),
                 stage: vk::SHADER_STAGE_COMPUTE_BIT,
-                module: entry_point.module.raw,
+                module: desc.shader.module.raw,
                 p_name,
                 p_specialization_info: ptr::null(),
             };
 
             let (base_handle, base_index) = match desc.parent {
-                pso::BaseCompute::Pipeline(pipeline) => (pipeline.0, -1),
-                pso::BaseCompute::Index(index) => (vk::Pipeline::null(), index as _),
-                pso::BaseCompute::None => (vk::Pipeline::null(), -1),
+                pso::BasePipeline::Pipeline(pipeline) => (pipeline.0, -1),
+                pso::BasePipeline::Index(index) => (vk::Pipeline::null(), index as _),
+                pso::BasePipeline::None => (vk::Pipeline::null(), -1),
             };
 
             let mut flags = vk::PipelineCreateFlags::empty();
-            if let pso::BaseCompute::None = desc.parent {
+            if let pso::BasePipeline::None = desc.parent {
                 flags |= vk::PIPELINE_CREATE_DERIVATIVE_BIT;
             }
             if desc.flags.contains(pso::PipelineCreationFlags::DISABLE_OPTIMIZATION) {

src/hal/src/device.rs

@@ -154,7 +154,7 @@ pub trait Device<B: Backend> {
     /// Create graphics pipelines.
     fn create_graphics_pipelines<'a>(
         &self,
-        &[(pso::GraphicsShaderSet<'a, B>, pso::GraphicsPipelineDesc<'a, B>)],
+        &[pso::GraphicsPipelineDesc<'a, B>],
     ) -> Vec<Result<B::GraphicsPipeline, pso::CreationError>>;
 
     /// Destroys a graphics pipeline.
@@ -166,7 +166,7 @@ pub trait Device<B: Backend> {
     /// Create compute pipelines.
     fn create_compute_pipelines<'a>(
         &self,
-        &[(pso::EntryPoint<'a, B>, pso::ComputePipelineDesc<'a, B>)],
+        &[pso::ComputePipelineDesc<'a, B>],
     ) -> Vec<Result<B::ComputePipeline, pso::CreationError>>;
 
     /// Destroys a compute pipeline.

src/hal/src/pso/compute.rs

@@ -1,11 +1,13 @@
 //! Compute pipeline descriptor.
 
 use Backend;
-use super::{BaseCompute, PipelineCreationFlags};
+use super::{BaseCompute, BasePipeline, EntryPoint, PipelineCreationFlags};
 
 ///
 #[derive(Debug)]
 pub struct ComputePipelineDesc<'a, B: Backend> {
+    ///
+    pub shader: EntryPoint<'a, B>,
     /// Pipeline layout.
     pub layout: &'a B::PipelineLayout,
     ///
@@ -17,12 +19,14 @@ pub struct ComputePipelineDesc<'a, B: Backend> {
 impl<'a, B: Backend> ComputePipelineDesc<'a, B> {
     /// Create a new empty PSO descriptor.
     pub fn new(
+        shader: EntryPoint<'a, B>,
         layout: &'a B::PipelineLayout,
     ) -> Self {
         ComputePipelineDesc {
+            shader,
             layout,
             flags: PipelineCreationFlags::empty(),
-            parent: BaseCompute::None,
+            parent: BasePipeline::None,
         }
     }
 }