mesh shaders init pipelies

save

remove printlns


some cleanup

tiny fixes


ask for task shader as well


rewrite to use existing RenderPipeline

FIX!

Author: MatusT

Cargo.lock

@@ -402,6 +402,39 @@ impl GlobalExt for wgc::hub::Global<IdentityPassThroughFactory> {
             A::DestroyRenderPipeline(id) => {
                 self.render_pipeline_destroy::<B>(id);
             }
+            A::CreateMeshPipeline { id, desc } => {
+                let task_stage = desc.task_stage.map(OwnedProgrammableStage::from);
+                let mesh_stage = OwnedProgrammableStage::from(desc.mesh_stage);
+                let fragment_stage = desc.fragment_stage.map(OwnedProgrammableStage::from);
+                self.device_maintain_ids::<B>(device);
+                self.device_create_mesh_pipeline::<B>(
+                    device,
+                    &wgc::pipeline::MeshPipelineDescriptor {
+                        layout: desc.layout,
+                        task_stage: task_stage.as_ref().map_or(ptr::null(), |s| &s.desc),
+                        mesh_stage: mesh_stage.desc,
+                        fragment_stage: fragment_stage.as_ref().map_or(ptr::null(), |s| &s.desc),
+                        primitive_topology: desc.primitive_topology,
+                        rasterization_state: desc
+                            .rasterization_state
+                            .as_ref()
+                            .map_or(ptr::null(), |rs| rs),
+                        color_states: desc.color_states.as_ptr(),
+                        color_states_length: desc.color_states.len(),
+                        depth_stencil_state: desc
+                            .depth_stencil_state
+                            .as_ref()
+                            .map_or(ptr::null(), |ds| ds),
+                        sample_count: desc.sample_count,
+                        sample_mask: desc.sample_mask,
+                        alpha_to_coverage_enabled: desc.alpha_to_coverage_enabled,
+                    },
+                    id,
+                );
+            }
+            A::DestroyMeshPipeline(id) => {
+                self.mesh_pipeline_destroy::<B>(id);
+            }
             A::WriteBuffer {
                 id,
                 data,

player/src/main.rs

@@ -28,10 +28,10 @@ bitflags = "1.0"
 copyless = "0.1"
 fxhash = "0.2"
 log = "0.4"
-hal = { package = "gfx-hal", version = "0.5" }
-gfx-backend-empty = "0.5"
-gfx-descriptor = "0.1"
-gfx-memory = "0.1"
+hal = { package = "gfx-hal", path = "../../gfx/src/hal", version = "0.5" }
+gfx-backend-empty = { path = "../../gfx/src/backend/empty", version = "0.5" }
+gfx-descriptor = { path = "../../gfx-extras/gfx-descriptor", version = "0.1" }
+gfx-memory = { path = "../../gfx-extras/gfx-memory", version = "0.1" }
 parking_lot = "0.10"
 peek-poke = "0.2"
 raw-window-handle = { version = "0.3", optional = true }
@@ -52,16 +52,16 @@ version = "0.5"
 features = ["peek-poke"]
 
 [target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
-gfx-backend-metal = { version = "0.5" }
-gfx-backend-vulkan = { version = "0.5", optional = true }
+gfx-backend-metal = { path = "../../gfx/src/backend/metal", version = "0.5" }
+gfx-backend-vulkan = { path = "../../gfx/src/backend/vulkan", version = "0.5", optional = true }
 
 [target.'cfg(all(unix, not(target_os = "ios"), not(target_os = "macos")))'.dependencies]
-gfx-backend-vulkan = { version = "0.5", features = ["x11"] }
+gfx-backend-vulkan = { path = "../../gfx/src/backend/vulkan", version = "0.5", features = ["x11"] }
 
 [target.'cfg(windows)'.dependencies]
-gfx-backend-dx12 = { version = "0.5" }
-gfx-backend-dx11 = { version = "0.5" }
-gfx-backend-vulkan = { version = "0.5" }
+gfx-backend-dx12 = { path = "../../gfx/src/backend/dx12", version = "0.5" }
+gfx-backend-dx11 = { path = "../../gfx/src/backend/dx11", version = "0.5" }
+gfx-backend-vulkan = { path = "../../gfx/src/backend/vulkan", version = "0.5" }
 
 [target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "dragonfly", target_os = "freebsd"))'.dependencies]
 battery = { version = "0.7", optional = true }

wgpu-core/Cargo.toml

@@ -67,6 +67,7 @@ pub enum RenderCommand {
         phantom_offsets: PhantomSlice<DynamicOffset>,
     },
     SetPipeline(id::RenderPipelineId),
+    SetMeshPipeline(id::RenderPipelineId),
     SetIndexBuffer {
         buffer_id: id::BufferId,
         offset: BufferAddress,
@@ -108,6 +109,9 @@ pub enum RenderCommand {
         buffer_id: id::BufferId,
         offset: BufferAddress,
     },
+    DrawMeshTasks {
+        tasks_count: u32,
+    },
     End,
 }
 
@@ -820,7 +824,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                     .map(|resolve| view_guard[resolve].format)
                     .collect(),
                 depth_stencil: depth_stencil_attachment.map(|at| view_guard[at.attachment].format),
-            };
+            };            
+
             (context, sample_count)
         };
 
@@ -847,6 +852,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             first_vertex: 0,
             first_instance: 0,
         };
+
         loop {
             assert!(
                 unsafe { peeker.add(RenderCommand::max_size()) <= raw_data_end },
@@ -887,6 +893,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         .bind_groups
                         .use_extend(&*bind_group_guard, bind_group_id, (), ())
                         .unwrap();
+
                     assert_eq!(bind_group.dynamic_count, offsets.len());
 
                     trackers.merge_extend(&bind_group.used);
@@ -1017,6 +1024,69 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                     }
                     state.vertex.update_limits();
                 }
+                RenderCommand::SetMeshPipeline(pipeline_id) => {
+                    state.pipeline = OptionalState::Set;
+                    let pipeline = trackers
+                        .render_pipes
+                        .use_extend(&*pipeline_guard, pipeline_id, (), ())
+                        .unwrap();
+
+                    assert!(
+                        context.compatible(&pipeline.pass_context),
+                        "The mesh pipeline is not compatible with the pass!"
+                    );
+                    assert_eq!(
+                        pipeline.sample_count, sample_count,
+                        "The mesh pipeline and renderpass have mismatching sample_count"
+                    );
+
+                    state
+                        .blend_color
+                        .require(pipeline.flags.contains(PipelineFlags::BLEND_COLOR));
+                    state
+                        .stencil_reference
+                        .require(pipeline.flags.contains(PipelineFlags::STENCIL_REFERENCE));
+
+                    unsafe {
+                        raw.bind_graphics_pipeline(&pipeline.raw);
+                    }
+
+                    // Rebind resource
+                    if state.binder.pipeline_layout_id != Some(pipeline.layout_id.value) {
+                        let pipeline_layout = &pipeline_layout_guard[pipeline.layout_id.value];
+                        state.binder.pipeline_layout_id = Some(pipeline.layout_id.value);
+                        state
+                            .binder
+                            .reset_expectations(pipeline_layout.bind_group_layout_ids.len());
+                        let mut is_compatible = true;
+
+                        for (index, (entry, bgl_id)) in state
+                            .binder
+                            .entries
+                            .iter_mut()
+                            .zip(&pipeline_layout.bind_group_layout_ids)
+                            .enumerate()
+                        {
+                            match entry.expect_layout(bgl_id.value) {
+                                LayoutChange::Match(bg_id, offsets) if is_compatible => {
+                                    let desc_set = bind_group_guard[bg_id].raw.raw();
+                                    unsafe {
+                                        raw.bind_graphics_descriptor_sets(
+                                            &pipeline_layout.raw,
+                                            index,
+                                            iter::once(desc_set),
+                                            offsets.iter().cloned(),
+                                        );
+                                    }
+                                }
+                                LayoutChange::Match(..) | LayoutChange::Unchanged => {}
+                                LayoutChange::Mismatch => {
+                                    is_compatible = false;
+                                }
+                            }
+                        }
+                    }
+                }
                 RenderCommand::SetIndexBuffer {
                     buffer_id,
                     offset,
@@ -1210,6 +1280,17 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         raw.draw_indexed_indirect(&buffer.raw, offset, 1, 0);
                     }
                 }
+                RenderCommand::DrawMeshTasks {
+                    tasks_count,
+                } => {
+                    state.is_ready().unwrap();
+                    unsafe {
+                        raw.draw_mesh_tasks(
+                            tasks_count,
+                            0,
+                        );
+                    }
+                }
                 RenderCommand::End => break,
             }
         }
@@ -1311,6 +1392,14 @@ pub mod render_ffi {
         pass.encode(&RenderCommand::SetPipeline(pipeline_id));
     }
 
+    #[no_mangle]
+    pub unsafe extern "C" fn wgpu_render_pass_set_mesh_pipeline(
+        pass: &mut RawPass,
+        pipeline_id: id::RenderPipelineId,
+    ) {
+        pass.encode(&RenderCommand::SetMeshPipeline(pipeline_id));
+    }
+
     #[no_mangle]
     pub unsafe extern "C" fn wgpu_render_pass_set_index_buffer(
         pass: &mut RawPass,
@@ -1434,6 +1523,16 @@ pub mod render_ffi {
         pass.encode(&RenderCommand::DrawIndexedIndirect { buffer_id, offset });
     }
 
+    #[no_mangle]
+    pub unsafe extern "C" fn wgpu_render_pass_draw_mesh_tasks(
+        pass: &mut RawPass,
+        tasks_count: u32,
+    ) {
+        pass.encode(&RenderCommand::DrawMeshTasks {
+            tasks_count
+        });
+    }
+
     #[no_mangle]
     pub extern "C" fn wgpu_render_pass_execute_bundles(
         _pass: &mut RawPass,

wgpu-core/src/command/render.rs

@@ -126,6 +126,12 @@ pub fn map_shader_stage_flags(shader_stage_flags: wgt::ShaderStage) -> hal::pso:
     if shader_stage_flags.contains(Ss::COMPUTE) {
         value |= H::COMPUTE;
     }
+    if shader_stage_flags.contains(Ss::TASK) {
+        value |= H::TASK;
+    }
+    if shader_stage_flags.contains(Ss::MESH) {
+        value |= H::MESH;
+    }
     value
 }