move files around, graphics config, msaa

1 files changed, 98 insertions, 32 deletions

diff --git a/client/src/render/mod.rs b/client/src/render/mod.rs
index 6964337..db961f4 100644
--- a/client/src/render/mod.rs
+++ b/client/src/render/mod.rs
@@ -15,10 +15,11 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 pub mod scene;
+pub mod shaders;
+pub mod ui;
 
 use crate::{
     camera::Camera, download::Downloader, interfaces::profiler::TimingProfiler, state::InputState,
-    ui::UiRenderer,
 };
 use anyhow::{Result, anyhow};
 use log::{info, warn};
@@ -30,6 +31,7 @@ use std::{
     thread::{sleep, spawn},
     time::Duration,
 };
+use ui::UiRenderer;
 use weareshared::tree::SceneTree;
 use wgpu::{
     AdapterInfo, Backends, CommandEncoderDescriptor, Device, DeviceDescriptor, Extent3d, Features,
@@ -52,7 +54,18 @@ pub struct Renderer<'a> {
     pub timing: TimingProfiler,
     pub timing_submit: Arc<Mutex<TimingProfiler>>,
     pub adapter_info: Arc<AdapterInfo>,
+
+    color_msaa: TextureView,
+    config: GraphicsConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct GraphicsConfig {
+    max_anisotropy: u16,
+    max_mip_count: u32,
+    sample_count: u32,
 }
+
 impl<'a> Renderer<'a> {
     pub fn new(window: &'a Window, downloader: Arc<Downloader>) -> Result<Self> {
         info!("wgpu init");
@@ -95,31 +108,60 @@ impl<'a> Renderer<'a> {
         let device = Arc::new(device);
         let queue = Arc::new(queue);
 
+        let config = GraphicsConfig {
+            max_anisotropy: 16,
+            max_mip_count: 16,
+            sample_count: 4,
+        };
+
+        let depth = device
+            .create_texture(&TextureDescriptor {
+                label: None,
+                size: Extent3d {
+                    height: 256,
+                    width: 256,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: config.sample_count,
+                dimension: TextureDimension::D2,
+                format: TextureFormat::Depth32Float,
+                usage: TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
+            })
+            .create_view(&TextureViewDescriptor::default());
+
+        let color_msaa = device
+            .create_texture(&TextureDescriptor {
+                label: None,
+                size: Extent3d {
+                    height: 256,
+                    width: 256,
+                    depth_or_array_layers: 1,
+                },
+                mip_level_count: 1,
+                sample_count: config.sample_count,
+                dimension: TextureDimension::D2,
+                format: surface_configuration.format,
+                usage: TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
+            })
+            .create_view(&TextureViewDescriptor::default());
+
         let scene_prepare = Arc::new(ScenePreparer::new(
             device.clone(),
             queue.clone(),
             surface_configuration.format,
             downloader,
+            config.clone(),
         ));
 
-        let ui_renderer =
-            UiRenderer::new(device.clone(), queue.clone(), surface_configuration.format);
-
-        let depth = device.create_texture(&TextureDescriptor {
-            label: None,
-            size: Extent3d {
-                height: 256,
-                width: 256,
-                depth_or_array_layers: 1,
-            },
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: TextureDimension::D2,
-            format: TextureFormat::Depth32Float,
-            usage: TextureUsages::RENDER_ATTACHMENT,
-            view_formats: &[],
-        });
-        let depth = depth.create_view(&TextureViewDescriptor::default());
+        let ui_renderer = UiRenderer::new(
+            device.clone(),
+            queue.clone(),
+            surface_configuration.format,
+            config.clone(),
+        );
 
         // TODO multithreading introduces double-loading some resources. fix that before increasing thread count
         for _ in 0..1 {
@@ -146,9 +188,11 @@ impl<'a> Renderer<'a> {
             queue,
             surface_configuration,
             ui_renderer,
+            config,
             surface_needs_reconfigure: false,
             timing: Default::default(),
             timing_submit: Default::default(),
+            color_msaa,
         })
     }
 
@@ -158,23 +202,38 @@ impl<'a> Renderer<'a> {
         self.surface
             .configure(&self.device, &self.surface_configuration);
 
+        let size = Extent3d {
+            height,
+            width,
+            depth_or_array_layers: 1,
+        };
         self.depth = self
             .device
             .create_texture(&TextureDescriptor {
                 label: None,
-                size: Extent3d {
-                    height,
-                    width,
-                    depth_or_array_layers: 1,
-                },
+                size,
                 mip_level_count: 1,
-                sample_count: 1,
+                sample_count: self.config.sample_count,
                 dimension: TextureDimension::D2,
                 format: TextureFormat::Depth32Float,
                 usage: TextureUsages::RENDER_ATTACHMENT,
                 view_formats: &[],
             })
             .create_view(&TextureViewDescriptor::default());
+
+        self.color_msaa = self
+            .device
+            .create_texture(&TextureDescriptor {
+                label: None,
+                size,
+                mip_level_count: 1,
+                sample_count: self.config.sample_count,
+                dimension: TextureDimension::D2,
+                format: self.surface_configuration.format,
+                usage: TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
+            })
+            .create_view(&TextureViewDescriptor::default());
     }
 
     pub fn draw(
@@ -189,12 +248,12 @@ impl<'a> Renderer<'a> {
                 .configure(&self.device, &self.surface_configuration);
             self.surface_needs_reconfigure = false
         }
-        let target = self.surface.get_current_texture()?;
-        if target.suboptimal {
+        let surface = self.surface.get_current_texture()?;
+        if surface.suboptimal {
             warn!("suboptimal swapchain texture");
             self.surface_needs_reconfigure = true;
         }
-        let target_view = target
+        let target_view = surface
             .texture
             .create_view(&TextureViewDescriptor::default());
 
@@ -205,10 +264,17 @@ impl<'a> Renderer<'a> {
         let view = camera.view_matrix();
         let project = camera.project_matrix();
 
+        let (target, resolve_target) = if self.config.sample_count == 1 {
+            (&target_view, None)
+        } else {
+            (&self.color_msaa, Some(&target_view))
+        };
+
         self.timing.checkpoint("draw scene");
         self.scene_pipeline.draw(
             &mut commands,
-            &target_view,
+            target,
+            resolve_target,
             &self.depth,
             scene,
             &self.scene_prepare.prefabs,
@@ -219,7 +285,8 @@ impl<'a> Renderer<'a> {
         self.timing.checkpoint("draw ui");
         self.ui_renderer.draw(
             &mut commands,
-            &target_view,
+            target,
+            resolve_target,
             &self.depth,
             project * view,
             input_state,
@@ -232,10 +299,9 @@ impl<'a> Renderer<'a> {
         self.device.poll(MaintainBase::WaitForSubmissionIndex(i));
 
         self.timing.checkpoint("present");
-        target.present();
+        surface.present();
 
         self.timing.checkpoint("");
-
         let mut ts = self.timing_submit.lock().unwrap();
         swap(&mut *ts, &mut self.timing);