You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: compositor.rs
    path of file: ./repos/rerun/crates/re_renderer/src/renderer
    
    the code of the file until where you have to start completion: use crate::{
    allocator::create_and_fill_uniform_buffer,
    include_shader_module,
    renderer::{screen_triangle_vertex_shader, DrawData, DrawError, Renderer},
    view_builder::ViewBuilder,
    wgpu_resources::{
        BindGroupDesc, BindGroupEntry, BindGroupLayoutDesc, GpuBindGroup, GpuBindGroupLayoutHandle,
        GpuRenderPipelineHandle, GpuRenderPipelinePoolAccessor, GpuTexture, PipelineLayoutDesc,
        RenderPipelineDesc,
    },
    OutlineConfig, Rgba,
};

use crate::{DrawPhase, RenderContext};

use smallvec::smallvec;

mod gpu_data {
    use crate::wgpu_buffer_types;

    /// Keep in sync with `composite.wgsl`
    #[repr(C, align(256))]
    #[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
    pub struct CompositeUniformBuffer {
        pub outline_color_layer_a: wgpu_buffer_types::Vec4,
        pub outline_color_layer_b: wgpu_buffer_types::Vec4,
        pub outline_radius_pixel: wgpu_buffer_types::F32RowPadded,
        pub end_padding: [wgpu_buffer_types::PaddingRow; 16 - 3],
    }
}

pub struct Compositor {
    render_pipeline_regular: GpuRenderPipelineHandle,
    render_pipeline_screenshot: GpuRenderPipelineHandle,
    bind_group_layout: GpuBindGroupLayoutHandle,
}

#[derive(Clone)]
pub struct CompositorDrawData {
    /// [`GpuBindGroup`] pointing at the current image source and
    /// a uniform buffer for describing a tonemapper/compositor configuration.
    bind_group: GpuBindGroup,
}

impl DrawData for CompositorDrawData {
 
    
    fn create_renderer(ctx: &RenderContext) -> Self {
        let bind_group_layout = ctx.gpu_resources.bind_group_layouts.get_or_create(
            &ctx.device,
            &BindGroupLayoutDesc {
                label: "Compositor::bind_group_layout".into(),
                entries: vec![
                    wgpu::BindGroupLayoutEntry {
                        binding: 0,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Buffer {
                            ty: wgpu::BufferBindingType::Uniform,
                            has_dynamic_offset: false,
                            min_binding_size: std::num::NonZeroU64::new(std::mem::size_of::<
                                gpu_data::CompositeUniformBuffer,
                            >(
                            )
                                as _),
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 1,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Texture {
                            sample_type: wgpu::TextureSampleType::Float { filterable: false },
                            view_dimension: wgpu::TextureViewDimension::D2,
                            multisampled: false,
                        },
                        count: None,
                    },
                    wgpu::BindGroupLayoutEntry {
                        binding: 2,
                        visibility: wgpu::ShaderStages::FRAGMENT,
                        ty: wgpu::BindingType::Texture {
                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
                            view_dimension: wgpu::TextureViewDimension::D2,
                            multisampled: false,
                        },
                        count: None,
                    },
                ],
            },
        );

        let vertex_handle = screen_triangle_vertex_shader(ctx);

        let render_pipeline_descriptor = RenderPipelineDesc {
            label: "CompositorDrawData::render_pipeline_regular".into(),
            pipeline_layout: ctx.gpu_resources.pipeline_layouts.get_or_create(
                ctx,
                &PipelineLayoutDesc {
                    label: "compositor".into(),
                    entries: vec![ctx.global_bindings.layout, bind_group_layout],
                },
            ),
            vertex_entrypoint: "main".into(),
            vertex_handle,
            fragment_entrypoint: "main".into(),
            fragment_handle: ctx
                .gpu_resources
                .shader_modules
                .get_or_create(ctx, &include_shader_module!("../../shader/composite.wgsl")),
            vertex_buffers: smallvec![],
            render_targets: smallvec![Some(ctx.config.output_format_color.into())],
            primitive: wgpu::PrimitiveState::default(),
            depth_stencil: None,
            multisample: wgpu::MultisampleState::default(),
        };
        let render_pipeline_regular = ctx
            .gpu_resources
            .render_pipelines
            .get_or_create(ctx, &render_pipeline_descriptor);
        let render_pipeline_screenshot = ctx.gpu_resources.render_pipelines.get_or_create(
            ctx,
            &RenderPipelineDesc {
                label: "CompositorDrawData::render_pipeline_screenshot".into(),
                render_targets: smallvec![Some(ViewBuilder::SCREENSHOT_COLOR_FORMAT.into())],
                ..render_pipeline_descriptor
            },
        );

        Compositor {
            render_pipeline_regular,
            render_pipeline_screenshot,
            bind_group_layout,
        }
    }