feat!: make ProgrammableStage::entry_point optional in wgpu-core

Author: ErichDonGubler

CHANGELOG.md

@@ -102,6 +102,7 @@ Bottom level categories:
 ```
 - `wgpu::Id` now implements `PartialOrd`/`Ord` allowing it to be put in `BTreeMap`s. By @cwfitzgerald and @9291Sam in [#5176](https://github.com/gfx-rs/wgpu/pull/5176)
 - `wgpu::CommandEncoder::write_timestamp` requires now the new `wgpu::Features::TIMESTAMP_QUERY_INSIDE_ENCODERS` feature which is available on all native backends but not on WebGPU (due to a spec change `write_timestamp` is no longer supported on WebGPU). By @wumpf in [#5188](https://github.com/gfx-rs/wgpu/pull/5188)
+- BREAKING CHANGE: [`wgpu_core::pipeline::ProgrammableStageDescriptor`](https://docs.rs/wgpu-core/latest/wgpu_core/pipeline/struct.ProgrammableStageDescriptor.html#structfield.entry_point) is now optional. By @ErichDonGubler in [#????](https://github.com/gfx-rs/wgpu/pull/????).
 
 #### GLES
 

wgpu-core/src/device/resource.rs

@@ -2679,14 +2679,21 @@ impl<A: HalApi> Device<A> {
         let mut shader_binding_sizes = FastHashMap::default();
         let io = validation::StageIo::default();
 
+        let final_entry_point_name;
+
         {
             let stage = wgt::ShaderStages::COMPUTE;
 
+            final_entry_point_name = shader_module.finalize_entry_point_name(
+                stage,
+                desc.stage.entry_point.as_ref().map(|ep| ep.as_ref()),
+            )?;
+
             if let Some(ref interface) = shader_module.interface {
                 let _ = interface.check_stage(
                     &mut binding_layout_source,
                     &mut shader_binding_sizes,
-                    &desc.stage.entry_point,
+                    &final_entry_point_name,
                     stage,
                     io,
                     None,
@@ -2714,7 +2721,7 @@ impl<A: HalApi> Device<A> {
             label: desc.label.to_hal(self.instance_flags),
             layout: pipeline_layout.raw(),
             stage: hal::ProgrammableStage {
-                entry_point: desc.stage.entry_point.as_ref(),
+                entry_point: final_entry_point_name.as_ref(),
                 module: shader_module.raw(),
             },
         };
@@ -3086,6 +3093,7 @@ impl<A: HalApi> Device<A> {
         };
 
         let vertex_shader_module;
+        let vertex_entry_point_name;
         let vertex_stage = {
             let stage_desc = &desc.vertex.stage;
             let stage = wgt::ShaderStages::VERTEX;
@@ -3102,12 +3110,19 @@ impl<A: HalApi> Device<A> {
 
             let stage_err = |error| pipeline::CreateRenderPipelineError::Stage { stage, error };
 
+            vertex_entry_point_name = vertex_shader_module
+                .finalize_entry_point_name(
+                    stage,
+                    stage_desc.entry_point.as_ref().map(|ep| ep.as_ref()),
+                )
+                .map_err(stage_err)?;
+
             if let Some(ref interface) = vertex_shader_module.interface {
                 io = interface
                     .check_stage(
                         &mut binding_layout_source,
                         &mut shader_binding_sizes,
-                        &stage_desc.entry_point,
+                        &vertex_entry_point_name,
                         stage,
                         io,
                         desc.depth_stencil.as_ref().map(|d| d.depth_compare),
@@ -3118,11 +3133,12 @@ impl<A: HalApi> Device<A> {
 
             hal::ProgrammableStage {
                 module: vertex_shader_module.raw(),
-                entry_point: stage_desc.entry_point.as_ref(),
+                entry_point: &vertex_entry_point_name,
             }
         };
 
         let mut fragment_shader_module = None;
+        let fragment_entry_point_name;
         let fragment_stage = match desc.fragment {
             Some(ref fragment_state) => {
                 let stage = wgt::ShaderStages::FRAGMENT;
@@ -3138,13 +3154,24 @@ impl<A: HalApi> Device<A> {
 
                 let stage_err = |error| pipeline::CreateRenderPipelineError::Stage { stage, error };
 
+                fragment_entry_point_name = shader_module
+                    .finalize_entry_point_name(
+                        stage,
+                        fragment_state
+                            .stage
+                            .entry_point
+                            .as_ref()
+                            .map(|ep| ep.as_ref()),
+                    )
+                    .map_err(stage_err)?;
+
                 if validated_stages == wgt::ShaderStages::VERTEX {
                     if let Some(ref interface) = shader_module.interface {
                         io = interface
                             .check_stage(
                                 &mut binding_layout_source,
                                 &mut shader_binding_sizes,
-                                &fragment_state.stage.entry_point,
+                                &fragment_entry_point_name,
                                 stage,
                                 io,
                                 desc.depth_stencil.as_ref().map(|d| d.depth_compare),
@@ -3156,7 +3183,7 @@ impl<A: HalApi> Device<A> {
 
                 if let Some(ref interface) = shader_module.interface {
                     shader_expects_dual_source_blending = interface
-                        .fragment_uses_dual_source_blending(&fragment_state.stage.entry_point)
+                        .fragment_uses_dual_source_blending(&fragment_entry_point_name)
                         .map_err(|error| pipeline::CreateRenderPipelineError::Stage {
                             stage,
                             error,
@@ -3165,7 +3192,7 @@ impl<A: HalApi> Device<A> {
 
                 Some(hal::ProgrammableStage {
                     module: shader_module.raw(),
-                    entry_point: fragment_state.stage.entry_point.as_ref(),
+                    entry_point: &fragment_entry_point_name,
                 })
             }
             None => None,

wgpu-core/src/pipeline.rs

@@ -92,6 +92,20 @@ impl<A: HalApi> ShaderModule<A> {
     pub(crate) fn raw(&self) -> &A::ShaderModule {
         self.raw.as_ref().unwrap()
     }
+
+    pub(crate) fn finalize_entry_point_name(
+        &self,
+        stage_bit: wgt::ShaderStages,
+        entry_point: Option<&str>,
+    ) -> Result<validation::FinalizedEntryPointName, validation::StageError> {
+        match &self.interface {
+            Some(interface) => interface.finalize_entry_point_name(stage_bit, entry_point),
+            None => entry_point
+                .map(|ep| ep.to_string())
+                .map(validation::FinalizedEntryPointName::new)
+                .ok_or(validation::StageError::NoEntryPointFound),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -213,9 +227,13 @@ impl CreateShaderModuleError {
 pub struct ProgrammableStageDescriptor<'a> {
     /// The compiled shader module for this stage.
     pub module: ShaderModuleId,
-    /// The name of the entry point in the compiled shader. There must be a function with this name
-    /// in the shader.
-    pub entry_point: Cow<'a, str>,
+    /// The name of the entry point in the compiled shader. The name is selected using the
+    /// following logic:
+    ///
+    /// * If `Some(name)` is specified, there must be a function with this name in the shader.
+    /// * If a single entry point associated with this stage must be in the shader, then proceed as
+    ///   if `Some(…)` was specified with that entry point's name.
+    pub entry_point: Option<Cow<'a, str>>,
 }
 
 /// Number of implicit bind groups derived at pipeline creation.

wgpu-core/src/validation.rs

@@ -4,7 +4,7 @@ use crate::{
     FastHashMap, FastHashSet,
 };
 use arrayvec::ArrayVec;
-use std::{collections::hash_map::Entry, fmt};
+use std::{collections::hash_map::Entry, fmt, ops::Deref};
 use thiserror::Error;
 use wgt::{BindGroupLayoutEntry, BindingType};
 
@@ -283,6 +283,16 @@ pub enum StageError {
     },
     #[error("Location[{location}] is provided by the previous stage output but is not consumed as input by this stage.")]
     InputNotConsumed { location: wgt::ShaderLocation },
+    #[error(
+        "Unable to select an entry point: no entry point was found in the provided shader module"
+    )]
+    NoEntryPointFound,
+    #[error(
+        "Unable to select an entry point: \
+        multiple entry points were found in the provided shader module, \
+        but no entry point was specified"
+    )]
+    MultipleEntryPointsFound,
 }
 
 fn map_storage_format_to_naga(format: wgt::TextureFormat) -> Option<naga::StorageFormat> {
@@ -971,6 +981,30 @@ impl Interface {
         }
     }
 
+    pub fn finalize_entry_point_name(
+        &self,
+        stage_bit: wgt::ShaderStages,
+        entry_point_name: Option<&str>,
+    ) -> Result<FinalizedEntryPointName, StageError> {
+        let stage = Self::shader_stage_from_stage_bit(stage_bit);
+        Ok(FinalizedEntryPointName::new(
+            entry_point_name
+                .map(|ep| ep.to_string())
+                .map(Ok)
+                .unwrap_or_else(|| {
+                    let mut entry_points = self
+                        .entry_points
+                        .keys()
+                        .filter_map(|(ep_stage, name)| (ep_stage == &stage).then_some(name));
+                    let first = entry_points.next().ok_or(StageError::NoEntryPointFound)?;
+                    entry_points
+                        .next()
+                        .ok_or(StageError::MultipleEntryPointsFound)?;
+                    Ok(first.clone())
+                })?,
+        ))
+    }
+
     pub(crate) fn shader_stage_from_stage_bit(stage_bit: wgt::ShaderStages) -> naga::ShaderStage {
         match stage_bit {
             wgt::ShaderStages::VERTEX => naga::ShaderStage::Vertex,
@@ -984,7 +1018,7 @@ impl Interface {
         &self,
         layouts: &mut BindingLayoutSource<'_>,
         shader_binding_sizes: &mut FastHashMap<naga::ResourceBinding, wgt::BufferSize>,
-        entry_point_name: &str,
+        entry_point_name: &FinalizedEntryPointName,
         stage_bit: wgt::ShaderStages,
         inputs: StageIo,
         compare_function: Option<wgt::CompareFunction>,
@@ -993,10 +1027,11 @@ impl Interface {
         // we need to look for one with the right execution model.
         let shader_stage = Self::shader_stage_from_stage_bit(stage_bit);
         let pair = (shader_stage, entry_point_name.to_string());
-        let entry_point = self
-            .entry_points
-            .get(&pair)
-            .ok_or(StageError::MissingEntryPoint(pair.1))?;
+        let entry_point = match self.entry_points.get(&pair) {
+            Some(some) => some,
+            None => return Err(StageError::MissingEntryPoint(pair.1)),
+        };
+        let (_stage, entry_point_name) = pair;
 
         // check resources visibility
         for &handle in entry_point.resources.iter() {
@@ -1294,3 +1329,23 @@ pub fn validate_color_attachment_bytes_per_sample(
 
     Ok(())
 }
+
+/// An entry point name finalized with [`Interface::finalize_entry_point_name`].
+#[derive(Debug)]
+pub struct FinalizedEntryPointName {
+    inner: String,
+}
+
+impl Deref for FinalizedEntryPointName {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.as_ref()
+    }
+}
+
+impl FinalizedEntryPointName {
+    pub(crate) fn new(inner: String) -> Self {
+        Self { inner }
+    }
+}

wgpu/src/backend/wgpu_core.rs

@@ -1102,7 +1102,7 @@ impl crate::Context for ContextWgpuCore {
             vertex: pipe::VertexState {
                 stage: pipe::ProgrammableStageDescriptor {
                     module: desc.vertex.module.id.into(),
-                    entry_point: Borrowed(desc.vertex.entry_point),
+                    entry_point: Some(Borrowed(desc.vertex.entry_point)),
                 },
                 buffers: Borrowed(&vertex_buffers),
             },
@@ -1112,7 +1112,7 @@ impl crate::Context for ContextWgpuCore {
             fragment: desc.fragment.as_ref().map(|frag| pipe::FragmentState {
                 stage: pipe::ProgrammableStageDescriptor {
                     module: frag.module.id.into(),
-                    entry_point: Borrowed(frag.entry_point),
+                    entry_point: Some(Borrowed(frag.entry_point)),
                 },
                 targets: Borrowed(frag.targets),
             }),
@@ -1160,7 +1160,7 @@ impl crate::Context for ContextWgpuCore {
             layout: desc.layout.map(|l| l.id.into()),
             stage: pipe::ProgrammableStageDescriptor {
                 module: desc.module.id.into(),
-                entry_point: Borrowed(desc.entry_point),
+                entry_point: Some(Borrowed(desc.entry_point)),
             },
         };