>,
29 | }
30 |
31 | impl GltfData {
32 | /// Create a new `GltfData` instance.
33 | pub fn new(buffers: Vec, path: P) -> Self
34 | where
35 | P: AsRef,
36 | {
37 | let mut base_dir = PathBuf::from(path.as_ref());
38 | base_dir.pop();
39 | Self {
40 | buffers,
41 | base_dir,
42 | models: HashMap::default(),
43 | materials: HashMap::default(),
44 | rgb_images: HashMap::default(),
45 | rgba_images: HashMap::default(),
46 | gray_images: HashMap::default(),
47 | }
48 | }
49 |
50 | /// Get a rgb image from the glTF document.
51 | pub fn get_rgb_image(&self, texture: &gltf::Texture<'_>) -> Arc {
52 | Arc::clone(
53 | self.rgb_images
54 | .get(&texture.index())
55 | .expect("Didn't preload this image"),
56 | )
57 | }
58 |
59 | /// Get a base color image from the glTF document.
60 | pub fn get_base_color_image(&self, texture: &gltf::Texture<'_>) -> Arc {
61 | Arc::clone(
62 | self.rgba_images
63 | .get(&texture.index())
64 | .expect("Didn't preload this image"),
65 | )
66 | }
67 |
68 | /// Get a gray image from the glTF document.
69 | pub fn get_gray_image(&self, texture: &gltf::Texture<'_>, channel: usize) -> Arc {
70 | Arc::clone(
71 | self.gray_images
72 | .get(&(texture.index(), channel))
73 | .expect("Didn't preload this image"),
74 | )
75 | }
76 |
77 | /// Load a texture from the glTF document.
78 | pub fn load_texture(&self, texture: &gltf::Texture<'_>) -> DynamicImage {
79 | let g_img = texture.source();
80 | let buffers = &self.buffers;
81 | match g_img.source() {
82 | Source::View { view, mime_type } => {
83 | let parent_buffer_data = &buffers[view.buffer().index()].0;
84 | let data = &parent_buffer_data[view.offset()..view.offset() + view.length()];
85 | let mime_type = mime_type.replace('/', ".");
86 | image::load_from_memory_with_format(
87 | data,
88 | ImageFormat::from_path(mime_type).unwrap(),
89 | )
90 | .unwrap()
91 | }
92 | Source::Uri { uri, mime_type } => {
93 | if uri.starts_with("data:") {
94 | let encoded = uri.split(',').nth(1).unwrap();
95 | let data = URL_SAFE_NO_PAD.decode(encoded).unwrap();
96 | let mime_type = mime_type.map_or_else(
97 | || {
98 | uri.split(',')
99 | .next()
100 | .unwrap()
101 | .split(':')
102 | .nth(1)
103 | .unwrap()
104 | .split(';')
105 | .next()
106 | .unwrap()
107 | },
108 | |ty| ty,
109 | );
110 | let mime_type = mime_type.replace('/', ".");
111 | image::load_from_memory_with_format(
112 | &data,
113 | ImageFormat::from_path(mime_type).unwrap(),
114 | )
115 | .unwrap()
116 | } else {
117 | let path = self.base_dir.join(uri);
118 | image::open(path).unwrap()
119 | }
120 | }
121 | }
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/gltf/utils/mod.rs:
--------------------------------------------------------------------------------
1 | mod gltf_data;
2 |
3 | use std::sync::{Arc, RwLock};
4 |
5 | use glam::Mat4;
6 | pub use gltf_data::GltfData;
7 |
8 | use gltf::scene::Transform;
9 | use image::GrayImage;
10 | use itertools::Itertools;
11 | use rayon::prelude::*;
12 |
13 | pub fn transform_to_matrix(transform: Transform) -> Mat4 {
14 | Mat4::from_cols_array_2d(&transform.matrix())
15 | }
16 |
17 | /// Get all rgb images from the glTF document.
18 | /// rgb textures are:
19 | /// - normal textures
20 | /// - emissive textures
21 | pub fn get_rgb_textures(doc: &gltf::Document) -> Vec {
22 | let normal_textures = doc
23 | .materials()
24 | .filter_map(|mat| mat.normal_texture())
25 | .map(|normal| normal.texture());
26 | let emissive_textures = doc
27 | .materials()
28 | .filter_map(|mat| mat.emissive_texture())
29 | .map(|emissive| emissive.texture());
30 |
31 | // append normal and emissives
32 | normal_textures
33 | .chain(emissive_textures)
34 | .unique_by(gltf::Texture::index)
35 | .collect()
36 | }
37 |
38 | /// Load all rgb images from the glTF document.
39 | pub fn load_rgb_images(doc: &gltf::Document, data: &Arc>) {
40 | // Load rgb images
41 | get_rgb_textures(doc).par_iter().for_each(|tex| {
42 | let texture = {
43 | let data = data.read().unwrap();
44 | data.load_texture(tex)
45 | };
46 |
47 | let texture = Arc::new(texture.to_rgb8());
48 | data.write()
49 | .unwrap()
50 | .rgb_images
51 | .insert(tex.index(), texture);
52 | });
53 | }
54 |
55 | /// Get all rgba images from the glTF document.
56 | /// rgba textures are:
57 | /// - base color textures
58 | pub fn get_rgba_textures(doc: &gltf::Document) -> Vec {
59 | doc.materials()
60 | .filter_map(|mat| mat.pbr_metallic_roughness().base_color_texture())
61 | .map(|info| info.texture())
62 | .collect()
63 | }
64 |
65 | /// Load all rgba images from the glTF document.
66 | pub fn load_rbga_images(doc: &gltf::Document, data: &Arc>) {
67 | // Load rgb images
68 | get_rgba_textures(doc).par_iter().for_each(|tex| {
69 | let texture = {
70 | let data = data.read().unwrap();
71 | data.load_texture(tex)
72 | };
73 |
74 | let texture = Arc::new(texture.to_rgba8());
75 | data.write()
76 | .unwrap()
77 | .rgba_images
78 | .insert(tex.index(), texture);
79 | });
80 | }
81 |
82 | /// Get all rgba images from the glTF document.
83 | /// rgba textures are:
84 | /// - occlusion textures
85 | /// - metallic roughness textures
86 | pub fn get_gray_textures(doc: &gltf::Document) -> Vec {
87 | let occlusion_textures = doc
88 | .materials()
89 | .filter_map(|mat| mat.occlusion_texture())
90 | .map(|normal| normal.texture());
91 | let metallic_roughness_textures = doc
92 | .materials()
93 | .filter_map(|mat| mat.pbr_metallic_roughness().metallic_roughness_texture())
94 | .map(|emissive| emissive.texture());
95 |
96 | // Only keep unique textures indices.
97 | occlusion_textures
98 | .chain(metallic_roughness_textures)
99 | .unique_by(gltf::Texture::index)
100 | .collect()
101 | }
102 |
103 | /// Load all rgba images from the glTF document.
104 | pub fn load_gray_images(doc: &gltf::Document, data: &Arc>) {
105 | // Load rgb images
106 | get_gray_textures(doc).par_iter().for_each(|tex| {
107 | let texture = {
108 | let data = data.read().unwrap();
109 | data.load_texture(tex)
110 | };
111 |
112 | let img = texture.to_rgba8();
113 | for channel in 0..4 {
114 | let mut extract_img = GrayImage::new(img.width(), img.height());
115 | for (x, y, px) in img.enumerate_pixels() {
116 | extract_img[(x, y)][0] = px[channel];
117 | }
118 |
119 | let img = Arc::new(extract_img);
120 |
121 | data.write()
122 | .unwrap()
123 | .gray_images
124 | .insert((tex.index(), channel), img);
125 | }
126 | });
127 | }
128 |
129 | /// Load all images from the glTF document.
130 | pub fn load_all_images(doc: &gltf::Document, data: &Arc>) {
131 | load_rgb_images(doc, data);
132 | load_rbga_images(doc, data);
133 | load_gray_images(doc, data);
134 | }
135 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/main.rs:
--------------------------------------------------------------------------------
1 | //! Client application for the `mesh_to_sdf` project.
2 | //!
3 | //! 
4 | //!
5 | //! A visualization client for the SDF of a mesh.
6 | //! Generates a SDF from a mesh and renders it.
7 | mod camera;
8 | mod camera_control;
9 | mod cubemap;
10 | mod frame_rate;
11 | mod gltf;
12 | mod passes;
13 | mod pbr;
14 | mod reload_flags;
15 | mod runner;
16 | mod sdf;
17 | mod sdf_program;
18 | mod texture;
19 | mod utility;
20 |
21 | use std::sync::{Arc, Mutex};
22 |
23 | #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
24 | use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
25 |
26 | #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
27 | use std::path::Path;
28 |
29 | /// App entry point.
30 | fn main() {
31 | let data = Arc::new(Mutex::new(crate::reload_flags::ReloadFlags {
32 | shaders: vec![],
33 | }));
34 |
35 | // Watch shaders folder.
36 | // When a shader is saved, the pipelines will be recreated.
37 | // Only enabled in native debug mode.
38 | #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
39 | {
40 | let data = Arc::clone(&data);
41 | std::thread::spawn(move || {
42 | // first try to watch the mesh_to_sdf_client/shaders folder (runnin from the root of the project)
43 | // if that fails, try to watch the shaders folder (running from the client folder)
44 | let paths = ["mesh_to_sdf_client/shaders", "shaders"];
45 | for path in paths {
46 | log::info!("Watching {path}");
47 | if let Err(error) = watch(path, &data) {
48 | log::error!("Could not watch shaders folder: {error:?}");
49 | }
50 | }
51 | });
52 | }
53 |
54 | runner::start_app(data);
55 | }
56 |
57 | /// Watch shader folder. Only done in native debug mode.
58 | /// Everytime a shader is modified/added/deleted,
59 | /// it will update the `ReloadFlags` so the program can reload them.
60 | #[cfg(all(debug_assertions, not(target_arch = "wasm32")))]
61 | fn watch>(
62 | path: P,
63 | data: &Arc>,
64 | ) -> notify::Result<()> {
65 | let (tx, rx) = std::sync::mpsc::channel();
66 |
67 | // Automatically select the best implementation for your platform.
68 | // You can also access each implementation directly e.g. INotifyWatcher.
69 | let mut watcher = RecommendedWatcher::new(tx, Config::default())?;
70 |
71 | // Add a path to be watched. All files and directories at that path and
72 | // below will be monitored for changes.
73 | watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;
74 |
75 | for res in rx {
76 | match res {
77 | Ok(event) => {
78 | log::info!("Change: {:?}", event.paths);
79 | let mut data = data.lock().unwrap();
80 | event.paths.iter().for_each(|p| {
81 | let shader_path = p.to_str().unwrap().to_owned();
82 | data.shaders.push(shader_path);
83 | });
84 | }
85 | Err(error) => log::error!("Error: {error:?}"),
86 | }
87 | }
88 |
89 | Ok(())
90 | }
91 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/passes/mip_generation_pass.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 |
3 | use crate::utility::shader_builder::ShaderBuilder;
4 |
5 | #[derive(Debug)]
6 | pub struct MipGenerationPass {
7 | pub pipeline: wgpu::RenderPipeline,
8 | pub sampler: wgpu::Sampler,
9 | }
10 |
11 | impl MipGenerationPass {
12 | pub fn create_pipeline(device: &wgpu::Device) -> Result {
13 | let shader = ShaderBuilder::create_module(device, "utility/mipmap_generation.wgsl")?;
14 |
15 | let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
16 | label: Some("blit"),
17 | layout: None,
18 | vertex: wgpu::VertexState {
19 | module: &shader,
20 | entry_point: "vs_main",
21 | buffers: &[],
22 | compilation_options: wgpu::PipelineCompilationOptions::default(),
23 | },
24 | fragment: Some(wgpu::FragmentState {
25 | module: &shader,
26 | entry_point: "fs_main",
27 | targets: &[Some(wgpu::TextureFormat::Rgba8UnormSrgb.into())],
28 | compilation_options: wgpu::PipelineCompilationOptions::default(),
29 | }),
30 | primitive: wgpu::PrimitiveState {
31 | topology: wgpu::PrimitiveTopology::TriangleList,
32 | ..Default::default()
33 | },
34 | depth_stencil: None,
35 | multisample: wgpu::MultisampleState::default(),
36 | multiview: None,
37 | });
38 |
39 | Ok(pipeline)
40 | }
41 |
42 | pub fn update_pipeline(&mut self, device: &wgpu::Device) -> Result<()> {
43 | self.pipeline = Self::create_pipeline(device)?;
44 | Ok(())
45 | }
46 |
47 | pub fn new(device: &wgpu::Device) -> Result {
48 | let pipeline = Self::create_pipeline(device)?;
49 |
50 | let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
51 | label: Some("mip"),
52 | address_mode_u: wgpu::AddressMode::ClampToEdge,
53 | address_mode_v: wgpu::AddressMode::ClampToEdge,
54 | address_mode_w: wgpu::AddressMode::ClampToEdge,
55 | mag_filter: wgpu::FilterMode::Linear,
56 | min_filter: wgpu::FilterMode::Linear,
57 | mipmap_filter: wgpu::FilterMode::Nearest,
58 | ..Default::default()
59 | });
60 |
61 | Ok(Self { pipeline, sampler })
62 | }
63 |
64 | pub fn run(
65 | &self,
66 | device: &wgpu::Device,
67 | encoder: &mut wgpu::CommandEncoder,
68 | from_view: &wgpu::TextureView,
69 | to_view: &wgpu::TextureView,
70 | ) {
71 | let bind_group_layout = self.pipeline.get_bind_group_layout(0);
72 |
73 | let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
74 | layout: &bind_group_layout,
75 | entries: &[
76 | wgpu::BindGroupEntry {
77 | binding: 0,
78 | resource: wgpu::BindingResource::TextureView(from_view),
79 | },
80 | wgpu::BindGroupEntry {
81 | binding: 1,
82 | resource: wgpu::BindingResource::Sampler(&self.sampler),
83 | },
84 | ],
85 | label: Some("generate_mipmaps::bind_group"),
86 | });
87 |
88 | let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
89 | label: Some("generate_mipmaps::rpass"),
90 | color_attachments: &[Some(wgpu::RenderPassColorAttachment {
91 | view: to_view,
92 | resolve_target: None,
93 | ops: wgpu::Operations {
94 | load: wgpu::LoadOp::Load,
95 | store: wgpu::StoreOp::Store,
96 | },
97 | })],
98 | depth_stencil_attachment: None,
99 | timestamp_writes: None,
100 | occlusion_query_set: None,
101 | });
102 | rpass.set_pipeline(&self.pipeline);
103 | rpass.set_bind_group(0, &bind_group, &[]);
104 | rpass.draw(0..3, 0..1);
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/passes/mod.rs:
--------------------------------------------------------------------------------
1 | //! Contains all the passes used in the renderer.
2 | pub mod cubemap_generation_pass;
3 | pub mod mip_generation_pass;
4 | pub mod model_render_pass;
5 | pub mod raymarch_pass;
6 | pub mod sdf_render_pass;
7 | pub mod shadow_pass;
8 | pub mod voxel_render_pass;
9 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/passes/sdf_render_pass.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 |
3 | use crate::camera::CameraData;
4 | use crate::sdf::{Sdf, SdfUniforms};
5 | use crate::texture::Texture;
6 | use crate::utility::shader_builder::ShaderBuilder;
7 |
8 | pub struct SdfRenderPass {
9 | pub render_pipeline: wgpu::RenderPipeline,
10 | pub sdf_bind_group_layout: wgpu::BindGroupLayout,
11 | }
12 |
13 | impl SdfRenderPass {
14 | fn create_pipeline(
15 | device: &wgpu::Device,
16 | view_format: wgpu::TextureFormat,
17 | camera: &CameraData,
18 | sdf_bind_group_layout: &wgpu::BindGroupLayout,
19 | settings_bind_group_layout: &wgpu::BindGroupLayout,
20 | ) -> Result {
21 | let draw_shader = ShaderBuilder::create_module(device, "draw_sdf.wgsl")?;
22 |
23 | let render_pipeline_layout =
24 | device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
25 | label: Some("SdfRenderPass::PipelineLayout"),
26 | bind_group_layouts: &[
27 | sdf_bind_group_layout,
28 | &camera.bind_group_layout,
29 | settings_bind_group_layout,
30 | ],
31 | push_constant_ranges: &[],
32 | });
33 |
34 | let primitive = wgpu::PrimitiveState {
35 | topology: wgpu::PrimitiveTopology::TriangleList,
36 | strip_index_format: None,
37 | front_face: wgpu::FrontFace::Ccw,
38 | cull_mode: None,
39 | polygon_mode: wgpu::PolygonMode::Fill,
40 | unclipped_depth: false,
41 | conservative: false,
42 | };
43 |
44 | ShaderBuilder::create_render_pipeline(
45 | device,
46 | &wgpu::RenderPipelineDescriptor {
47 | label: Some("SdfRenderPass::RenderPipeline"),
48 | layout: Some(&render_pipeline_layout),
49 | vertex: wgpu::VertexState {
50 | module: &draw_shader,
51 | entry_point: "main_vs",
52 | buffers: &[],
53 | compilation_options: wgpu::PipelineCompilationOptions::default(),
54 | },
55 | fragment: Some(wgpu::FragmentState {
56 | module: &draw_shader,
57 | entry_point: "main_fs",
58 | targets: &[Some(view_format.into())],
59 | compilation_options: wgpu::PipelineCompilationOptions::default(),
60 | }),
61 | primitive,
62 | depth_stencil: Some(wgpu::DepthStencilState {
63 | format: Texture::DEPTH_FORMAT,
64 | depth_write_enabled: true,
65 | depth_compare: wgpu::CompareFunction::Greater,
66 | stencil: wgpu::StencilState::default(),
67 | bias: wgpu::DepthBiasState::default(),
68 | }),
69 | multisample: wgpu::MultisampleState::default(),
70 | multiview: None,
71 | },
72 | )
73 | }
74 |
75 | pub fn get_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
76 | device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
77 | label: Some("Sdf Bind Group Layout"),
78 | entries: &[
79 | wgpu::BindGroupLayoutEntry {
80 | binding: 0,
81 | visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
82 | ty: wgpu::BindingType::Buffer {
83 | ty: wgpu::BufferBindingType::Uniform,
84 | has_dynamic_offset: false,
85 | min_binding_size: wgpu::BufferSize::new(
86 | core::mem::size_of::() as _,
87 | ),
88 | },
89 | count: None,
90 | },
91 | wgpu::BindGroupLayoutEntry {
92 | binding: 1,
93 | visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
94 | ty: wgpu::BindingType::Buffer {
95 | ty: wgpu::BufferBindingType::Storage { read_only: true },
96 | has_dynamic_offset: false,
97 | min_binding_size: None,
98 | },
99 | count: None,
100 | },
101 | wgpu::BindGroupLayoutEntry {
102 | binding: 2,
103 | visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
104 | ty: wgpu::BindingType::Buffer {
105 | ty: wgpu::BufferBindingType::Storage { read_only: true },
106 | has_dynamic_offset: false,
107 | min_binding_size: None,
108 | },
109 | count: None,
110 | },
111 | ],
112 | })
113 | }
114 |
115 | pub fn update_pipeline(
116 | &mut self,
117 | device: &wgpu::Device,
118 | view_format: wgpu::TextureFormat,
119 | camera: &CameraData,
120 | settings_bind_group_layout: &wgpu::BindGroupLayout,
121 | ) -> Result<()> {
122 | self.render_pipeline = Self::create_pipeline(
123 | device,
124 | view_format,
125 | camera,
126 | &self.sdf_bind_group_layout,
127 | settings_bind_group_layout,
128 | )?;
129 | Ok(())
130 | }
131 | pub fn new(
132 | device: &wgpu::Device,
133 | view_format: wgpu::TextureFormat,
134 | camera: &CameraData,
135 | settings_bind_group_layout: &wgpu::BindGroupLayout,
136 | ) -> Result {
137 | let sdf_bind_group_layout = Self::get_bind_group_layout(device);
138 |
139 | let render_pipeline = Self::create_pipeline(
140 | device,
141 | view_format,
142 | camera,
143 | &sdf_bind_group_layout,
144 | settings_bind_group_layout,
145 | )?;
146 |
147 | Ok(Self {
148 | render_pipeline,
149 | sdf_bind_group_layout,
150 | })
151 | }
152 |
153 | pub fn run(
154 | &self,
155 | command_encoder: &mut wgpu::CommandEncoder,
156 | view: &wgpu::TextureView,
157 | depth_map: &Texture,
158 | camera: &CameraData,
159 | sdf: &Sdf,
160 | settings_bind_group: &wgpu::BindGroup,
161 | ) {
162 | // need to draw it each frame to update depth map.
163 | command_encoder.push_debug_group("render particles");
164 | {
165 | let render_pass_descriptor = wgpu::RenderPassDescriptor {
166 | label: Some("SdfRenderPass::run::render_pass_descriptor"),
167 | color_attachments: &[Some(wgpu::RenderPassColorAttachment {
168 | view,
169 | resolve_target: None,
170 | ops: wgpu::Operations {
171 | load: wgpu::LoadOp::Load,
172 | store: wgpu::StoreOp::Store,
173 | },
174 | })],
175 | depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
176 | view: &depth_map.view,
177 | depth_ops: Some(wgpu::Operations {
178 | load: wgpu::LoadOp::Load,
179 | store: wgpu::StoreOp::Store,
180 | }),
181 | stencil_ops: None,
182 | }),
183 | timestamp_writes: None,
184 | occlusion_query_set: None,
185 | };
186 |
187 | // render pass
188 | let mut rpass = command_encoder.begin_render_pass(&render_pass_descriptor);
189 | rpass.set_pipeline(&self.render_pipeline);
190 | rpass.set_bind_group(0, &sdf.bind_group, &[]);
191 | rpass.set_bind_group(1, &camera.bind_group, &[]);
192 | rpass.set_bind_group(2, settings_bind_group, &[]);
193 | // vertices are computed in the shader directly to save bandwidth
194 | rpass.draw(0..3, 0..sdf.get_cell_count());
195 | }
196 | command_encoder.pop_debug_group();
197 | }
198 | }
199 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/passes/shadow_pass.rs:
--------------------------------------------------------------------------------
1 | use anyhow::Result;
2 |
3 | use crate::pbr::mesh::MeshVertex;
4 | use crate::pbr::model::Model;
5 | use crate::pbr::model_instance::ModelInstance;
6 | use crate::texture::Texture;
7 | use crate::utility::shader_builder::ShaderBuilder;
8 |
9 | use crate::pbr::shadow_map::ShadowMap;
10 |
11 | use crate::passes::model_render_pass::ModelRenderPass;
12 |
13 | pub struct ShadowPass {
14 | pub render_pipeline: wgpu::RenderPipeline,
15 | pub map: ShadowMap,
16 | }
17 |
18 | impl ShadowPass {
19 | fn create_pipeline(
20 | device: &wgpu::Device,
21 | shadow_map: &ShadowMap,
22 | ) -> Result {
23 | let draw_shader = ShaderBuilder::create_module(device, "draw_model.wgsl")?;
24 |
25 | let model_bind_group_layout = ModelRenderPass::create_model_bind_group_layout(device);
26 |
27 | let render_pipeline_layout =
28 | device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
29 | label: Some("shadow map"),
30 | bind_group_layouts: &[
31 | &model_bind_group_layout,
32 | &shadow_map.light.bind_group_layout,
33 | ],
34 | push_constant_ranges: &[],
35 | });
36 |
37 | ShaderBuilder::create_render_pipeline(
38 | device,
39 | &wgpu::RenderPipelineDescriptor {
40 | label: Some("shadow pass"),
41 | layout: Some(&render_pipeline_layout),
42 | vertex: wgpu::VertexState {
43 | module: &draw_shader,
44 | entry_point: "main_vs",
45 | buffers: &[MeshVertex::desc()],
46 | compilation_options: wgpu::PipelineCompilationOptions::default(),
47 | },
48 | fragment: None,
49 | primitive: wgpu::PrimitiveState::default(),
50 | depth_stencil: Some(wgpu::DepthStencilState {
51 | format: Texture::DEPTH_FORMAT,
52 | depth_write_enabled: true,
53 | depth_compare: wgpu::CompareFunction::Greater,
54 | stencil: wgpu::StencilState::default(),
55 | bias: wgpu::DepthBiasState::default(),
56 | }),
57 | multisample: wgpu::MultisampleState::default(),
58 | multiview: None,
59 | },
60 | )
61 | }
62 |
63 | pub fn update_pipeline(&mut self, device: &wgpu::Device) -> Result<()> {
64 | self.render_pipeline = Self::create_pipeline(device, &self.map)?;
65 | Ok(())
66 | }
67 |
68 | pub fn new(device: &wgpu::Device, shadow_map: ShadowMap) -> Result {
69 | Ok(Self {
70 | render_pipeline: Self::create_pipeline(device, &shadow_map)?,
71 | map: shadow_map,
72 | })
73 | }
74 |
75 | pub fn run(
76 | &self,
77 | command_encoder: &mut wgpu::CommandEncoder,
78 | model: &Model,
79 | model_instance: &ModelInstance,
80 | ) {
81 | let render_pass_descriptor = wgpu::RenderPassDescriptor {
82 | label: Some("ShadowPass::run::render_pass_descriptor"),
83 | color_attachments: &[],
84 | depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
85 | view: &self.map.texture.view,
86 | depth_ops: Some(wgpu::Operations {
87 | load: wgpu::LoadOp::Load,
88 | store: wgpu::StoreOp::Store,
89 | }),
90 | stencil_ops: None,
91 | }),
92 | timestamp_writes: None,
93 | occlusion_query_set: None,
94 | };
95 |
96 | let mut rpass = command_encoder.begin_render_pass(&render_pass_descriptor);
97 | rpass.set_pipeline(&self.render_pipeline);
98 | rpass.set_bind_group(0, &model_instance.transform_bind_group, &[]);
99 | rpass.set_bind_group(1, &self.map.light.bind_group, &[]);
100 | rpass.set_vertex_buffer(0, model.mesh.vertex_buffer.slice(..));
101 | rpass.set_index_buffer(model.mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
102 | rpass.draw_indexed(0..model.mesh.index_count, 0, 0..1);
103 | }
104 | }
105 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/pbr/mesh.rs:
--------------------------------------------------------------------------------
1 | use wgpu::util::DeviceExt;
2 |
3 | pub mod primitives;
4 |
5 | #[repr(C)]
6 | #[derive(Default, Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
7 | pub struct MeshVertex {
8 | pub position: [f32; 3],
9 | pub normal: [f32; 3],
10 | pub tex_coords: [f32; 2],
11 | }
12 |
13 | impl MeshVertex {
14 | const ATTRIBUTES: [wgpu::VertexAttribute; 3] =
15 | wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Float32x2];
16 |
17 | pub const fn desc() -> wgpu::VertexBufferLayout<'static> {
18 | wgpu::VertexBufferLayout {
19 | array_stride: 8 * 4,
20 | step_mode: wgpu::VertexStepMode::Vertex,
21 | attributes: &Self::ATTRIBUTES,
22 | }
23 | }
24 | }
25 |
26 | pub struct Mesh {
27 | pub vertices: Vec,
28 | pub indices: Vec,
29 |
30 | pub vertex_buffer: wgpu::Buffer,
31 | pub index_buffer: wgpu::Buffer,
32 |
33 | pub index_count: u32,
34 | }
35 |
36 | impl Mesh {
37 | pub fn new(device: &wgpu::Device, vertices: Vec, indices: Vec) -> Self {
38 | let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
39 | label: Some("Voxel Vertex Buffer"),
40 | contents: bytemuck::cast_slice(&vertices),
41 | usage: wgpu::BufferUsages::VERTEX,
42 | });
43 |
44 | let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
45 | label: Some("Voxel Index Buffer"),
46 | contents: bytemuck::cast_slice(&indices),
47 | usage: wgpu::BufferUsages::INDEX,
48 | });
49 |
50 | let index_count = indices.len() as u32;
51 | Self {
52 | vertices,
53 | indices,
54 |
55 | vertex_buffer,
56 | index_buffer,
57 |
58 | index_count,
59 | }
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/pbr/mesh/primitives.rs:
--------------------------------------------------------------------------------
1 | use itertools::Itertools;
2 |
3 | use super::{Mesh, MeshVertex};
4 |
5 | pub fn create_box(device: &wgpu::Device) -> Mesh {
6 | // Draw box.
7 | let positions = [
8 | // front
9 | [-1.0, -1.0, 1.0],
10 | [1.0, -1.0, 1.0],
11 | [-1.0, 1.0, 1.0],
12 | [1.0, 1.0, 1.0],
13 | // back
14 | [-1.0, -1.0, -1.0],
15 | [1.0, -1.0, -1.0],
16 | [-1.0, 1.0, -1.0],
17 | [1.0, 1.0, -1.0],
18 | // left
19 | [-1.0, -1.0, -1.0],
20 | [-1.0, -1.0, 1.0],
21 | [-1.0, 1.0, -1.0],
22 | [-1.0, 1.0, 1.0],
23 | // right
24 | [1.0, -1.0, -1.0],
25 | [1.0, -1.0, 1.0],
26 | [1.0, 1.0, -1.0],
27 | [1.0, 1.0, 1.0],
28 | // top
29 | [-1.0, 1.0, -1.0],
30 | [1.0, 1.0, -1.0],
31 | [-1.0, 1.0, 1.0],
32 | [1.0, 1.0, 1.0],
33 | // bottom
34 | [-1.0, -1.0, -1.0],
35 | [1.0, -1.0, -1.0],
36 | [-1.0, -1.0, 1.0],
37 | [1.0, -1.0, 1.0],
38 | ];
39 | let normals = [
40 | [0.0, 0.0, 1.0], // front
41 | [0.0, 0.0, -1.0], // back
42 | [-1.0, 0.0, 0.0], // left
43 | [1.0, 0.0, 0.0], // right
44 | [0.0, 1.0, 0.0], // top
45 | [0.0, -1.0, 0.0], // bottom
46 | ];
47 |
48 | let mut indices: Vec = vec![];
49 | #[allow(clippy::identity_op)]
50 | for face in 0..6 {
51 | indices.append(&mut vec![face * 4 + 2, face * 4 + 1, face * 4 + 3]);
52 | indices.append(&mut vec![face * 4 + 0, face * 4 + 1, face * 4 + 2]);
53 | }
54 |
55 | let vertices = positions
56 | .into_iter()
57 | .zip(normals.iter().flat_map(|&n| core::iter::repeat(n).take(4)))
58 | .map(|(position, normal)| MeshVertex {
59 | position,
60 | normal,
61 | tex_coords: [0.0, 0.0],
62 | })
63 | .collect_vec();
64 |
65 | Mesh::new(device, vertices, indices)
66 | }
67 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/pbr/mod.rs:
--------------------------------------------------------------------------------
1 | //! While the name is PBR, it's not really PBR at-the-moment.
2 | //! It's just a simple model renderer, with albedo, blinn-phong shading, specular and shadows.
3 | pub mod mesh;
4 | pub mod model;
5 | pub mod model_instance;
6 | pub mod shadow_map;
7 |
--------------------------------------------------------------------------------
/mesh_to_sdf_client/src/pbr/model.rs:
--------------------------------------------------------------------------------
1 | use itertools::Itertools;
2 |
3 | use crate::{
4 | gltf::{GltfModel, Material},
5 | texture::Texture,
6 | };
7 |
8 | use super::mesh::{Mesh, MeshVertex};
9 | use crate::passes::model_render_pass::ModelRenderPass;
10 |
11 | pub struct Model {
12 | pub name: Option,
13 |
14 | pub mesh: Mesh,
15 |
16 | // TODO Material struct.
17 | pub albedo: Texture,
18 |
19 | pub textures_bind_group: wgpu::BindGroup,
20 | }
21 |
22 | impl Model {
23 | pub fn from_gtlf(
24 | device: &wgpu::Device,
25 | queue: &wgpu::Queue,
26 | model: &GltfModel,
27 | material: Option<&Material>,
28 | ) -> Self {
29 | let indices = model
30 | .indices()
31 | .cloned()
32 | .unwrap_or_else(|| (0..(model.vertices().len() as u32)).collect());
33 | let vertices = model
34 | .vertices()
35 | .iter()
36 | .map(|v| MeshVertex {
37 | position: [v.position.x, v.position.y, v.position.z],
38 | normal: [v.normal.x, v.normal.y, v.normal.z],
39 | tex_coords: [v.tex_coords.x, v.tex_coords.y],
40 | })
41 | .collect_vec();
42 |
43 | println!("model: {:?}", model.mesh_name());
44 |
45 | let mesh = Mesh::new(device, vertices, indices);
46 |
47 | // If no albedo is present, render as grey.
48 | let grey_albedo: image::ImageBuffer, std::vec::Vec