molgfx-render 0.1.0

The render graph, passes and the engine that drives a frame.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//! Draw recording for the specialized transparent geometry.
//!
//! Draws arrive grouped by representation, so each helper changes pipeline at
//! most once per representation rather than once per draw.

use crate::passes::PassRegistry;
use crate::scene_gpu::GpuScene;
use molgfx_gpu::{Device, RenderPassEncoder};

/// Records transparent spheres, switching pipeline only when the clip state
/// changes between representations.
pub(super) fn record_spheres<D: Device, P: RenderPassEncoder<D>>(
    passes: &PassRegistry<D>,
    scene: &GpuScene<D>,
    pass: &mut P,
) {
    let mut bound = None;
    if let Some(arena) = scene.indirect_args() {
        for (group, offset, shading, _) in scene.atom_draws(true) {
            if bound != Some(shading) {
                pass.set_pipeline(if shading.clipped() {
                    passes.oit.sphere_clipped.get(shading)
                } else {
                    passes.oit.sphere.get(shading)
                });
                bound = Some(shading);
            }
            pass.set_bind_group(2, group, &[]);
            pass.draw_indirect(arena, offset);
        }
    }
}

/// Records transparent surfaces, switching between the analytic union and the
/// persistent-grid tracing only when the surface family changes.
pub(super) fn record_surfaces<D: Device, P: RenderPassEncoder<D>>(
    passes: &PassRegistry<D>,
    scene: &GpuScene<D>,
    pass: &mut P,
) {
    let mut bound = None;
    if let Some(arena) = scene.indirect_args() {
        for (group, offset, shading, _) in scene.surface_draws(true) {
            if bound != Some(shading) {
                pass.set_pipeline(if shading.surface_grid() {
                    passes.oit.grid_surface.get(shading)
                } else {
                    passes.oit.union_surface.get(shading)
                });
                bound = Some(shading);
            }
            pass.set_bind_group(2, group, &[]);
            pass.draw_indirect(arena, offset);
        }
    }
}

/// Records transparent primitives, changing pipeline at most once per class as
/// it walks the shape-sorted table.
pub(super) fn record_primitives<D: Device, P: RenderPassEncoder<D>>(
    passes: &PassRegistry<D>,
    scene: &GpuScene<D>,
    pass: &mut P,
) {
    if let Some((table, runs)) = scene.primitive_groups() {
        pass.set_bind_group(2, table, &[]);
        for run in runs.iter().filter(|run| run.translucent) {
            let Some(pipeline) = passes.oit.primitive.pipeline(run) else {
                continue;
            };
            pass.set_pipeline(pipeline);
            pass.draw(
                0..crate::passes::primitive_pipelines::PRIMITIVE_QUAD_VERTICES,
                run.first..run.first + run.len,
            );
        }
    }
    if let Some((table, args, runs)) = scene.ligand_pose_draws() {
        pass.set_bind_group(2, table, &[]);
        for run in runs.iter().filter(|run| run.translucent) {
            let Some(pipeline) = passes.oit.ligand_pose.pipeline(run) else {
                continue;
            };
            pass.set_pipeline(pipeline);
            pass.draw_indirect(args, run.args_offset);
        }
    }
}