pebble-engine 0.9.5

A modular, ECS-style graphics/app framework for Rust.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

pub mod cubemap;
pub mod material;
pub mod material_instance;
pub mod samplers;
pub mod textures;

pub struct BindingEntry {
    pub name: &'static str,
    pub kind: BindingKind,
}

pub enum BindingKind {
    Texture,
    /// `texture_2d_array<f32>` in WGSL — a texture with multiple layers
    /// sampled by index, e.g. a texture atlas or a per-instance layer
    /// lookup. Bind the whole array as one resource; select the layer in
    /// the shader.
    TextureArray,
    Sampler,
    /// `sampler_comparison` in WGSL — a sampler used with
    /// `textureSampleCompare`, e.g. shadow-map testing. Distinct from a
    /// regular [`Sampler`](BindingKind::Sampler) binding at the wgpu level
    /// (`SamplerBindingType::Comparison` vs `Filtering`); pair with a
    /// [`SamplerKind`](crate::wgpu::samplers::SamplerKind) comparison
    /// variant (e.g. `CompareLess`) when building the actual sampler.
    ComparisonSampler,
    Buffer,
    TextureCubemap,
}

impl BindingEntry {
    pub fn texture(name: &'static str) -> Self {
        Self {
            name,
            kind: BindingKind::Texture,
        }
    }

    pub fn sampler(name: &'static str) -> Self {
        Self {
            name,
            kind: BindingKind::Sampler,
        }
    }

    pub fn buffer(name: &'static str) -> Self {
        Self {
            name,
            kind: BindingKind::Buffer,
        }
    }

    pub fn cubemap(name: &'static str) -> Self {
        Self {
            name,
            kind: BindingKind::TextureCubemap,
        }
    }

    pub fn texture_array(name: &'static str) -> Self {
        Self {
            name,
            kind: BindingKind::TextureArray,
        }
    }

    pub fn comparison_sampler(name: &'static str) -> Self {
        Self {
            name,
            kind: BindingKind::ComparisonSampler,
        }
    }

    pub fn layout_entry(&self, binding: u32) -> wgpu::BindGroupLayoutEntry {
        match self.kind {
            BindingKind::Texture => wgpu::BindGroupLayoutEntry {
                binding,
                visibility: wgpu::ShaderStages::FRAGMENT,
                ty: wgpu::BindingType::Texture {
                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
                    view_dimension: wgpu::TextureViewDimension::D2,
                    multisampled: false,
                },
                count: None,
            },
            BindingKind::Sampler => wgpu::BindGroupLayoutEntry {
                binding,
                visibility: wgpu::ShaderStages::FRAGMENT,
                ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                count: None,
            },
            BindingKind::Buffer => wgpu::BindGroupLayoutEntry {
                binding,
                visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
                ty: wgpu::BindingType::Buffer {
                    ty: wgpu::BufferBindingType::Uniform,
                    has_dynamic_offset: false,
                    min_binding_size: None,
                },
                count: None,
            },
            BindingKind::TextureCubemap => wgpu::BindGroupLayoutEntry {
                binding,
                visibility: wgpu::ShaderStages::FRAGMENT,
                ty: wgpu::BindingType::Texture {
                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
                    view_dimension: wgpu::TextureViewDimension::Cube,
                    multisampled: false,
                },
                count: None,
            },
            BindingKind::TextureArray => wgpu::BindGroupLayoutEntry {
                binding,
                visibility: wgpu::ShaderStages::FRAGMENT,
                ty: wgpu::BindingType::Texture {
                    sample_type: wgpu::TextureSampleType::Float { filterable: true },
                    view_dimension: wgpu::TextureViewDimension::D2Array,
                    multisampled: false,
                },
                count: None,
            },
            BindingKind::ComparisonSampler => wgpu::BindGroupLayoutEntry {
                binding,
                visibility: wgpu::ShaderStages::FRAGMENT,
                ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Comparison),
                count: None,
            },
        }
    }
}