rend3-pbr 0.2.2

PBR Render Routine for rend3
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::convert::TryFrom;

use glam::UVec2;
use wgpu::{
    Device, Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages, TextureView,
    TextureViewDescriptor,
};

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct RenderTextureOptions {
    pub resolution: UVec2,
    pub samples: SampleCount,
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[repr(u8)]
pub enum SampleCount {
    One = 1,
    Four = 4,
}

impl Default for SampleCount {
    fn default() -> Self {
        Self::One
    }
}

impl TryFrom<u8> for SampleCount {
    type Error = u8;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        Ok(match value {
            1 => Self::One,
            4 => Self::Four,
            v => return Err(v),
        })
    }
}

pub struct RenderTextures {
    pub color: TextureView,
    pub resolve: Option<TextureView>,
    pub depth: TextureView,
    pub samples: SampleCount,
}
impl RenderTextures {
    pub fn new(device: &Device, options: RenderTextureOptions) -> Self {
        profiling::scope!("RenderTextures::new");
        Self {
            color: create_internal_color_buffer(
                device,
                TextureFormat::Rgba16Float,
                options.resolution,
                options.samples,
            ),
            resolve: if options.samples != SampleCount::One {
                Some(create_internal_color_buffer(
                    device,
                    TextureFormat::Rgba16Float,
                    options.resolution,
                    SampleCount::One,
                ))
            } else {
                None
            },
            depth: create_internal_depth_buffer(device, options),
            samples: options.samples,
        }
    }

    pub fn blit_source_view(&self) -> &TextureView {
        self.resolve.as_ref().unwrap_or(&self.color)
    }
}

fn create_internal_color_buffer(
    device: &Device,
    format: TextureFormat,
    resolution: UVec2,
    samples: SampleCount,
) -> TextureView {
    device
        .create_texture(&TextureDescriptor {
            label: Some("internal renderbuffer"),
            size: Extent3d {
                width: resolution.x,
                height: resolution.y,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: samples as u32,
            dimension: TextureDimension::D2,
            format,
            usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_SRC,
        })
        .create_view(&TextureViewDescriptor::default())
}

fn create_internal_depth_buffer(device: &Device, options: RenderTextureOptions) -> TextureView {
    device
        .create_texture(&TextureDescriptor {
            label: Some("internal depth renderbuffer"),
            size: Extent3d {
                width: options.resolution.x,
                height: options.resolution.y,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: options.samples as u32,
            dimension: TextureDimension::D2,
            format: TextureFormat::Depth32Float,
            usage: TextureUsages::RENDER_ATTACHMENT,
        })
        .create_view(&TextureViewDescriptor::default())
}