Jengamon/rexweb - Change HTDZ53HWD4X3DSFZX7MMC7DPFJNHQPGBVLJD2S325SQRRVIQ3CLAC

separate world rendering into middleware pattern

Created by Jengamon on February 6, 2024

HTDZ53HWD4X3DSFZX7MMC7DPFJNHQPGBVLJD2S325SQRRVIQ3CLAC

Dependencies

In channels

main

Change contents

Replacement in src/screen.rs at line 5 [8.51]
∅:D[6.25] → [7.2622:2666]
B:BD[8.51] → [7.2622:2666]
```
use std::{collections::HashMap, sync::Arc};
```
[6.25]
[9.20]
```
use std::sync::Arc;
```
Replacement in src/screen.rs at line 10 [8.51]
B:BD[10.3644] → [11.2830:2871]
B:BD[11.2871] → [7.2700:2723]
∅:D[7.2723] → [11.2871:2898]
B:BD[11.2871] → [11.2871:2898]
```
use encase::{ShaderType, UniformBuffer};
use naga_oil::compose;
use wgpu::util::DeviceExt;
```
[10.3644]
[8.80]
```
use encase::ShaderType;
```

Replacement in src/screen.rs at line 24 [8.51]

B:BD[11.2937] → [11.2937:3072]

    world_texture_view: wgpu::TextureView,
    // world_texture_sampler: wgpu::Sampler,
    world_texture_bind_group: wgpu::BindGroup,

[11.2937]

[9.128]

    // world_texture_view: wgpu::TextureView,
    // // world_texture_sampler: wgpu::Sampler,
    // world_texture_bind_group: wgpu::BindGroup,

Replacement in src/screen.rs at line 28 [8.51]

B:BD[9.129] → [11.3073:3181]

    camera_uniform: CameraUniform,
    camera_buffer: wgpu::Buffer,
    camera_bind_group: wgpu::BindGroup,

[9.129]

[11.3181]

    // camera_uniform: CameraUniform,
    // camera_buffer: wgpu::Buffer,
    // camera_bind_group: wgpu::BindGroup,

Replacement in src/screen.rs at line 32 [8.51]

B:BD[11.3182] → [12.316:405]

    render_options_buffer: wgpu::Buffer,
    render_options_bind_group: wgpu::BindGroup,

[11.3182]

[12.405]

    // render_options_buffer: wgpu::Buffer,
    // render_options_bind_group: wgpu::BindGroup,

Replacement in src/screen.rs at line 35 [8.51]

∅:D[12.406] → [11.3182:3506]

B:BD[11.3182] → [11.3182:3506]

    /// Renders from the world texture to screen space within the bounds of the camera
    // TODO eventually handle screen space effects
    world_render_pipeline: wgpu::RenderPipeline,
    // num_world_vertices: u32,
    num_world_indices: u32,
    world_vertex_buffer: wgpu::Buffer,
    world_index_buffer: wgpu::Buffer,

[12.406]

[11.3506]

    // /// Renders from the world texture to screen space within the bounds of the camera
    // // TODO eventually handle screen space effects
    // world_render_pipeline: wgpu::RenderPipeline,
    // // num_world_vertices: u32,
    // num_world_indices: u32,
    // world_vertex_buffer: wgpu::Buffer,
    // world_index_buffer: wgpu::Buffer,

Insertion in src/screen.rs at line 50 [8.51]
[11.3583]
[11.3583]
```
    world_renderer: middleware::WorldRenderer,
```
Deletion in src/screen.rs at line 170 [8.51]
∅:D[10.3712] → [9.178:181]
∅:D[11.4954] → [9.178:181]
B:BD[9.178] → [9.178:181]
B:BD[9.181] → [11.4955:5079]
```
}
/// Information sent to the shader about our camera
#[derive(ShaderType)]
struct CameraUniform {
    view_proj: glam::Mat4,
```

Deletion in src/screen.rs at line 172 [8.51]

B:BD[11.5082] → [11.5082:5330]

impl CameraUniform {
    fn new() -> Self {
        Self {
            view_proj: glam::Mat4::IDENTITY,
        }
    }
    fn update_view_proj(&mut self, camera: &Camera) {
        self.view_proj = camera.build_view_projection_matrix();
    }
}

Deletion in src/screen.rs at line 201 [8.51]

B:BD[10.4131] → [11.5413:5695]

}
/// Most general type of vertex
/// Specifies a position, then tex coordinates, then an associated color (w/ alpha)
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
    position: [f32; 3],
    tex_coords: [f32; 2],
    color: [f32; 4],

Deletion in src/screen.rs at line 203 [8.51]

B:BD[11.5698] → [11.5698:6664]

∅:D[11.6664] → [10.4131:4134]

B:BD[10.4131] → [10.4131:4134]

impl Vertex {
    fn desc() -> wgpu::VertexBufferLayout<'static> {
        wgpu::VertexBufferLayout {
            array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
            step_mode: wgpu::VertexStepMode::Vertex,
            attributes: &[
                wgpu::VertexAttribute {
                    offset: 0,
                    shader_location: 0,
                    format: wgpu::VertexFormat::Float32x3,
                },
                wgpu::VertexAttribute {
                    offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
                    shader_location: 1,
                    format: wgpu::VertexFormat::Float32x2,
                },
                wgpu::VertexAttribute {
                    offset: std::mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
                    shader_location: 2,
                    format: wgpu::VertexFormat::Float32x4,
                },
            ],
        }
    }
}

Deletion in src/screen.rs at line 204 [8.51]

B:BD[8.386] → [11.6665:6722]

B:BD[11.6722] → [3.387:540]

∅:D[3.540] → [11.6772:6819]

B:BD[11.6772] → [11.6772:6819]

B:BD[11.6819] → [3.541:582]

∅:D[3.582] → [11.6864:6985]

B:BD[11.6864] → [11.6864:6985]

B:BD[11.6985] → [3.583:623]

∅:D[3.623] → [11.7029:7150]

B:BD[11.7029] → [11.7029:7150]

B:BD[11.7150] → [3.624:663]

∅:D[3.663] → [11.7193:7314]

B:BD[11.7193] → [11.7193:7314]

B:BD[11.7314] → [3.664:704]

∅:D[3.704] → [11.7358:7491]

B:BD[11.7358] → [11.7358:7491]

B:BD[11.7491] → [7.2834:3499]

    const INDICES: &'static [u16] = &[0, 2, 3, 0, 1, 2];
    /// `w` and `h` are percentages of the screen to use to render the world, (0.0, 1.0]
    fn generate_world_vertices(w: f32, h: f32) -> Vec<Vertex> {
        let verts = vec![
            Vertex {
                position: [-w, -h, 0.0],
                tex_coords: [0.0, 1.0],
                color: [1.0, 1.0, 1.0, 1.0],
            },
            Vertex {
                position: [w, -h, 0.0],
                tex_coords: [1.0, 1.0],
                color: [1.0, 1.0, 1.0, 1.0],
            },
            Vertex {
                position: [w, h, 0.0],
                tex_coords: [1.0, 0.0],
                color: [1.0, 1.0, 1.0, 1.0],
            },
            Vertex {
                position: [-w, h, 0.0],
                tex_coords: [0.0, 0.0],
                color: [1.0, 1.0, 1.0, 1.0],
            },
        ];
        verts
    }
    fn create_composer(_assets: &AssetCache) -> Result<compose::Composer, compose::ComposerError> {
        let mut composer = compose::Composer::default();
        // HDR module
        let hdr_module_src = include_str!("./hdr.wgsl");
        let (name, imports, shader_defs) = compose::get_preprocessor_data(hdr_module_src);
        composer.add_composable_module(compose::ComposableModuleDescriptor {
            as_name: name,
            source: hdr_module_src,
            file_path: "hdr.wgsl",
            language: compose::ShaderLanguage::Wgsl,
            additional_imports: &imports,
            shader_defs,
        })?;
        Ok(composer)
    }

Deletion in src/screen.rs at line 206 [8.51]
B:BD[8.493] → [11.7492:7552]
```
        let num_world_indices = Self::INDICES.len() as u32;
```

Replacement in src/screen.rs at line 274 [8.51]

B:BD[11.7722] → [11.7722:7723]

B:BD[11.7723] → [7.3953:4013]

B:BD[7.4013] → [3.705:775]

∅:D[3.775] → [11.7785:8055]

B:BD[11.7785] → [11.7785:8055]

B:BD[11.8055] → [3.776:854]

∅:D[3.854] → [11.8102:8754]

B:BD[11.8102] → [11.8102:8754]

B:BD[11.8754] → [7.4014:4056]

∅:D[7.4056] → [11.8868:9468]

B:BD[11.8868] → [11.8868:9468]

B:BD[11.9468] → [4.0:51]

∅:D[4.51] → [11.9519:12698]

∅:D[7.4107] → [11.9519:12698]

B:BD[11.9519] → [11.9519:12698]

B:BD[11.12698] → [12.681:2239]

∅:D[12.2239] → [11.12698:12711]

B:BD[11.12698] → [11.12698:12711]

B:BD[11.12711] → [7.4108:5149]

∅:D[7.5149] → [11.12711:12832]

B:BD[11.12711] → [11.12711:12832]

B:BD[11.12832] → [7.5150:5218]

∅:D[7.5218] → [11.12920:13113]

B:BD[11.12920] → [11.12920:13113]

B:BD[11.13113] → [12.2240:2454]

∅:D[12.2454] → [11.13213:14812]

B:BD[11.13213] → [11.13213:14812]


        let mut composer = Self::create_composer(assets)?;
        let world_vertices = Self::generate_world_vertices(1.0, 1.0);
        // let num_world_vertices = world_vertices.len() as u32;
        let world_vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("world vertex buffer"),
            contents: bytemuck::cast_slice(&world_vertices),
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
        });
        let world_index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("world vertex buffer"),
            contents: bytemuck::cast_slice(Self::INDICES),
            usage: wgpu::BufferUsages::INDEX,
        });
        let world_texture = device.create_texture(&wgpu::TextureDescriptor {
            size: wgpu::Extent3d {
                width: WORLD_HALF_EXTENTS.x * 2,
                height: WORLD_HALF_EXTENTS.y * 2,
                depth_or_array_layers: 1,
            },
            mip_level_count: 1,
            sample_count: 1,
            dimension: wgpu::TextureDimension::D2,
            format: world_texture_format,
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
            label: Some("world texture"),
            view_formats: &[],
        });
        let world_texture_view = world_texture.create_view(&wgpu::TextureViewDescriptor::default());
        let world_texture_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
            address_mode_u: wgpu::AddressMode::ClampToEdge,
            address_mode_v: wgpu::AddressMode::ClampToEdge,
            address_mode_w: wgpu::AddressMode::ClampToEdge,
            mag_filter: wgpu::FilterMode::Nearest,
            min_filter: wgpu::FilterMode::Nearest,
            mipmap_filter: wgpu::FilterMode::Nearest,
            ..Default::default()
        });
        let world_texture_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("world texture bind group layout"),
                entries: &[
                    wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Texture {
                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
                            view_dimension: wgpu::TextureViewDimension::D2,
                            multisampled: false,
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 1,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                        count: None,
                    },
                ],
            });
        let world_texture_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("world texture bind group"),
            layout: &world_texture_bind_group_layout,
            entries: &[
                wgpu::BindGroupEntry {
                    binding: 0,
                    resource: wgpu::BindingResource::TextureView(&world_texture_view),
                },
                wgpu::BindGroupEntry {
                    binding: 1,
                    resource: wgpu::BindingResource::Sampler(&world_texture_sampler),
                },
            ],
        });
        let camera_uniform = CameraUniform::new();
        let mut uniform_buffer = UniformBuffer::new(Vec::new());
        uniform_buffer.write(&camera_uniform).unwrap();
        let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("camera buffer"),
            contents: &uniform_buffer.into_inner(),
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
        });
        let camera_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                label: Some("camera bind group layout"),
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::VERTEX,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                }],
            });
        let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
            layout: &camera_bind_group_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: camera_buffer.as_entire_binding(),
            }],
            label: Some("camera bind group"),
        });
        let render_options = RenderOptions::default();
        let mut render_options_uniform_buffer = UniformBuffer::new(Vec::new());
        render_options_uniform_buffer
            .write(&render_options)
            .unwrap();
        let render_options_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
            label: Some("render options buffer"),
            contents: &render_options_uniform_buffer.into_inner(),
            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
        });
        let render_options_bind_group_layout =
            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                entries: &[wgpu::BindGroupLayoutEntry {
                    binding: 0,
                    visibility: wgpu::ShaderStages::FRAGMENT,
                    ty: wgpu::BindingType::Buffer {
                        ty: wgpu::BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                }],
                label: Some("render options bind group layout"),
            });
        let render_options_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
            label: Some("render options bind group"),
            layout: &render_options_bind_group_layout,
            entries: &[wgpu::BindGroupEntry {
                binding: 0,
                resource: render_options_buffer.as_entire_binding(),
            }],
        });
        // let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
        // label: Some("world shader"),
        // source: wgpu::ShaderSource::Wgsl(include_str!("world_shader.wgsl").into()),
        // });
        let composed_world_shader = composer.make_naga_module(compose::NagaModuleDescriptor {
            source: include_str!("world_shader.wgsl"),
            file_path: "world_shader.wgsl",
            shader_type: compose::ShaderType::Wgsl,
            shader_defs: HashMap::new(),
            additional_imports: &[],
        })?;
        let mut validator = naga::valid::Validator::new(
            naga::valid::ValidationFlags::default(),
            naga::valid::Capabilities::default(),
        );
        let composed_world_shader_module_info = validator.validate(&composed_world_shader)?;
        let shader_source = naga::back::wgsl::write_string(
            &composed_world_shader,
            &composed_world_shader_module_info,
            naga::back::wgsl::WriterFlags::EXPLICIT_TYPES,
        )?;
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("world shader"),
            source: wgpu::ShaderSource::Wgsl(shader_source.into()),
        });
        let world_render_pipeline_layout =
            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                label: Some("world render pipeline layout"),
                bind_group_layouts: &[
                    &world_texture_bind_group_layout,
                    &camera_bind_group_layout,
                    &render_options_bind_group_layout,
                ],
                push_constant_ranges: &[],
            });
        let world_render_pipeline =
            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some("world render pipeline"),
                layout: Some(&world_render_pipeline_layout),
                vertex: wgpu::VertexState {
                    module: &shader,
                    entry_point: "vs_main",
                    buffers: &[Vertex::desc()],
                },
                primitive: wgpu::PrimitiveState {
                    topology: wgpu::PrimitiveTopology::TriangleList,
                    strip_index_format: None,
                    front_face: wgpu::FrontFace::Ccw,
                    cull_mode: Some(wgpu::Face::Back),
                    polygon_mode: wgpu::PolygonMode::Fill,
                    unclipped_depth: false,
                    conservative: false,
                },
                depth_stencil: None,
                multisample: wgpu::MultisampleState {
                    count: 1,
                    mask: !0,
                    alpha_to_coverage_enabled: false,
                },
                fragment: Some(wgpu::FragmentState {
                    module: &shader,
                    entry_point: "fs_main",
                    targets: &[Some(wgpu::ColorTargetState {
                        format: config.format,
                        blend: Some(wgpu::BlendState::REPLACE),
                        write_mask: wgpu::ColorWrites::ALL,
                    })],
                }),
                multiview: None,
            });

[11.7722]

[10.4388]

        let world_renderer =
            middleware::WorldRenderer::new(&device, config.format, world_texture_format, assets)?;

Replacement in src/screen.rs at line 285 [8.51]

B:BD[11.14814] → [11.14814:15073]

B:BD[11.15073] → [12.2455:2529]

∅:D[12.2529] → [11.15073:15205]

B:BD[11.15073] → [11.15073:15205]

            // world_texture,
            world_texture_view,
            // world_texture_sampler,
            world_texture_bind_group,
            camera_uniform,
            camera_buffer,
            camera_bind_group,
            world_render_pipeline,
            render_options_buffer,
            render_options_bind_group,
            // num_world_vertices,
            num_world_indices,
            world_vertex_buffer,
            world_index_buffer,

[11.14814]

[7.5219]

            world_renderer,

Replacement in src/screen.rs at line 344 [8.51]

B:BD[9.828] → [9.828:900]

        let screen_descriptor = egui_wgpu::renderer::ScreenDescriptor {

[9.828]

[9.900]

        let screen_descriptor = egui_wgpu::ScreenDescriptor {

Deletion in src/screen.rs at line 361 [8.51]

B:BD[11.15324] → [11.15324:15325]

B:BD[11.15325] → [13.3401:3448]

B:BD[13.3448] → [3.855:1231]

∅:D[3.1231] → [11.15361:15647]

∅:D[13.3498] → [11.15361:15647]

B:BD[11.15361] → [11.15361:15647]


        // Update the camera and camera buffer
        if let Some((w, h)) = input.camera.update_aspect(&self.window) {
            // Update the world vertex buffer
            let new_world_vertices = Self::generate_world_vertices(w, h);
            self.queue.write_buffer(
                &self.world_vertex_buffer,
                0,
                bytemuck::cast_slice(&new_world_vertices),
            );
        }
        self.camera_uniform.update_view_proj(input.camera);
        let mut uniform_buffer = UniformBuffer::new(Vec::new());
        uniform_buffer.write(&self.camera_uniform).unwrap();
        self.queue
            .write_buffer(&self.camera_buffer, 0, &uniform_buffer.into_inner());

Deletion in src/screen.rs at line 362 [8.51]

B:BD[12.2531] → [12.2531:2798]

∅:D[12.2798] → [11.15647:15648]

B:BD[11.15647] → [11.15647:15648]

        // Update render options
        let mut uniform_buffer = UniformBuffer::new(Vec::new());
        uniform_buffer.write(input.render_options).unwrap();
        self.queue
            .write_buffer(&self.render_options_buffer, 0, &uniform_buffer.into_inner());

Replacement in src/screen.rs at line 398 [8.51]

B:BD[11.17288] → [11.17288:17340]

                    view: &self.world_texture_view,

[11.17288]

[11.17340]

                    view: self.world_renderer.world_texture_view(),

Insertion in src/screen.rs at line 450 [8.51]

[10.6693]

[9.1409]

        let world_renderer_data = self.world_renderer.prepare(
            &self.device,
            &self.queue,
            &self.window,
            input.camera,
            input.render_options,
        );

Replacement in src/screen.rs at line 480 [8.51]

B:BD[10.6746] → [11.18402:18640]

B:BD[11.18640] → [12.2799:2886]

∅:D[12.2886] → [11.18640:18935]

B:BD[11.18640] → [11.18640:18935]

            final_render_pass.set_pipeline(&self.world_render_pipeline);
            final_render_pass.set_bind_group(0, &self.world_texture_bind_group, &[]);
            final_render_pass.set_bind_group(1, &self.camera_bind_group, &[]);
            final_render_pass.set_bind_group(2, &self.render_options_bind_group, &[]);
            final_render_pass.set_vertex_buffer(0, self.world_vertex_buffer.slice(..));
            final_render_pass
                .set_index_buffer(self.world_index_buffer.slice(..), wgpu::IndexFormat::Uint16);
            final_render_pass.draw_indexed(0..self.num_world_indices, 0, 0..1);

[10.6746]

[11.18935]

            self.world_renderer
                .render(&mut final_render_pass, &world_renderer_data);

Insertion in src/screen/middleware.rs at line 1 [12.2925]
[12.2925]
[5.0]
```
pub use world::WorldRenderer;
```

Replacement in src/screen/middleware.rs at line 4 [12.2925]

B:BD[5.82] → [5.82:190]

#[allow(dead_code)]
pub mod world {
    pub struct WorldRenderer {}
    pub type WorldRenderFrameData = ();

[5.82]

[5.190]

mod world {
    use std::collections::HashMap;
    use assets_manager::AssetCache;
    use encase::{ShaderType, UniformBuffer};
    use naga_oil::compose;
    use wgpu::util::DeviceExt;
    use winit::window::Window;
    use crate::screen::{Camera, RenderOptions, WORLD_HALF_EXTENTS};
    /// Information sent to the shader about our camera
    #[derive(ShaderType)]
    struct CameraUniform {
        view_proj: glam::Mat4,
    }
    impl CameraUniform {
        fn new() -> Self {
            Self {
                view_proj: glam::Mat4::IDENTITY,
            }
        }
        fn update_view_proj(&mut self, camera: &Camera) {
            self.view_proj = camera.build_view_projection_matrix();
        }
    }
    pub struct WorldRenderer {
        // world_texture: wgpu::Texture,
        world_texture_view: wgpu::TextureView,
        // world_texture_sampler: wgpu::Sampler,
        world_texture_bind_group: wgpu::BindGroup,
        camera_uniform: CameraUniform,
        camera_buffer: wgpu::Buffer,
        camera_bind_group: wgpu::BindGroup,
        render_options_buffer: wgpu::Buffer,
        render_options_bind_group: wgpu::BindGroup,
        /// Renders from the world texture to screen space within the bounds of the camera
        // TODO eventually handle screen space effects
        world_render_pipeline: wgpu::RenderPipeline,
        // num_world_vertices: u32,
        num_world_indices: u32,
        world_vertex_buffer: wgpu::Buffer,
        world_index_buffer: wgpu::Buffer,
    }
    pub struct WorldRenderFrameData {}
    /// Most general type of vertex
    /// Specifies a position, then tex coordinates, then an associated color (w/ alpha)
    #[repr(C)]
    #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
    struct Vertex {
        position: [f32; 3],
        tex_coords: [f32; 2],
        color: [f32; 4],
    }
    impl Vertex {
        fn desc() -> wgpu::VertexBufferLayout<'static> {
            wgpu::VertexBufferLayout {
                array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,
                step_mode: wgpu::VertexStepMode::Vertex,
                attributes: &[
                    wgpu::VertexAttribute {
                        offset: 0,
                        shader_location: 0,
                        format: wgpu::VertexFormat::Float32x3,
                    },
                    wgpu::VertexAttribute {
                        offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
                        shader_location: 1,
                        format: wgpu::VertexFormat::Float32x2,
                    },
                    wgpu::VertexAttribute {
                        offset: std::mem::size_of::<[f32; 5]>() as wgpu::BufferAddress,
                        shader_location: 2,
                        format: wgpu::VertexFormat::Float32x4,
                    },
                ],
            }
        }
    }

Replacement in src/screen/middleware.rs at line 94 [12.2925]

B:BD[5.216] → [5.216:301]

        fn new(device: &wgpu::Device, texture_format: wgpu::TextureFormat) -> Self {

[5.216]

[5.301]

        const INDICES: &'static [u16] = &[0, 2, 3, 0, 1, 2];
        /// `w` and `h` are percentages of the screen to use to render the world, (0.0, 1.0]
        fn generate_world_vertices(w: f32, h: f32) -> Vec<Vertex> {
            let verts = vec![
                Vertex {
                    position: [-w, -h, 0.0],
                    tex_coords: [0.0, 1.0],
                    color: [1.0, 1.0, 1.0, 1.0],
                },
                Vertex {
                    position: [w, -h, 0.0],
                    tex_coords: [1.0, 1.0],
                    color: [1.0, 1.0, 1.0, 1.0],
                },
                Vertex {
                    position: [w, h, 0.0],
                    tex_coords: [1.0, 0.0],
                    color: [1.0, 1.0, 1.0, 1.0],
                },
                Vertex {
                    position: [-w, h, 0.0],
                    tex_coords: [0.0, 0.0],
                    color: [1.0, 1.0, 1.0, 1.0],
                },
            ];
            verts
        }
        fn create_composer(
            _assets: &AssetCache,
        ) -> Result<compose::Composer, compose::ComposerError> {
            let mut composer = compose::Composer::default();
            // HDR module
            let hdr_module_src = include_str!("../hdr.wgsl");
            let (name, imports, shader_defs) = compose::get_preprocessor_data(hdr_module_src);
            composer.add_composable_module(compose::ComposableModuleDescriptor {
                as_name: name,
                source: hdr_module_src,
                file_path: "hdr.wgsl",
                language: compose::ShaderLanguage::Wgsl,
                additional_imports: &imports,
                shader_defs,
            })?;
            Ok(composer)
        }
        pub fn world_texture_view(&self) -> &wgpu::TextureView {
            &self.world_texture_view
        }
        pub fn new(
            device: &wgpu::Device,
            texture_format: wgpu::TextureFormat,
            world_texture_format: wgpu::TextureFormat,
            assets: &AssetCache,
        ) -> color_eyre::Result<Self> {

Replacement in src/screen/middleware.rs at line 155 [12.2925]

B:BD[5.365] → [5.365:385]

            Self {}

[5.365]

[5.385]

            let num_world_indices = Self::INDICES.len() as u32;
            let mut composer = Self::create_composer(assets)?;
            let world_vertices = Self::generate_world_vertices(1.0, 1.0);
            // let num_world_vertices = world_vertices.len() as u32;
            let world_vertex_buffer =
                device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                    label: Some("world vertex buffer"),
                    contents: bytemuck::cast_slice(&world_vertices),
                    usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                });
            let world_index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("world vertex buffer"),
                contents: bytemuck::cast_slice(Self::INDICES),
                usage: wgpu::BufferUsages::INDEX,
            });
            let world_texture = device.create_texture(&wgpu::TextureDescriptor {
                size: wgpu::Extent3d {
                    width: WORLD_HALF_EXTENTS.x * 2,
                    height: WORLD_HALF_EXTENTS.y * 2,
                    depth_or_array_layers: 1,
                },
                mip_level_count: 1,
                sample_count: 1,
                dimension: wgpu::TextureDimension::D2,
                format: world_texture_format,
                usage: wgpu::TextureUsages::RENDER_ATTACHMENT
                    | wgpu::TextureUsages::TEXTURE_BINDING,
                label: Some("world texture"),
                view_formats: &[],
            });
            let world_texture_view =
                world_texture.create_view(&wgpu::TextureViewDescriptor::default());
            let world_texture_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
                address_mode_u: wgpu::AddressMode::ClampToEdge,
                address_mode_v: wgpu::AddressMode::ClampToEdge,
                address_mode_w: wgpu::AddressMode::ClampToEdge,
                mag_filter: wgpu::FilterMode::Nearest,
                min_filter: wgpu::FilterMode::Nearest,
                mipmap_filter: wgpu::FilterMode::Nearest,
                ..Default::default()
            });
            let world_texture_bind_group_layout =
                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    label: Some("world texture bind group layout"),
                    entries: &[
                        wgpu::BindGroupLayoutEntry {
                            binding: 0,
                            visibility: wgpu::ShaderStages::FRAGMENT,
                            ty: wgpu::BindingType::Texture {
                                sample_type: wgpu::TextureSampleType::Float { filterable: true },
                                view_dimension: wgpu::TextureViewDimension::D2,
                                multisampled: false,
                            },
                            count: None,
                        },
                        wgpu::BindGroupLayoutEntry {
                            binding: 1,
                            visibility: wgpu::ShaderStages::FRAGMENT,
                            ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
                            count: None,
                        },
                    ],
                });
            let world_texture_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("world texture bind group"),
                layout: &world_texture_bind_group_layout,
                entries: &[
                    wgpu::BindGroupEntry {
                        binding: 0,
                        resource: wgpu::BindingResource::TextureView(&world_texture_view),
                    },
                    wgpu::BindGroupEntry {
                        binding: 1,
                        resource: wgpu::BindingResource::Sampler(&world_texture_sampler),
                    },
                ],
            });
            let camera_uniform = CameraUniform::new();
            let mut uniform_buffer = UniformBuffer::new(Vec::new());
            uniform_buffer.write(&camera_uniform).unwrap();
            let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("camera buffer"),
                contents: &uniform_buffer.into_inner(),
                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            });
            let camera_bind_group_layout =
                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    label: Some("camera bind group layout"),
                    entries: &[wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::VERTEX,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    }],
                });
            let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
                layout: &camera_bind_group_layout,
                entries: &[wgpu::BindGroupEntry {
                    binding: 0,
                    resource: camera_buffer.as_entire_binding(),
                }],
                label: Some("camera bind group"),
            });
            let render_options = RenderOptions::default();
            let mut render_options_uniform_buffer = UniformBuffer::new(Vec::new());
            render_options_uniform_buffer
                .write(&render_options)
                .unwrap();
            let render_options_buffer =
                device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                    label: Some("render options buffer"),
                    contents: &render_options_uniform_buffer.into_inner(),
                    usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
                });
            let render_options_bind_group_layout =
                device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
                    entries: &[wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: None,
                        },
                        count: None,
                    }],
                    label: Some("render options bind group layout"),
                });
            let render_options_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
                label: Some("render options bind group"),
                layout: &render_options_bind_group_layout,
                entries: &[wgpu::BindGroupEntry {
                    binding: 0,
                    resource: render_options_buffer.as_entire_binding(),
                }],
            });
            // let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            // label: Some("world shader"),
            // source: wgpu::ShaderSource::Wgsl(include_str!("world_shader.wgsl").into()),
            // });
            let composed_world_shader =
                composer.make_naga_module(compose::NagaModuleDescriptor {
                    source: include_str!("../world_shader.wgsl"),
                    file_path: "world_shader.wgsl",
                    shader_type: compose::ShaderType::Wgsl,
                    shader_defs: HashMap::new(),
                    additional_imports: &[],
                })?;
            let mut validator = naga::valid::Validator::new(
                naga::valid::ValidationFlags::default(),
                naga::valid::Capabilities::default(),
            );
            let composed_world_shader_module_info = validator.validate(&composed_world_shader)?;
            let shader_source = naga::back::wgsl::write_string(
                &composed_world_shader,
                &composed_world_shader_module_info,
                naga::back::wgsl::WriterFlags::EXPLICIT_TYPES,
            )?;
            let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
                label: Some("world shader"),
                source: wgpu::ShaderSource::Wgsl(shader_source.into()),
            });
            let world_render_pipeline_layout =
                device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
                    label: Some("world render pipeline layout"),
                    bind_group_layouts: &[
                        &world_texture_bind_group_layout,
                        &camera_bind_group_layout,
                        &render_options_bind_group_layout,
                    ],
                    push_constant_ranges: &[],
                });
            let world_render_pipeline =
                device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                    label: Some("world render pipeline"),
                    layout: Some(&world_render_pipeline_layout),
                    vertex: wgpu::VertexState {
                        module: &shader,
                        entry_point: "vs_main",
                        buffers: &[Vertex::desc()],
                    },
                    primitive: wgpu::PrimitiveState {
                        topology: wgpu::PrimitiveTopology::TriangleList,
                        strip_index_format: None,
                        front_face: wgpu::FrontFace::Ccw,
                        cull_mode: Some(wgpu::Face::Back),
                        polygon_mode: wgpu::PolygonMode::Fill,
                        unclipped_depth: false,
                        conservative: false,
                    },
                    depth_stencil: None,
                    multisample: wgpu::MultisampleState {
                        count: 1,
                        mask: !0,
                        alpha_to_coverage_enabled: false,
                    },
                    fragment: Some(wgpu::FragmentState {
                        module: &shader,
                        entry_point: "fs_main",
                        targets: &[Some(wgpu::ColorTargetState {
                            format: texture_format,
                            blend: Some(wgpu::BlendState::REPLACE),
                            write_mask: wgpu::ColorWrites::ALL,
                        })],
                    }),
                    multiview: None,
                });
            Ok(Self {
                world_texture_view,
                world_texture_bind_group,
                camera_uniform,
                camera_buffer,
                camera_bind_group,
                render_options_buffer,
                render_options_bind_group,
                world_render_pipeline,
                num_world_indices,
                world_vertex_buffer,
                world_index_buffer,
            })

Replacement in src/screen/middleware.rs at line 387 [12.2925]

B:BD[5.396] → [5.396:472]

        fn prepare(&mut self) -> WorldRenderFrameData {
            todo!()

[5.396]

[5.472]

        pub fn prepare(
            &mut self,
            _device: &wgpu::Device,
            queue: &wgpu::Queue,
            window: &Window,
            camera: &mut Camera,
            render_options: &RenderOptions,
        ) -> WorldRenderFrameData {
            if let Some((w, h)) = camera.update_aspect(window) {
                // Update the world vertex buffer
                let new_world_vertices = Self::generate_world_vertices(w, h);
                queue.write_buffer(
                    &self.world_vertex_buffer,
                    0,
                    bytemuck::cast_slice(&new_world_vertices),
                );
            }
            // Update the camera and camera buffer
            self.camera_uniform.update_view_proj(camera);
            let mut uniform_buffer = UniformBuffer::new(Vec::new());
            uniform_buffer.write(&self.camera_uniform).unwrap();
            queue.write_buffer(&self.camera_buffer, 0, &uniform_buffer.into_inner());
            // Update render options
            let mut uniform_buffer = UniformBuffer::new(Vec::new());
            uniform_buffer.write(render_options).unwrap();
            queue.write_buffer(&self.render_options_buffer, 0, &uniform_buffer.into_inner());
            WorldRenderFrameData {}

Replacement in src/screen/middleware.rs at line 419 [12.2925]
B:BD[5.483] → [5.483:510]
```
        fn render<'rpass>(
```
[5.483]
[5.510]
```
        pub fn render<'rpass>(
```

Replacement in src/screen/middleware.rs at line 422 [12.2925]

B:BD[5.592] → [5.592:647]

            render_data: &'rpass WorldRenderFrameData,

[5.592]

[5.647]

            _render_data: &'rpass WorldRenderFrameData,

Replacement in src/screen/middleware.rs at line 424 [12.2925]

B:BD[5.659] → [5.659:725]

            let _ = render_pass;
            let _ = render_data;

[5.659]

[5.725]

            render_pass.set_pipeline(&self.world_render_pipeline);
            render_pass.set_bind_group(0, &self.world_texture_bind_group, &[]);
            render_pass.set_bind_group(1, &self.camera_bind_group, &[]);
            render_pass.set_bind_group(2, &self.render_options_bind_group, &[]);
            render_pass.set_vertex_buffer(0, self.world_vertex_buffer.slice(..));
            render_pass
                .set_index_buffer(self.world_index_buffer.slice(..), wgpu::IndexFormat::Uint16);
            render_pass.draw_indexed(0..self.num_world_indices, 0, 0..1);

Replacement in Cargo.toml at line 13 [8.12025]

B:BD[8.12308] → [9.7126:7209]

egui = "0.26.0-alpha.2"
egui-wgpu = "0.26.0-alpha.2"
egui-winit = "0.26.0-alpha.2"

[8.12308]

[11.20222]

egui = "0.26.0"
egui-wgpu = "0.26.0"
egui-winit = "0.26.0"

Replacement in Cargo.lock at line 271 [8.12974]
B:BD[8.19514] → [2.197:216]
```
version = "0.69.3"
```
[8.19514]
[8.19533]
```
version = "0.69.4"
```

Replacement in Cargo.lock at line 273 [8.12974]

B:BD[8.19598] → [2.217:295]

checksum = "4f78d23540ba24a8aa93dc51300b6fc9c9c82cd3a31c2c7b4f834578d1705378"

[8.19598]

[8.19676]

checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"

Insertion in Cargo.lock at line 813 [8.12974]

[8.36334]

]
[[package]]
name = "document-features"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef5282ad69563b5fc40319526ba27e0e7363d552a896f0297d54f767717f9b95"
dependencies = [
 "litrs",

Replacement in Cargo.lock at line 832 [8.12974]
B:BD[8.36841] → [9.8444:8471]
```
version = "0.26.0-alpha.2"
```
[8.36841]
[8.36860]
```
version = "0.26.0"
```

Replacement in Cargo.lock at line 834 [8.12974]

B:BD[8.36925] → [9.8472:8550]

checksum = "4fe3dbfdd558f843ae73a7a121aabfe2b738328b6cbb5cd156107f85092d249a"

[8.36925]

[8.37003]

checksum = "169a0e42e2b3d0f663e100f5c10710ffdb9748f7e7565305ecc09044d59e0fbd"

Replacement in Cargo.lock at line 841 [8.12974]
B:BD[8.37062] → [9.8551:8578]
```
version = "0.26.0-alpha.2"
```
[8.37062]
[8.37081]
```
version = "0.26.0"
```

Replacement in Cargo.lock at line 843 [8.12974]

B:BD[8.37146] → [9.8579:8657]

checksum = "646b98fbc5dfd80dec07d41baf00e4a3012e458e22969109e63b1db05b041927"

[8.37146]

[8.37224]

checksum = "5493685c2ca33e06b5ad45ae304b13bc084c395f422268bff1377633552f69ac"

Replacement in Cargo.lock at line 853 [8.12974]
B:BD[8.37322] → [9.8658:8685]
```
version = "0.26.0-alpha.2"
```
[8.37322]
[8.37341]
```
version = "0.26.0"
```

Replacement in Cargo.lock at line 855 [8.12974]

B:BD[8.37406] → [9.8686:8764]

checksum = "2b9a61c42d72a4abb7e90f54f7d68113c9540fc3972673a9110e2b55712687bb"

[8.37406]

[8.37484]

checksum = "094ce3408f61ead0747b506aeb9e3fa9adbd5d937096a26dfbee24387bce8b3a"

Insertion in Cargo.lock at line 858 [8.12974]
[8.37514]
[8.37514]
```
 "document-features",
```
Replacement in Cargo.lock at line 870 [8.12974]
B:BD[8.37620] → [9.8788:8815]
```
version = "0.26.0-alpha.2"
```
[8.37620]
[8.37639]
```
version = "0.26.0"
```

Replacement in Cargo.lock at line 872 [8.12974]

B:BD[8.37704] → [9.8816:8894]

checksum = "8618754bac7bd49df4a57344cc0ccb4fe8e62126dce12ffb7f6c283d1015e000"

[8.37704]

[8.37782]

checksum = "d85f8f89d6a937535e164a5bd6e31719fd7db01bc188d7b59425414b160a2ee1"

Replacement in Cargo.lock at line 892 [8.12974]
B:BD[8.38143] → [9.8935:8962]
```
version = "0.26.0-alpha.2"
```
[8.38143]
[8.38162]
```
version = "0.26.0"
```

Replacement in Cargo.lock at line 894 [8.12974]

B:BD[8.38227] → [9.8963:9041]

checksum = "7045913a3b06a9a8e298e281f7d9247025e5cc13b21787c6a2561fd555dd6735"

[8.38227]

[8.38305]

checksum = "6ba2475f57a416ce2a05e557f3d18e465c7aef23f3f6da2252b428eaaaaa6a65"

Replacement in Cargo.lock at line 955 [8.12974]
B:BD[8.38868] → [9.9042:9069]
```
version = "0.26.0-alpha.2"
```
[8.38868]
[8.38887]
```
version = "0.26.0"
```

Replacement in Cargo.lock at line 957 [8.12974]

B:BD[8.38952] → [9.9070:9148]

checksum = "cecbf377648fc603a8a7abed354b5a09a9770430a0d3aa7a61e1189baed91f4b"

[8.38952]

[8.39030]

checksum = "b823734a8b7e81302a5f1a8ba041ab4ed7805a43d8dfec4dac0c72b933699bbc"

Replacement in Cargo.lock at line 1016 [8.12974]
B:BD[8.40538] → [8.40538:40557]
```
version = "1.71.0"
```
[8.40538]
[8.40557]
```
version = "1.72.0"
```

Replacement in Cargo.lock at line 1018 [8.12974]

B:BD[8.40622] → [8.40622:40700]

checksum = "832a761f35ab3e6664babfbdc6cef35a4860e816ec3916dcfd0882954e98a8a8"

[8.40622]

[8.40700]

checksum = "887d93f60543e9a9362ef8a21beedd0a833c5d9610e18c67abe15a5963dcb1a4"

Replacement in Cargo.lock at line 1354 [8.12974]
B:BD[8.50979] → [8.50979:50997]
```
version = "2.2.1"
```
[8.50979]
[8.50997]
```
version = "2.3.1"
```

Replacement in Cargo.lock at line 1356 [8.12974]

B:BD[8.51062] → [8.51062:51140]

checksum = "02b4af3693f1b705df946e9fe5631932443781d0aabb423b62fcd4d73f6d2fd0"

[8.51062]

[8.51140]

checksum = "bc52e53916c08643f1b56ec082790d1e86a32e58dc5268f897f313fbae7b4872"

Insertion in Cargo.lock at line 1358 [8.12974]
[8.51157]
[8.51157]
```
 "cfg-if",
```
Replacement in Cargo.lock at line 1399 [8.12974]
B:BD[8.52414] → [14.2052:2070]
```
version = "0.3.4"
```
[8.52414]
[8.52432]
```
version = "0.3.5"
```

Replacement in Cargo.lock at line 1401 [8.12974]

B:BD[8.52497] → [14.2071:2149]

checksum = "5d3d0e0f38255e7fa3cf31335b3a56f05febd18025f4db5ef7a0cfb4f8da651f"

[8.52497]

[8.52575]

checksum = "d0c62115964e08cb8039170eb33c1d0e2388a256930279edca206fff675f82c3"

Replacement in Cargo.lock at line 1601 [8.12974]
B:BD[8.57334] → [8.57334:57353]
```
version = "0.3.67"
```
[8.57334]
[8.57353]
```
version = "0.3.68"
```

Replacement in Cargo.lock at line 1603 [8.12974]

B:BD[8.57418] → [8.57418:57496]

checksum = "9a1d36f1235bc969acba30b7f5990b864423a6068a10f7c90ae8f0112e3a59d1"

[8.57418]

[8.57496]

checksum = "406cda4b368d531c842222cf9d2600a9a4acce8d29423695379c6868a143a9ee"

Insertion in Cargo.lock at line 1729 [8.12974]

[8.60634]

name = "litrs"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
[[package]]

Replacement in Cargo.lock at line 2290 [8.12974]
B:BD[8.78625] → [8.78625:78643]
```
version = "3.3.2"
```
[8.78625]
[8.78643]
```
version = "3.4.0"
```

Replacement in Cargo.lock at line 2292 [8.12974]

B:BD[8.78708] → [8.78708:78786]

checksum = "545c980a3880efd47b2e262f6a4bb6daad6555cf3367aa9c4e52895f69537a41"

[8.78708]

[8.78786]

checksum = "30054e72317ab98eddd8561db0f6524df3367636884b7b21b703e4b280a84a14"

Replacement in Cargo.lock at line 2509 [8.12974]
B:BD[14.4931] → [14.4931:4950]
```
version = "0.15.2"
```
[14.4931]
[14.4950]
```
version = "0.15.3"
```

Replacement in Cargo.lock at line 2511 [8.12974]

B:BD[14.5015] → [14.5015:5093]

checksum = "7555e052e772f964a1c99f1434f6a2c3a47a5f8e4292236921f121a7753cb2b5"

[14.5015]

[14.5093]

checksum = "a1362980db95801b70031dd592dc052a44b1810ca9da8fbcf7b25983f3174ed0"

Replacement in Cargo.lock at line 3114 [8.12974]
B:BD[8.99778] → [8.99778:99797]
```
version = "0.11.3"
```
[8.99778]
[8.99797]
```
version = "0.11.4"
```

Replacement in Cargo.lock at line 3116 [8.12974]

B:BD[8.99862] → [8.99862:99940]

checksum = "b6a067b809476893fce6a254cf285850ff69c847e6cfbade6a20b655b6c7e80d"

[8.99862]

[8.99940]

checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"

Replacement in Cargo.lock at line 3128 [8.12974]
B:BD[8.100587] → [8.100587:100606]
```
version = "0.11.3"
```
[8.100587]
[8.100606]
```
version = "0.11.4"
```

Replacement in Cargo.lock at line 3130 [8.12974]

B:BD[8.100671] → [8.100671:100749]

checksum = "5de35e8a90052baaaf61f171680ac2f8e925a1e43ea9d2e3a00514772250e541"

[8.100671]

[8.100749]

checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"

Replacement in Cargo.lock at line 3385 [8.12974]
B:BD[8.107556] → [8.107556:107575]
```
version = "0.2.90"
```
[8.107556]
[8.107575]
```
version = "0.2.91"
```

Replacement in Cargo.lock at line 3387 [8.12974]

B:BD[8.107640] → [8.107640:107718]

checksum = "b1223296a201415c7fad14792dbefaace9bd52b62d33453ade1c5b5f07555406"

[8.107640]

[8.107718]

checksum = "c1e124130aee3fb58c5bdd6b639a0509486b0338acaaae0c84a5124b0f588b7f"

Replacement in Cargo.lock at line 3395 [8.12974]
B:BD[8.107814] → [8.107814:107833]
```
version = "0.2.90"
```
[8.107814]
[8.107833]
```
version = "0.2.91"
```

Replacement in Cargo.lock at line 3397 [8.12974]

B:BD[8.107898] → [8.107898:107976]

checksum = "fcdc935b63408d58a32f8cc9738a0bffd8f05cc7c002086c6ef20b7312ad9dcd"

[8.107898]

[8.107976]

checksum = "c9e7e1900c352b609c8488ad12639a311045f40a35491fb69ba8c12f758af70b"

Replacement in Cargo.lock at line 3410 [8.12974]
B:BD[8.108137] → [8.108137:108156]
```
version = "0.4.40"
```
[8.108137]
[8.108156]
```
version = "0.4.41"
```

Replacement in Cargo.lock at line 3412 [8.12974]

B:BD[8.108221] → [8.108221:108299]

checksum = "bde2032aeb86bdfaecc8b261eef3cba735cc426c1f3a3416d1e0791be95fc461"

[8.108221]

[8.108299]

checksum = "877b9c3f61ceea0e56331985743b13f3d25c406a7098d45180fb5f09bc19ed97"

Replacement in Cargo.lock at line 3422 [8.12974]
B:BD[8.108410] → [8.108410:108429]
```
version = "0.2.90"
```
[8.108410]
[8.108429]
```
version = "0.2.91"
```

Replacement in Cargo.lock at line 3424 [8.12974]

B:BD[8.108494] → [8.108494:108572]

checksum = "3e4c238561b2d428924c49815533a8b9121c664599558a5d9ec51f8a1740a999"

[8.108494]

[8.108572]

checksum = "b30af9e2d358182b5c7449424f017eba305ed32a7010509ede96cdc4696c46ed"

Replacement in Cargo.lock at line 3432 [8.12974]
B:BD[8.108681] → [8.108681:108700]
```
version = "0.2.90"
```
[8.108681]
[8.108700]
```
version = "0.2.91"
```

Replacement in Cargo.lock at line 3434 [8.12974]

B:BD[8.108765] → [8.108765:108843]

checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"

[8.108765]

[8.108843]

checksum = "642f325be6301eb8107a83d12a8ac6c1e1c54345a7ef1a9261962dfefda09e66"

Replacement in Cargo.lock at line 3445 [8.12974]
B:BD[8.108994] → [8.108994:109013]
```
version = "0.2.90"
```
[8.108994]
[8.109013]
```
version = "0.2.91"
```

Replacement in Cargo.lock at line 3447 [8.12974]

B:BD[8.109078] → [8.109078:109156]

checksum = "4d91413b1c31d7539ba5ef2451af3f0b833a005eb27a631cec32bc0635a8602b"

[8.109078]

[8.109156]

checksum = "4f186bd2dcf04330886ce82d6f33dd75a7bfcf69ecf5763b89fcde53b6ac9838"

Replacement in Cargo.lock at line 3560 [8.12974]
B:BD[8.113605] → [9.10586:10605]
```
version = "0.3.67"
```
[8.113605]
[8.113624]
```
version = "0.3.68"
```

Replacement in Cargo.lock at line 3562 [8.12974]

B:BD[8.113689] → [9.10606:10684]

checksum = "58cd2333b6e0be7a39605f0e255892fd7418a682d8da8fe042fe25128794d2ed"

[8.113689]

[8.113767]

checksum = "96565907687f7aceb35bc5fc03770a8a0471d82e479f25832f54a0e3f4b28446"

Replacement in Cargo.lock at line 4039 [8.12974]
B:BD[8.130672] → [14.8309:8328]
```
version = "0.5.37"
```
[8.130672]
[8.130691]
```
version = "0.5.39"
```

Replacement in Cargo.lock at line 4041 [8.12974]

B:BD[8.130756] → [14.8329:8407]

checksum = "a7cad8365489051ae9f054164e459304af2e7e9bb407c958076c8bf4aef52da5"

[8.130756]

[8.130834]

checksum = "5389a154b01683d28c77f8f68f49dea75f0a4da32557a58f68ee51ebba472d29"

separate world rendering into middleware pattern

Dependencies

In channels

Change contents

Replacement in src/screen.rs at line 5 [8.51]

Replacement in src/screen.rs at line 10 [8.51]

Replacement in src/screen.rs at line 24 [8.51]

Replacement in src/screen.rs at line 28 [8.51]

Replacement in src/screen.rs at line 32 [8.51]

Replacement in src/screen.rs at line 35 [8.51]

Insertion in src/screen.rs at line 50 [8.51]

Deletion in src/screen.rs at line 170 [8.51]

Deletion in src/screen.rs at line 172 [8.51]

Deletion in src/screen.rs at line 201 [8.51]

Deletion in src/screen.rs at line 203 [8.51]

Deletion in src/screen.rs at line 204 [8.51]

Deletion in src/screen.rs at line 206 [8.51]

Replacement in src/screen.rs at line 274 [8.51]

Replacement in src/screen.rs at line 285 [8.51]

Replacement in src/screen.rs at line 344 [8.51]

Deletion in src/screen.rs at line 361 [8.51]

Deletion in src/screen.rs at line 362 [8.51]

Replacement in src/screen.rs at line 398 [8.51]

Insertion in src/screen.rs at line 450 [8.51]

Replacement in src/screen.rs at line 480 [8.51]

Insertion in src/screen/middleware.rs at line 1 [12.2925]

Replacement in src/screen/middleware.rs at line 4 [12.2925]

Replacement in src/screen/middleware.rs at line 94 [12.2925]

Replacement in src/screen/middleware.rs at line 155 [12.2925]

Replacement in src/screen/middleware.rs at line 387 [12.2925]

Replacement in src/screen/middleware.rs at line 419 [12.2925]

Replacement in src/screen/middleware.rs at line 422 [12.2925]

Replacement in src/screen/middleware.rs at line 424 [12.2925]

Replacement in Cargo.toml at line 13 [8.12025]

Replacement in Cargo.lock at line 271 [8.12974]

Replacement in Cargo.lock at line 273 [8.12974]

Insertion in Cargo.lock at line 813 [8.12974]

Replacement in Cargo.lock at line 832 [8.12974]

Replacement in Cargo.lock at line 834 [8.12974]

Replacement in Cargo.lock at line 841 [8.12974]

Replacement in Cargo.lock at line 843 [8.12974]

Replacement in Cargo.lock at line 853 [8.12974]

Replacement in Cargo.lock at line 855 [8.12974]

Insertion in Cargo.lock at line 858 [8.12974]

Replacement in Cargo.lock at line 870 [8.12974]

Replacement in Cargo.lock at line 872 [8.12974]

Replacement in Cargo.lock at line 892 [8.12974]

Replacement in Cargo.lock at line 894 [8.12974]

Replacement in Cargo.lock at line 955 [8.12974]

Replacement in Cargo.lock at line 957 [8.12974]

Replacement in Cargo.lock at line 1016 [8.12974]

Replacement in Cargo.lock at line 1018 [8.12974]

Replacement in Cargo.lock at line 1354 [8.12974]

Replacement in Cargo.lock at line 1356 [8.12974]

Insertion in Cargo.lock at line 1358 [8.12974]

Replacement in Cargo.lock at line 1399 [8.12974]

Replacement in Cargo.lock at line 1401 [8.12974]

Replacement in Cargo.lock at line 1601 [8.12974]

Replacement in Cargo.lock at line 1603 [8.12974]

Insertion in Cargo.lock at line 1729 [8.12974]

Replacement in Cargo.lock at line 2290 [8.12974]

Replacement in Cargo.lock at line 2292 [8.12974]

Replacement in Cargo.lock at line 2509 [8.12974]

Replacement in Cargo.lock at line 2511 [8.12974]

Replacement in Cargo.lock at line 3114 [8.12974]

Replacement in Cargo.lock at line 3116 [8.12974]

Replacement in Cargo.lock at line 3128 [8.12974]

Replacement in Cargo.lock at line 3130 [8.12974]

Replacement in Cargo.lock at line 3385 [8.12974]

Replacement in Cargo.lock at line 3387 [8.12974]

Replacement in Cargo.lock at line 3395 [8.12974]

Replacement in Cargo.lock at line 3397 [8.12974]

Replacement in Cargo.lock at line 3410 [8.12974]

Replacement in Cargo.lock at line 3412 [8.12974]

Replacement in Cargo.lock at line 3422 [8.12974]

Replacement in Cargo.lock at line 3424 [8.12974]

Replacement in Cargo.lock at line 3432 [8.12974]

Replacement in Cargo.lock at line 3434 [8.12974]

Replacement in Cargo.lock at line 3445 [8.12974]

Replacement in Cargo.lock at line 3447 [8.12974]