Merge remote-tracking branch 'origin/trunk' into parse-to-edit-ast

editor/src/lib.rs

@@ -1,14 +1,5 @@
 #![warn(clippy::all, clippy::dbg_macro)]
-// I'm skeptical that clippy:large_enum_variant is a good lint to have globally enabled.
-//
-// It warns about a performance problem where the only quick remediation is
-// to allocate more on the heap, which has lots of tradeoffs - including making it
-// long-term unclear which allocations *need* to happen for compilation's sake
-// (e.g. recursive structures) versus those which were only added to appease clippy.
-//
-// Effectively optimizing data structure memory layout isn't a quick fix,
-// and encouraging shortcuts here creates bad incentives. I would rather temporarily
-// re-enable this when working on performance optimizations than have it block PRs.
+// See github.com/rtfeldman/roc/issues/800 for discussion of the large_enum_variant check.
 #![allow(clippy::large_enum_variant)]
 
 // Inspired by:
@@ -20,12 +11,10 @@
 use crate::buffer::create_rect_buffers;
 use crate::text::{build_glyph_brush, Text};
 use crate::vertex::Vertex;
-use cgmath::Ortho;
+use ortho::{init_ortho, update_ortho_buffer, OrthoResources};
 use std::error::Error;
 use std::io;
 use std::path::Path;
-use wgpu::util::DeviceExt;
-use wgpu::{BindGroup, BindGroupLayoutDescriptor, BindGroupLayoutEntry, Buffer, ShaderStage};
 use winit::event;
 use winit::event::{Event, ModifiersState};
 use winit::event_loop::ControlFlow;
@@ -35,6 +24,7 @@ mod buffer;
 pub mod expr;
 pub mod file;
 mod keyboard_input;
+mod ortho;
 pub mod pool;
 mod rect;
 pub mod text;
@@ -51,31 +41,6 @@ pub fn launch(_filepaths: &[&Path]) -> io::Result<()> {
     Ok(())
 }
 
-#[repr(C)]
-#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
-struct Uniforms {
-    // We can't use cgmath with bytemuck directly so we'll have
-    // to convert the Matrix4 into a 4x4 f32 array
-    ortho: [[f32; 4]; 4],
-}
-
-impl Uniforms {
-    fn new(w: u32, h: u32) -> Self {
-        let ortho: cgmath::Matrix4<f32> = Ortho::<f32> {
-            left: 0.0,
-            right: w as f32,
-            bottom: h as f32,
-            top: 0.0,
-            near: -1.0,
-            far: 1.0,
-        }
-        .into();
-        Self {
-            ortho: ortho.into(),
-        }
-    }
-}
-
 fn run_event_loop() -> Result<(), Box<dyn Error>> {
     env_logger::init();
 
@@ -133,8 +98,7 @@ fn run_event_loop() -> Result<(), Box<dyn Error>> {
 
     let mut swap_chain = gpu_device.create_swap_chain(&surface, &swap_chain_descr);
 
-    let (rect_pipeline, ortho_bind_group, ortho_buffer) =
-        make_rect_pipeline(&gpu_device, &swap_chain_descr);
+    let (rect_pipeline, ortho) = make_rect_pipeline(&gpu_device, &swap_chain_descr);
 
     let mut glyph_brush = build_glyph_brush(&gpu_device, render_format)?;
 
@@ -179,33 +143,13 @@ fn run_event_loop() -> Result<(), Box<dyn Error>> {
                     },
                 );
 
-                // update orthographic buffer according to new window size
-                let new_uniforms = Uniforms::new(size.width, size.height);
-
-                let new_ortho_buffer =
-                    gpu_device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-                        label: Some("Ortho uniform buffer"),
-                        contents: bytemuck::cast_slice(&[new_uniforms]),
-                        usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_SRC,
-                    });
-
-                // get a command encoder for the current frame
-                let mut encoder =
-                    gpu_device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
-                        label: Some("Resize"),
-                    });
-
-                // overwrite the new buffer over the old one
-                encoder.copy_buffer_to_buffer(
-                    &new_ortho_buffer,
-                    0,
-                    &ortho_buffer,
-                    0,
-                    (std::mem::size_of::<Uniforms>() * vec![new_uniforms].as_slice().len())
-                        as wgpu::BufferAddress,
+                update_ortho_buffer(
+                    size.width,
+                    size.height,
+                    &gpu_device,
+                    &ortho.buffer,
+                    &cmd_queue,
                 );
-
-                cmd_queue.submit(Some(encoder.finish()));
             }
             //Received Character
             Event::WindowEvent {
@@ -260,7 +204,7 @@ fn run_event_loop() -> Result<(), Box<dyn Error>> {
 
                 if rect_buffers.num_rects > 0 {
                     render_pass.set_pipeline(&rect_pipeline);
-                    render_pass.set_bind_group(0, &ortho_bind_group, &[]);
+                    render_pass.set_bind_group(0, &ortho.bind_group, &[]);
                     render_pass.set_vertex_buffer(0, rect_buffers.vertex_buffer.slice(..));
                     render_pass.set_index_buffer(rect_buffers.index_buffer.slice(..));
                     render_pass.draw_indexed(0..rect_buffers.num_rects, 0, 0..1);
@@ -300,41 +244,11 @@ fn run_event_loop() -> Result<(), Box<dyn Error>> {
 fn make_rect_pipeline(
     gpu_device: &wgpu::Device,
     swap_chain_descr: &wgpu::SwapChainDescriptor,
-) -> (wgpu::RenderPipeline, BindGroup, Buffer) {
-    let uniforms = Uniforms::new(swap_chain_descr.width, swap_chain_descr.height);
-
-    // orthographic projection is used to transfrom pixel coords to the coordinate system used by wgpu
-    let ortho_buffer = gpu_device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
-        label: Some("Ortho uniform buffer"),
-        contents: bytemuck::cast_slice(&[uniforms]),
-        usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
-    });
-
-    // bind groups consist of extra resources that are provided to the shaders
-    let ortho_bind_group_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-        entries: &[BindGroupLayoutEntry {
-            binding: 0,
-            visibility: ShaderStage::VERTEX,
-            ty: wgpu::BindingType::UniformBuffer {
-                dynamic: false,
-                min_binding_size: None,
-            },
-            count: None,
-        }],
-        label: Some("Ortho bind group layout"),
-    });
-
-    let ortho_bind_group = gpu_device.create_bind_group(&wgpu::BindGroupDescriptor {
-        layout: &ortho_bind_group_layout,
-        entries: &[wgpu::BindGroupEntry {
-            binding: 0,
-            resource: wgpu::BindingResource::Buffer(ortho_buffer.slice(..)),
-        }],
-        label: Some("Ortho bind group"),
-    });
+) -> (wgpu::RenderPipeline, OrthoResources) {
+    let ortho = init_ortho(swap_chain_descr.width, swap_chain_descr.height, gpu_device);
 
     let pipeline_layout = gpu_device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-        bind_group_layouts: &[&ortho_bind_group_layout],
+        bind_group_layouts: &[&ortho.bind_group_layout],
         push_constant_ranges: &[],
         label: Some("Rectangle pipeline layout"),
     });
@@ -347,7 +261,7 @@ fn make_rect_pipeline(
         wgpu::include_spirv!("shaders/rect.frag.spv"),
     );
 
-    (pipeline, ortho_bind_group, ortho_buffer)
+    (pipeline, ortho)
 }
 
 fn create_render_pipeline(