forked from bevyengine/bevy
-
Notifications
You must be signed in to change notification settings - Fork 0
/
shader_prepass.rs
253 lines (229 loc) · 8.4 KB
/
shader_prepass.rs
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
//! Bevy has an optional prepass that is controlled per-material. A prepass is a rendering pass that runs before the main pass.
//! It will optionally generate various view textures. Currently it supports depth, normal, and motion vector textures.
//! The textures are not generated for any material using alpha blending.
use bevy::{
core_pipeline::prepass::{DepthPrepass, MotionVectorPrepass, NormalPrepass},
pbr::{NotShadowCaster, PbrPlugin},
prelude::*,
reflect::TypePath,
render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
};
fn main() {
App::new()
.add_plugins((
DefaultPlugins.set(PbrPlugin {
// The prepass is enabled by default on the StandardMaterial,
// but you can disable it if you need to.
//
// prepass_enabled: false,
..default()
}),
MaterialPlugin::<CustomMaterial>::default(),
MaterialPlugin::<PrepassOutputMaterial> {
// This material only needs to read the prepass textures,
// but the meshes using it should not contribute to the prepass render, so we can disable it.
prepass_enabled: false,
..default()
},
))
.add_systems(Startup, setup)
.add_systems(Update, (rotate, toggle_prepass_view))
// Disabling MSAA for maximum compatibility. Shader prepass with MSAA needs GPU capability MULTISAMPLED_SHADING
.insert_resource(Msaa::Off)
.run();
}
/// set up a simple 3D scene
fn setup(
mut commands: Commands,
mut meshes: ResMut<Assets<Mesh>>,
mut materials: ResMut<Assets<CustomMaterial>>,
mut std_materials: ResMut<Assets<StandardMaterial>>,
mut depth_materials: ResMut<Assets<PrepassOutputMaterial>>,
asset_server: Res<AssetServer>,
) {
// camera
commands.spawn((
Camera3dBundle {
transform: Transform::from_xyz(-2.0, 3., 5.0).looking_at(Vec3::ZERO, Vec3::Y),
..default()
},
// To enable the prepass you need to add the components associated with the ones you need
// This will write the depth buffer to a texture that you can use in the main pass
DepthPrepass,
// This will generate a texture containing world normals (with normal maps applied)
NormalPrepass,
// This will generate a texture containing screen space pixel motion vectors
MotionVectorPrepass,
));
// plane
commands.spawn(PbrBundle {
mesh: meshes.add(Plane3d::default().mesh().size(5.0, 5.0)),
material: std_materials.add(Color::rgb(0.3, 0.5, 0.3)),
..default()
});
// A quad that shows the outputs of the prepass
// To make it easy, we just draw a big quad right in front of the camera.
// For a real application, this isn't ideal.
commands.spawn((
MaterialMeshBundle {
mesh: meshes.add(Rectangle::new(20.0, 20.0)),
material: depth_materials.add(PrepassOutputMaterial {
settings: ShowPrepassSettings::default(),
}),
transform: Transform::from_xyz(-0.75, 1.25, 3.0)
.looking_at(Vec3::new(2.0, -2.5, -5.0), Vec3::Y),
..default()
},
NotShadowCaster,
));
// Opaque cube
commands.spawn((
MaterialMeshBundle {
mesh: meshes.add(Cuboid::default()),
material: materials.add(CustomMaterial {
color: Color::WHITE,
color_texture: Some(asset_server.load("branding/icon.png")),
alpha_mode: AlphaMode::Opaque,
}),
transform: Transform::from_xyz(-1.0, 0.5, 0.0),
..default()
},
Rotates,
));
// Cube with alpha mask
commands.spawn(PbrBundle {
mesh: meshes.add(Cuboid::default()),
material: std_materials.add(StandardMaterial {
alpha_mode: AlphaMode::Mask(1.0),
base_color_texture: Some(asset_server.load("branding/icon.png")),
..default()
}),
transform: Transform::from_xyz(0.0, 0.5, 0.0),
..default()
});
// Cube with alpha blending.
// Transparent materials are ignored by the prepass
commands.spawn(MaterialMeshBundle {
mesh: meshes.add(Cuboid::default()),
material: materials.add(CustomMaterial {
color: Color::WHITE,
color_texture: Some(asset_server.load("branding/icon.png")),
alpha_mode: AlphaMode::Blend,
}),
transform: Transform::from_xyz(1.0, 0.5, 0.0),
..default()
});
// light
commands.spawn(PointLightBundle {
point_light: PointLight {
shadows_enabled: true,
..default()
},
transform: Transform::from_xyz(4.0, 8.0, 4.0),
..default()
});
let style = TextStyle {
font_size: 18.0,
..default()
};
commands.spawn(
TextBundle::from_sections(vec![
TextSection::new("Prepass Output: transparent\n", style.clone()),
TextSection::new("\n\n", style.clone()),
TextSection::new("Controls\n", style.clone()),
TextSection::new("---------------\n", style.clone()),
TextSection::new("Space - Change output\n", style),
])
.with_style(Style {
position_type: PositionType::Absolute,
top: Val::Px(10.0),
left: Val::Px(10.0),
..default()
}),
);
}
// This is the struct that will be passed to your shader
#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
struct CustomMaterial {
#[uniform(0)]
color: Color,
#[texture(1)]
#[sampler(2)]
color_texture: Option<Handle<Image>>,
alpha_mode: AlphaMode,
}
/// Not shown in this example, but if you need to specialize your material, the specialize
/// function will also be used by the prepass
impl Material for CustomMaterial {
fn fragment_shader() -> ShaderRef {
"shaders/custom_material.wgsl".into()
}
fn alpha_mode(&self) -> AlphaMode {
self.alpha_mode
}
// You can override the default shaders used in the prepass if your material does
// anything not supported by the default prepass
// fn prepass_fragment_shader() -> ShaderRef {
// "shaders/custom_material.wgsl".into()
// }
}
#[derive(Component)]
struct Rotates;
fn rotate(mut q: Query<&mut Transform, With<Rotates>>, time: Res<Time>) {
for mut t in q.iter_mut() {
let rot = (time.elapsed_seconds().sin() * 0.5 + 0.5) * std::f32::consts::PI * 2.0;
t.rotation = Quat::from_rotation_z(rot);
}
}
#[derive(Debug, Clone, Default, ShaderType)]
struct ShowPrepassSettings {
show_depth: u32,
show_normals: u32,
show_motion_vectors: u32,
padding_1: u32,
padding_2: u32,
}
// This shader simply loads the prepass texture and outputs it directly
#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
struct PrepassOutputMaterial {
#[uniform(0)]
settings: ShowPrepassSettings,
}
impl Material for PrepassOutputMaterial {
fn fragment_shader() -> ShaderRef {
"shaders/show_prepass.wgsl".into()
}
// This needs to be transparent in order to show the scene behind the mesh
fn alpha_mode(&self) -> AlphaMode {
AlphaMode::Blend
}
}
/// Every time you press space, it will cycle between transparent, depth and normals view
fn toggle_prepass_view(
mut prepass_view: Local<u32>,
keycode: Res<ButtonInput<KeyCode>>,
material_handle: Query<&Handle<PrepassOutputMaterial>>,
mut materials: ResMut<Assets<PrepassOutputMaterial>>,
mut text: Query<&mut Text>,
) {
if keycode.just_pressed(KeyCode::Space) {
*prepass_view = (*prepass_view + 1) % 4;
let label = match *prepass_view {
0 => "transparent",
1 => "depth",
2 => "normals",
3 => "motion vectors",
_ => unreachable!(),
};
let mut text = text.single_mut();
text.sections[0].value = format!("Prepass Output: {label}\n");
for section in &mut text.sections {
section.style.color = Color::WHITE;
}
let handle = material_handle.single();
let mat = materials.get_mut(handle).unwrap();
mat.settings.show_depth = (*prepass_view == 1) as u32;
mat.settings.show_normals = (*prepass_view == 2) as u32;
mat.settings.show_motion_vectors = (*prepass_view == 3) as u32;
}
}