CoCalc -- pipelines.rs

GitHub Repository: bevyengine/bevy
Path: blob/main/crates/bevy_pbr/src/meshlet/pipelines.rs
⁶⁶⁰⁰ views
1
use super::resource_manager::ResourceManager;
2
use bevy_asset::{load_embedded_asset, AssetServer, Handle};
3
use bevy_core_pipeline::{
4
    core_3d::CORE_3D_DEPTH_FORMAT, experimental::mip_generation::DownsampleDepthShader,
5
    FullscreenShader,
6
};
7
use bevy_ecs::{
8
    resource::Resource,
9
    system::{Commands, Res},
10
    world::World,
11
};
12
use bevy_render::render_resource::*;
13
use bevy_shader::Shader;
14
use bevy_utils::default;
15

16
#[derive(Resource)]
17
pub struct MeshletPipelines {
18
    clear_visibility_buffer: CachedComputePipelineId,
19
    clear_visibility_buffer_shadow_view: CachedComputePipelineId,
20
    first_instance_cull: CachedComputePipelineId,
21
    second_instance_cull: CachedComputePipelineId,
22
    first_bvh_cull: CachedComputePipelineId,
23
    second_bvh_cull: CachedComputePipelineId,
24
    first_meshlet_cull: CachedComputePipelineId,
25
    second_meshlet_cull: CachedComputePipelineId,
26
    downsample_depth_first: CachedComputePipelineId,
27
    downsample_depth_second: CachedComputePipelineId,
28
    downsample_depth_first_shadow_view: CachedComputePipelineId,
29
    downsample_depth_second_shadow_view: CachedComputePipelineId,
30
    visibility_buffer_software_raster: CachedComputePipelineId,
31
    visibility_buffer_software_raster_shadow_view: CachedComputePipelineId,
32
    visibility_buffer_hardware_raster: CachedRenderPipelineId,
33
    visibility_buffer_hardware_raster_shadow_view: CachedRenderPipelineId,
34
    visibility_buffer_hardware_raster_shadow_view_unclipped: CachedRenderPipelineId,
35
    resolve_depth: CachedRenderPipelineId,
36
    resolve_depth_shadow_view: CachedRenderPipelineId,
37
    resolve_material_depth: CachedRenderPipelineId,
38
    remap_1d_to_2d_dispatch: Option<CachedComputePipelineId>,
39
    fill_counts: CachedComputePipelineId,
40
    pub(crate) meshlet_mesh_material: Handle<Shader>,
41
}
42

43
pub fn init_meshlet_pipelines(
44
    mut commands: Commands,
45
    resource_manager: Res<ResourceManager>,
46
    fullscreen_shader: Res<FullscreenShader>,
47
    downsample_depth_shader: Res<DownsampleDepthShader>,
48
    pipeline_cache: Res<PipelineCache>,
49
    asset_server: Res<AssetServer>,
50
) {
51
    let clear_visibility_buffer_bind_group_layout = resource_manager
52
        .clear_visibility_buffer_bind_group_layout
53
        .clone();
54
    let clear_visibility_buffer_shadow_view_bind_group_layout = resource_manager
55
        .clear_visibility_buffer_shadow_view_bind_group_layout
56
        .clone();
57
    let first_instance_cull_bind_group_layout = resource_manager
58
        .first_instance_cull_bind_group_layout
59
        .clone();
60
    let second_instance_cull_bind_group_layout = resource_manager
61
        .second_instance_cull_bind_group_layout
62
        .clone();
63
    let first_bvh_cull_bind_group_layout =
64
        resource_manager.first_bvh_cull_bind_group_layout.clone();
65
    let second_bvh_cull_bind_group_layout =
66
        resource_manager.second_bvh_cull_bind_group_layout.clone();
67
    let first_meshlet_cull_bind_group_layout = resource_manager
68
        .first_meshlet_cull_bind_group_layout
69
        .clone();
70
    let second_meshlet_cull_bind_group_layout = resource_manager
71
        .second_meshlet_cull_bind_group_layout
72
        .clone();
73
    let downsample_depth_layout = resource_manager.downsample_depth_bind_group_layout.clone();
74
    let downsample_depth_shadow_view_layout = resource_manager
75
        .downsample_depth_shadow_view_bind_group_layout
76
        .clone();
77
    let visibility_buffer_raster_layout = resource_manager
78
        .visibility_buffer_raster_bind_group_layout
79
        .clone();
80
    let visibility_buffer_raster_shadow_view_layout = resource_manager
81
        .visibility_buffer_raster_shadow_view_bind_group_layout
82
        .clone();
83
    let resolve_depth_layout = resource_manager.resolve_depth_bind_group_layout.clone();
84
    let resolve_depth_shadow_view_layout = resource_manager
85
        .resolve_depth_shadow_view_bind_group_layout
86
        .clone();
87
    let resolve_material_depth_layout = resource_manager
88
        .resolve_material_depth_bind_group_layout
89
        .clone();
90
    let remap_1d_to_2d_dispatch_layout = resource_manager
91
        .remap_1d_to_2d_dispatch_bind_group_layout
92
        .clone();
93

94
    let downsample_depth_shader = (*downsample_depth_shader).clone();
95
    let vertex_state = fullscreen_shader.to_vertex_state();
96
    let fill_counts_layout = resource_manager.fill_counts_bind_group_layout.clone();
97

98
    let clear_visibility_buffer =
99
        load_embedded_asset!(asset_server.as_ref(), "clear_visibility_buffer.wgsl");
100
    let cull_instances = load_embedded_asset!(asset_server.as_ref(), "cull_instances.wgsl");
101
    let cull_bvh = load_embedded_asset!(asset_server.as_ref(), "cull_bvh.wgsl");
102
    let cull_clusters = load_embedded_asset!(asset_server.as_ref(), "cull_clusters.wgsl");
103
    let visibility_buffer_software_raster = load_embedded_asset!(
104
        asset_server.as_ref(),
105
        "visibility_buffer_software_raster.wgsl"
106
    );
107
    let visibility_buffer_hardware_raster = load_embedded_asset!(
108
        asset_server.as_ref(),
109
        "visibility_buffer_hardware_raster.wgsl"
110
    );
111
    let resolve_render_targets =
112
        load_embedded_asset!(asset_server.as_ref(), "resolve_render_targets.wgsl");
113
    let remap_1d_to_2d_dispatch =
114
        load_embedded_asset!(asset_server.as_ref(), "remap_1d_to_2d_dispatch.wgsl");
115
    let fill_counts = load_embedded_asset!(asset_server.as_ref(), "fill_counts.wgsl");
116
    let meshlet_mesh_material =
117
        load_embedded_asset!(asset_server.as_ref(), "meshlet_mesh_material.wgsl");
118

119
    commands.insert_resource(MeshletPipelines {
120
        clear_visibility_buffer: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
121
            label: Some("meshlet_clear_visibility_buffer_pipeline".into()),
122
            layout: vec![clear_visibility_buffer_bind_group_layout],
123
            push_constant_ranges: vec![PushConstantRange {
124
                stages: ShaderStages::COMPUTE,
125
                range: 0..8,
126
            }],
127
            shader: clear_visibility_buffer.clone(),
128
            shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into()],
129
            ..default()
130
        }),
131

132
        clear_visibility_buffer_shadow_view: pipeline_cache.queue_compute_pipeline(
133
            ComputePipelineDescriptor {
134
                label: Some("meshlet_clear_visibility_buffer_shadow_view_pipeline".into()),
135
                layout: vec![clear_visibility_buffer_shadow_view_bind_group_layout],
136
                push_constant_ranges: vec![PushConstantRange {
137
                    stages: ShaderStages::COMPUTE,
138
                    range: 0..8,
139
                }],
140
                shader: clear_visibility_buffer,
141
                ..default()
142
            },
143
        ),
144

145
        first_instance_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
146
            label: Some("meshlet_first_instance_cull_pipeline".into()),
147
            layout: vec![first_instance_cull_bind_group_layout.clone()],
148
            push_constant_ranges: vec![PushConstantRange {
149
                stages: ShaderStages::COMPUTE,
150
                range: 0..4,
151
            }],
152
            shader: cull_instances.clone(),
153
            shader_defs: vec![
154
                "MESHLET_INSTANCE_CULLING_PASS".into(),
155
                "MESHLET_FIRST_CULLING_PASS".into(),
156
            ],
157
            ..default()
158
        }),
159

160
        second_instance_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
161
            label: Some("meshlet_second_instance_cull_pipeline".into()),
162
            layout: vec![second_instance_cull_bind_group_layout.clone()],
163
            push_constant_ranges: vec![PushConstantRange {
164
                stages: ShaderStages::COMPUTE,
165
                range: 0..4,
166
            }],
167
            shader: cull_instances,
168
            shader_defs: vec![
169
                "MESHLET_INSTANCE_CULLING_PASS".into(),
170
                "MESHLET_SECOND_CULLING_PASS".into(),
171
            ],
172
            ..default()
173
        }),
174

175
        first_bvh_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
176
            label: Some("meshlet_first_bvh_cull_pipeline".into()),
177
            layout: vec![first_bvh_cull_bind_group_layout.clone()],
178
            push_constant_ranges: vec![PushConstantRange {
179
                stages: ShaderStages::COMPUTE,
180
                range: 0..8,
181
            }],
182
            shader: cull_bvh.clone(),
183
            shader_defs: vec![
184
                "MESHLET_BVH_CULLING_PASS".into(),
185
                "MESHLET_FIRST_CULLING_PASS".into(),
186
            ],
187
            ..default()
188
        }),
189

190
        second_bvh_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
191
            label: Some("meshlet_second_bvh_cull_pipeline".into()),
192
            layout: vec![second_bvh_cull_bind_group_layout.clone()],
193
            push_constant_ranges: vec![PushConstantRange {
194
                stages: ShaderStages::COMPUTE,
195
                range: 0..8,
196
            }],
197
            shader: cull_bvh,
198
            shader_defs: vec![
199
                "MESHLET_BVH_CULLING_PASS".into(),
200
                "MESHLET_SECOND_CULLING_PASS".into(),
201
            ],
202
            ..default()
203
        }),
204

205
        first_meshlet_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
206
            label: Some("meshlet_first_meshlet_cull_pipeline".into()),
207
            layout: vec![first_meshlet_cull_bind_group_layout.clone()],
208
            push_constant_ranges: vec![PushConstantRange {
209
                stages: ShaderStages::COMPUTE,
210
                range: 0..4,
211
            }],
212
            shader: cull_clusters.clone(),
213
            shader_defs: vec![
214
                "MESHLET_CLUSTER_CULLING_PASS".into(),
215
                "MESHLET_FIRST_CULLING_PASS".into(),
216
            ],
217
            ..default()
218
        }),
219

220
        second_meshlet_cull: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
221
            label: Some("meshlet_second_meshlet_cull_pipeline".into()),
222
            layout: vec![second_meshlet_cull_bind_group_layout.clone()],
223
            push_constant_ranges: vec![PushConstantRange {
224
                stages: ShaderStages::COMPUTE,
225
                range: 0..4,
226
            }],
227
            shader: cull_clusters,
228
            shader_defs: vec![
229
                "MESHLET_CLUSTER_CULLING_PASS".into(),
230
                "MESHLET_SECOND_CULLING_PASS".into(),
231
            ],
232
            ..default()
233
        }),
234

235
        downsample_depth_first: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
236
            label: Some("meshlet_downsample_depth_first_pipeline".into()),
237
            layout: vec![downsample_depth_layout.clone()],
238
            push_constant_ranges: vec![PushConstantRange {
239
                stages: ShaderStages::COMPUTE,
240
                range: 0..4,
241
            }],
242
            shader: downsample_depth_shader.clone(),
243
            shader_defs: vec![
244
                "MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
245
                "MESHLET".into(),
246
            ],
247
            entry_point: Some("downsample_depth_first".into()),
248
            ..default()
249
        }),
250

251
        downsample_depth_second: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
252
            label: Some("meshlet_downsample_depth_second_pipeline".into()),
253
            layout: vec![downsample_depth_layout.clone()],
254
            push_constant_ranges: vec![PushConstantRange {
255
                stages: ShaderStages::COMPUTE,
256
                range: 0..4,
257
            }],
258
            shader: downsample_depth_shader.clone(),
259
            shader_defs: vec![
260
                "MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
261
                "MESHLET".into(),
262
            ],
263
            entry_point: Some("downsample_depth_second".into()),
264
            ..default()
265
        }),
266

267
        downsample_depth_first_shadow_view: pipeline_cache.queue_compute_pipeline(
268
            ComputePipelineDescriptor {
269
                label: Some("meshlet_downsample_depth_first_pipeline".into()),
270
                layout: vec![downsample_depth_shadow_view_layout.clone()],
271
                push_constant_ranges: vec![PushConstantRange {
272
                    stages: ShaderStages::COMPUTE,
273
                    range: 0..4,
274
                }],
275
                shader: downsample_depth_shader.clone(),
276
                shader_defs: vec!["MESHLET".into()],
277
                entry_point: Some("downsample_depth_first".into()),
278
                ..default()
279
            },
280
        ),
281

282
        downsample_depth_second_shadow_view: pipeline_cache.queue_compute_pipeline(
283
            ComputePipelineDescriptor {
284
                label: Some("meshlet_downsample_depth_second_pipeline".into()),
285
                layout: vec![downsample_depth_shadow_view_layout],
286
                push_constant_ranges: vec![PushConstantRange {
287
                    stages: ShaderStages::COMPUTE,
288
                    range: 0..4,
289
                }],
290
                shader: downsample_depth_shader,
291
                shader_defs: vec!["MESHLET".into()],
292
                entry_point: Some("downsample_depth_second".into()),
293
                zero_initialize_workgroup_memory: false,
294
            },
295
        ),
296

297
        visibility_buffer_software_raster: pipeline_cache.queue_compute_pipeline(
298
            ComputePipelineDescriptor {
299
                label: Some("meshlet_visibility_buffer_software_raster_pipeline".into()),
300
                layout: vec![visibility_buffer_raster_layout.clone()],
301
                push_constant_ranges: vec![],
302
                shader: visibility_buffer_software_raster.clone(),
303
                shader_defs: vec![
304
                    "MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into(),
305
                    "MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
306
                    if remap_1d_to_2d_dispatch_layout.is_some() {
307
                        "MESHLET_2D_DISPATCH"
308
                    } else {
309
                        ""
310
                    }
311
                    .into(),
312
                ],
313
                ..default()
314
            },
315
        ),
316

317
        visibility_buffer_software_raster_shadow_view: pipeline_cache.queue_compute_pipeline(
318
            ComputePipelineDescriptor {
319
                label: Some(
320
                    "meshlet_visibility_buffer_software_raster_shadow_view_pipeline".into(),
321
                ),
322
                layout: vec![visibility_buffer_raster_shadow_view_layout.clone()],
323
                push_constant_ranges: vec![],
324
                shader: visibility_buffer_software_raster,
325
                shader_defs: vec![
326
                    "MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into(),
327
                    if remap_1d_to_2d_dispatch_layout.is_some() {
328
                        "MESHLET_2D_DISPATCH"
329
                    } else {
330
                        ""
331
                    }
332
                    .into(),
333
                ],
334
                ..default()
335
            },
336
        ),
337

338
        visibility_buffer_hardware_raster: pipeline_cache.queue_render_pipeline(
339
            RenderPipelineDescriptor {
340
                label: Some("meshlet_visibility_buffer_hardware_raster_pipeline".into()),
341
                layout: vec![visibility_buffer_raster_layout.clone()],
342
                push_constant_ranges: vec![PushConstantRange {
343
                    stages: ShaderStages::VERTEX,
344
                    range: 0..4,
345
                }],
346
                vertex: VertexState {
347
                    shader: visibility_buffer_hardware_raster.clone(),
348
                    shader_defs: vec![
349
                        "MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into(),
350
                        "MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
351
                    ],
352
                    ..default()
353
                },
354
                fragment: Some(FragmentState {
355
                    shader: visibility_buffer_hardware_raster.clone(),
356
                    shader_defs: vec![
357
                        "MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into(),
358
                        "MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into(),
359
                    ],
360
                    targets: vec![Some(ColorTargetState {
361
                        format: TextureFormat::R8Uint,
362
                        blend: None,
363
                        write_mask: ColorWrites::empty(),
364
                    })],
365
                    ..default()
366
                }),
367
                ..default()
368
            },
369
        ),
370

371
        visibility_buffer_hardware_raster_shadow_view: pipeline_cache.queue_render_pipeline(
372
            RenderPipelineDescriptor {
373
                label: Some(
374
                    "meshlet_visibility_buffer_hardware_raster_shadow_view_pipeline".into(),
375
                ),
376
                layout: vec![visibility_buffer_raster_shadow_view_layout.clone()],
377
                push_constant_ranges: vec![PushConstantRange {
378
                    stages: ShaderStages::VERTEX,
379
                    range: 0..4,
380
                }],
381
                vertex: VertexState {
382
                    shader: visibility_buffer_hardware_raster.clone(),
383
                    shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
384
                    ..default()
385
                },
386
                fragment: Some(FragmentState {
387
                    shader: visibility_buffer_hardware_raster.clone(),
388
                    shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
389
                    targets: vec![Some(ColorTargetState {
390
                        format: TextureFormat::R8Uint,
391
                        blend: None,
392
                        write_mask: ColorWrites::empty(),
393
                    })],
394
                    ..default()
395
                }),
396
                ..default()
397
            },
398
        ),
399

400
        visibility_buffer_hardware_raster_shadow_view_unclipped: pipeline_cache
401
            .queue_render_pipeline(RenderPipelineDescriptor {
402
                label: Some(
403
                    "meshlet_visibility_buffer_hardware_raster_shadow_view_unclipped_pipeline"
404
                        .into(),
405
                ),
406
                layout: vec![visibility_buffer_raster_shadow_view_layout],
407
                push_constant_ranges: vec![PushConstantRange {
408
                    stages: ShaderStages::VERTEX,
409
                    range: 0..4,
410
                }],
411
                vertex: VertexState {
412
                    shader: visibility_buffer_hardware_raster.clone(),
413
                    shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
414
                    ..default()
415
                },
416
                fragment: Some(FragmentState {
417
                    shader: visibility_buffer_hardware_raster,
418
                    shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS".into()],
419
                    targets: vec![Some(ColorTargetState {
420
                        format: TextureFormat::R8Uint,
421
                        blend: None,
422
                        write_mask: ColorWrites::empty(),
423
                    })],
424
                    ..default()
425
                }),
426
                ..default()
427
            }),
428

429
        resolve_depth: pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
430
            label: Some("meshlet_resolve_depth_pipeline".into()),
431
            layout: vec![resolve_depth_layout],
432
            vertex: vertex_state.clone(),
433
            depth_stencil: Some(DepthStencilState {
434
                format: CORE_3D_DEPTH_FORMAT,
435
                depth_write_enabled: true,
436
                depth_compare: CompareFunction::Always,
437
                stencil: StencilState::default(),
438
                bias: DepthBiasState::default(),
439
            }),
440
            fragment: Some(FragmentState {
441
                shader: resolve_render_targets.clone(),
442
                shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into()],
443
                entry_point: Some("resolve_depth".into()),
444
                ..default()
445
            }),
446
            ..default()
447
        }),
448

449
        resolve_depth_shadow_view: pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
450
            label: Some("meshlet_resolve_depth_pipeline".into()),
451
            layout: vec![resolve_depth_shadow_view_layout],
452
            vertex: vertex_state.clone(),
453
            depth_stencil: Some(DepthStencilState {
454
                format: CORE_3D_DEPTH_FORMAT,
455
                depth_write_enabled: true,
456
                depth_compare: CompareFunction::Always,
457
                stencil: StencilState::default(),
458
                bias: DepthBiasState::default(),
459
            }),
460
            fragment: Some(FragmentState {
461
                shader: resolve_render_targets.clone(),
462
                entry_point: Some("resolve_depth".into()),
463
                ..default()
464
            }),
465
            ..default()
466
        }),
467

468
        resolve_material_depth: pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
469
            label: Some("meshlet_resolve_material_depth_pipeline".into()),
470
            layout: vec![resolve_material_depth_layout],
471
            vertex: vertex_state,
472
            primitive: PrimitiveState::default(),
473
            depth_stencil: Some(DepthStencilState {
474
                format: TextureFormat::Depth16Unorm,
475
                depth_write_enabled: true,
476
                depth_compare: CompareFunction::Always,
477
                stencil: StencilState::default(),
478
                bias: DepthBiasState::default(),
479
            }),
480
            fragment: Some(FragmentState {
481
                shader: resolve_render_targets,
482
                shader_defs: vec!["MESHLET_VISIBILITY_BUFFER_RASTER_PASS_OUTPUT".into()],
483
                entry_point: Some("resolve_material_depth".into()),
484
                targets: vec![],
485
            }),
486
            ..default()
487
        }),
488

489
        fill_counts: pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
490
            label: Some("meshlet_fill_counts_pipeline".into()),
491
            layout: vec![fill_counts_layout],
492
            shader: fill_counts,
493
            shader_defs: vec![if remap_1d_to_2d_dispatch_layout.is_some() {
494
                "MESHLET_2D_DISPATCH"
495
            } else {
496
                ""
497
            }
498
            .into()],
499
            ..default()
500
        }),
501

502
        remap_1d_to_2d_dispatch: remap_1d_to_2d_dispatch_layout.map(|layout| {
503
            pipeline_cache.queue_compute_pipeline(ComputePipelineDescriptor {
504
                label: Some("meshlet_remap_1d_to_2d_dispatch_pipeline".into()),
505
                layout: vec![layout],
506
                push_constant_ranges: vec![PushConstantRange {
507
                    stages: ShaderStages::COMPUTE,
508
                    range: 0..4,
509
                }],
510
                shader: remap_1d_to_2d_dispatch,
511
                ..default()
512
            })
513
        }),
514

515
        meshlet_mesh_material,
516
    });
517
}
518

519
impl MeshletPipelines {
520
    pub fn get(
521
        world: &World,
522
    ) -> Option<(
523
        &ComputePipeline,
524
        &ComputePipeline,
525
        &ComputePipeline,
526
        &ComputePipeline,
527
        &ComputePipeline,
528
        &ComputePipeline,
529
        &ComputePipeline,
530
        &ComputePipeline,
531
        &ComputePipeline,
532
        &ComputePipeline,
533
        &ComputePipeline,
534
        &ComputePipeline,
535
        &ComputePipeline,
536
        &ComputePipeline,
537
        &RenderPipeline,
538
        &RenderPipeline,
539
        &RenderPipeline,
540
        &RenderPipeline,
541
        &RenderPipeline,
542
        &RenderPipeline,
543
        Option<&ComputePipeline>,
544
        &ComputePipeline,
545
    )> {
546
        let pipeline_cache = world.get_resource::<PipelineCache>()?;
547
        let pipeline = world.get_resource::<Self>()?;
548
        Some((
549
            pipeline_cache.get_compute_pipeline(pipeline.clear_visibility_buffer)?,
550
            pipeline_cache.get_compute_pipeline(pipeline.clear_visibility_buffer_shadow_view)?,
551
            pipeline_cache.get_compute_pipeline(pipeline.first_instance_cull)?,
552
            pipeline_cache.get_compute_pipeline(pipeline.second_instance_cull)?,
553
            pipeline_cache.get_compute_pipeline(pipeline.first_bvh_cull)?,
554
            pipeline_cache.get_compute_pipeline(pipeline.second_bvh_cull)?,
555
            pipeline_cache.get_compute_pipeline(pipeline.first_meshlet_cull)?,
556
            pipeline_cache.get_compute_pipeline(pipeline.second_meshlet_cull)?,
557
            pipeline_cache.get_compute_pipeline(pipeline.downsample_depth_first)?,
558
            pipeline_cache.get_compute_pipeline(pipeline.downsample_depth_second)?,
559
            pipeline_cache.get_compute_pipeline(pipeline.downsample_depth_first_shadow_view)?,
560
            pipeline_cache.get_compute_pipeline(pipeline.downsample_depth_second_shadow_view)?,
561
            pipeline_cache.get_compute_pipeline(pipeline.visibility_buffer_software_raster)?,
562
            pipeline_cache
563
                .get_compute_pipeline(pipeline.visibility_buffer_software_raster_shadow_view)?,
564
            pipeline_cache.get_render_pipeline(pipeline.visibility_buffer_hardware_raster)?,
565
            pipeline_cache
566
                .get_render_pipeline(pipeline.visibility_buffer_hardware_raster_shadow_view)?,
567
            pipeline_cache.get_render_pipeline(
568
                pipeline.visibility_buffer_hardware_raster_shadow_view_unclipped,
569
            )?,
570
            pipeline_cache.get_render_pipeline(pipeline.resolve_depth)?,
571
            pipeline_cache.get_render_pipeline(pipeline.resolve_depth_shadow_view)?,
572
            pipeline_cache.get_render_pipeline(pipeline.resolve_material_depth)?,
573
            match pipeline.remap_1d_to_2d_dispatch {
574
                Some(id) => Some(pipeline_cache.get_compute_pipeline(id)?),
575
                None => None,
576
            },
577
            pipeline_cache.get_compute_pipeline(pipeline.fill_counts)?,
578
        ))
579
    }
580
}
581

582
Product

Resources

Company
