awsm-renderer 0.3.1

awsm-renderer
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
89
90
91
92

//! Material decal render pass execution.

use awsm_renderer_core::command::compute_pass::ComputePassDescriptor;

use crate::{
    decals::Decals,
    error::Result,
    render::RenderContext,
    render_passes::{
        material_decal::{
            bind_group::MaterialDecalBindGroups, classify::render_pass::DecalClassifyRenderPass,
            composite::MaterialDecalComposite, pipeline::MaterialDecalPipelines,
        },
        RenderPassInitContext,
    },
};

/// Material decal pass bind groups, compute pipelines, the
/// downstream composite pass, and the upstream per-tile classify pass.
pub struct MaterialDecalRenderPass {
    pub bind_groups: MaterialDecalBindGroups,
    pub pipelines: MaterialDecalPipelines,
    pub composite: MaterialDecalComposite,
    pub classify_pass: DecalClassifyRenderPass,
}

impl MaterialDecalRenderPass {
    pub async fn new(ctx: &mut RenderPassInitContext<'_>) -> Result<Self> {
        let bind_groups = MaterialDecalBindGroups::new(ctx).await?;
        let pipelines = MaterialDecalPipelines::new(ctx, &bind_groups).await?;
        let composite = MaterialDecalComposite::new(ctx).await?;
        let classify_pass = DecalClassifyRenderPass::new(ctx).await?;
        Ok(Self {
            bind_groups,
            pipelines,
            composite,
            classify_pass,
        })
    }

    /// Rebuilds the texture-pool layout + dependent pipelines after the
    /// texture pool changes. Mirrors the opaque / transparent passes;
    /// without this the cached `texture_pool_layout_key` stays pinned
    /// to the empty layout captured at init time and the populated
    /// texture-pool bind group fails validation.
    pub async fn texture_pool_changed(
        &mut self,
        ctx: &mut RenderPassInitContext<'_>,
    ) -> Result<()> {
        self.bind_groups = self.bind_groups.clone_because_texture_pool_changed(ctx)?;
        self.pipelines = MaterialDecalPipelines::new(ctx, &self.bind_groups).await?;
        Ok(())
    }

    /// Dispatches: classify → compute → composite. Skipped when no
    /// decals are active.
    pub fn render(&self, ctx: &RenderContext, decals: &Decals) -> Result<()> {
        if decals.is_empty() {
            return Ok(());
        }

        // Tile-bucket classify must run before the shading compute so
        // per-pixel iteration reads from a fresh per-tile decal list.
        self.classify_pass.render(ctx, decals.len() as u32)?;

        let pipeline_key = if ctx.anti_aliasing.msaa_sample_count.is_some() {
            self.pipelines.multisampled_pipeline_key
        } else {
            self.pipelines.singlesampled_pipeline_key
        };

        let compute_pass = ctx.command_encoder.begin_compute_pass(Some(
            &ComputePassDescriptor::new(Some("Material Decal Pass")).into(),
        ));

        compute_pass.set_pipeline(ctx.pipelines.compute.get(pipeline_key)?);
        compute_pass.set_bind_group(0, self.bind_groups.get_main()?, None)?;
        compute_pass.set_bind_group(1, self.bind_groups.get_texture_pool()?, None)?;

        let workgroups_x = ctx.render_texture_views.width.div_ceil(8);
        let workgroups_y = ctx.render_texture_views.height.div_ceil(8);
        compute_pass.dispatch_workgroups(workgroups_x, Some(workgroups_y), Some(1));
        compute_pass.end();

        // Composite pass — blit decal_color onto transparent. Cheap
        // fullscreen-tri with per-fragment discard; per-frame cost is
        // negligible vs the compute that just ran.
        self.composite.render(ctx)?;

        Ok(())
    }
}