Struct ContextBuilder

Source

pub struct ContextBuilder { /* private fields */ }

Expand description

Structure to register resources and ultimately build the main Thyme Context.

You pass resources to it to register them with Thyme. Once this process is complete, call build to create your Context.

Implementations§

Source §

impl ContextBuilder

Source

pub fn with_defaults() -> ContextBuilder

Creates a new ContextBuilder, using the default BuildOptions

§Example

    let mut context_builder = thyme::ContextBuilder::with_defaults();
    context_builder.register_theme(theme)?;
    ...

Examples found in repository ?

examples/demo_glium.rs (line 30)

10fn main() -> Result<(), Box<dyn std::error::Error>> {
11    use glium::glutin::{window::WindowBuilder};
12    use glium::{Display, Surface};
13
14    // initialize our very basic logger so error messages go to stdout
15    thyme::log::init(log::Level::Warn).unwrap();
16
17    let window_size = [1280.0, 720.0];
18    let events_loop = EventLoop::new();
19
20    // create glium display
21    let builder = WindowBuilder::new()
22        .with_title("Thyme Demo")
23        .with_inner_size(glium::glutin::dpi::LogicalSize::new(window_size[0], window_size[1]));
24    let context = glium::glutin::ContextBuilder::new();
25    let display = Display::new(builder, context, &events_loop)?;
26
27    // create thyme backend
28    let mut renderer = thyme::GliumRenderer::new(&display)?;
29    let mut io = thyme::WinitIo::new(&events_loop, window_size.into())?;
30    let mut context_builder = thyme::ContextBuilder::with_defaults();
31
32    demo::register_assets(&mut context_builder);
33
34    let mut context = context_builder.build(&mut renderer, &mut io)?;
35
36    let mut party = demo::Party::default();
37
38    let mut last_frame = std::time::Instant::now();
39    let frame_time = std::time::Duration::from_millis(16);
40    
41    // run main loop
42    events_loop.run(move |event, _, control_flow| match event {
43        Event::MainEventsCleared => {
44            if std::time::Instant::now() > last_frame + frame_time {
45                display.gl_window().window().request_redraw();
46            }
47            *control_flow = ControlFlow::WaitUntil(last_frame + frame_time);
48        },
49        Event::RedrawRequested(_) => {
50            last_frame = std::time::Instant::now();
51
52            party.check_context_changes(&mut context, &mut renderer);
53
54            let mut target = display.draw();
55            target.clear_color(0.21404, 0.21404, 0.21404, 1.0); // manual sRGB conversion for 0.5
56
57            bench::run("thyme", || {
58                display.gl_window().window().set_cursor_visible(!party.theme_has_mouse_cursor());
59
60                let mut ui = context.create_frame();
61
62                bench::run("frame", || {
63                    demo::build_ui(&mut ui, &mut party);
64                });
65
66                bench::run("draw", || {
67                    renderer.draw_frame(&mut target, ui).unwrap();
68                });
69            });
70
71            target.finish().unwrap();
72        },
73        Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => *control_flow = ControlFlow::Exit,
74        event => {
75            io.handle_event(&mut context, &event);
76        }
77    })
78}

More examples

Hide additional examples

examples/demo_gl.rs (line 45)

16fn main() -> Result<(), Box<dyn std::error::Error>> {
17    // initialize our very basic logger so error messages go to stdout
18    thyme::log::init(log::Level::Warn).unwrap();
19
20    // create glium display
21    let event_loop = glutin::event_loop::EventLoop::new();
22    let window_builder = glutin::window::WindowBuilder::new()
23        .with_title("Hello world!")
24        .with_inner_size(glutin::dpi::LogicalSize::new(1280.0, 720.0));
25
26    let windowed_context = glutin::ContextBuilder::new()
27        .with_gl(glutin::GlRequest::Specific(
28            glutin::Api::OpenGl,
29            (OPENGL_MAJOR_VERSION, OPENGL_MINOR_VERSION),
30        ))
31        .build_windowed(window_builder, &event_loop)?;
32
33    let windowed_context = unsafe {
34        windowed_context
35            .make_current().map_err(|(_context, e)| e)?
36    };
37
38    {
39        let gl_context = windowed_context.context();
40        gl::load_with(|ptr| gl_context.get_proc_address(ptr) as *const _)
41    }
42
43    // create thyme backend
44    let mut renderer = thyme::GLRenderer::new();
45    let mut context_builder = thyme::ContextBuilder::with_defaults();
46
47    demo::register_assets(&mut context_builder);
48
49    let window_size = [1280.0, 720.0];
50    let mut io = thyme::WinitIo::new(&event_loop, window_size.into())?;
51    let mut context = context_builder.build(&mut renderer, &mut io)?;
52    let mut party = demo::Party::default();
53
54    let mut last_frame = std::time::Instant::now();
55    let frame_time = std::time::Duration::from_millis(16);
56
57    // run main loop
58    event_loop.run(move |event, _, control_flow| match event {
59        Event::MainEventsCleared => {
60            if std::time::Instant::now() > last_frame + frame_time {
61                windowed_context.window().request_redraw();
62            }
63            *control_flow = ControlFlow::WaitUntil(last_frame + frame_time);
64        }
65        Event::RedrawRequested(_) => {
66            last_frame = std::time::Instant::now();
67
68            party.check_context_changes(&mut context, &mut renderer);
69
70            renderer.clear_color(0.5, 0.5, 0.5, 1.0);
71
72            bench::run("thyme", || {
73                windowed_context.window().set_cursor_visible(!party.theme_has_mouse_cursor());
74
75                let mut ui = context.create_frame();
76
77                bench::run("frame", || {
78                    demo::build_ui(&mut ui, &mut party);
79                });
80
81                bench::run("draw", || {
82                    renderer.draw_frame(ui);
83                });
84            });
85
86            windowed_context.swap_buffers().unwrap();
87        }
88        Event::WindowEvent {
89            event: WindowEvent::CloseRequested,
90            ..
91        } => *control_flow = ControlFlow::Exit,
92        event => {
93            io.handle_event(&mut context, &event);
94        }
95    })
96}

examples/demo_wgpu.rs (line 41)

12fn main() -> Result<(), Box<dyn std::error::Error>> {
13    use winit::{ window::WindowBuilder };
14
15    // initialize our very basic logger so error messages go to stdout
16    thyme::log::init(log::Level::Warn).unwrap();
17
18    let window_size = [1280.0, 720.0];
19    let events_loop = EventLoop::new();
20
21    // create winit window
22    let window = WindowBuilder::new()
23        .with_title("Thyme WGPU Demo")
24        .with_inner_size(winit::dpi::LogicalSize::new(window_size[0], window_size[1]))
25        .build(&events_loop)?;
26
27    // setup WGPU
28    let instance_desc = wgpu::InstanceDescriptor {
29        backends: wgpu::Backends::PRIMARY,
30        dx12_shader_compiler: wgpu::Dx12Compiler::Fxc,
31    };
32    let instance = wgpu::Instance::new(instance_desc);
33    let surface = unsafe { instance.create_surface(&window).map_err(thyme::Error::WgpuSurface)? };
34    let (_adapter, device, queue) = futures::executor::block_on(setup_wgpu(&instance, &surface));
35    let surface_config = get_surface_config(window_size[0] as u32, window_size[1] as u32);
36    surface.configure(&device, &surface_config);
37
38    // create thyme backend
39    let mut renderer = thyme::WgpuRenderer::new(Arc::clone(&device), Arc::clone(&queue));
40    let mut io = thyme::WinitIo::new(&events_loop, window_size.into())?;
41    let mut context_builder = thyme::ContextBuilder::with_defaults();
42
43    demo::register_assets(&mut context_builder);
44
45    let mut context = context_builder.build(&mut renderer, &mut io)?;
46
47    let mut party = demo::Party::default();
48
49    let mut last_frame = std::time::Instant::now();
50    let frame_time = std::time::Duration::from_millis(16);
51
52    // run main loop
53    events_loop.run(move |event, _, control_flow| match event {
54        Event::MainEventsCleared => {
55            if std::time::Instant::now() > last_frame + frame_time {
56                window.request_redraw();
57            }
58            *control_flow = ControlFlow::WaitUntil(last_frame + frame_time);
59        },
60        Event::RedrawRequested(_) => {
61            last_frame = std::time::Instant::now();
62
63            party.check_context_changes(&mut context, &mut renderer);
64
65            let frame = surface.get_current_texture().unwrap();
66            let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
67            let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
68
69            bench::run("thyme", || {
70                window.set_cursor_visible(!party.theme_has_mouse_cursor());
71
72                let mut ui = context.create_frame();
73
74                bench::run("frame", || {
75                    demo::build_ui(&mut ui, &mut party);
76                });
77
78                bench::run("draw", || {
79                    {
80                        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
81                            label: None,
82                            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
83                                view: &view,
84                                resolve_target: None,
85                                ops: wgpu::Operations {
86                                    load: wgpu::LoadOp::Clear(wgpu::Color { r: 0.5, g: 0.5, b: 0.5, a: 1.0 }),
87                                    store: true,
88                                },
89                            })],
90                            depth_stencil_attachment: None,
91                        });
92
93                        renderer.draw_frame(ui, &mut render_pass);
94                    }
95
96                    queue.submit(Some(encoder.finish()));
97                    frame.present();
98                });
99            });
100        },
101        Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => *control_flow = ControlFlow::Exit,
102        event => {
103            // recreate swap chain on resize, but also still pass the event to thyme
104            if let Event::WindowEvent { event: WindowEvent::Resized(_), ..} = event {
105                let size: (u32, u32) = window.inner_size().into();
106
107                let surface_config = get_surface_config(size.0, size.1);
108                surface.configure(&device, &surface_config);
109            }
110
111            io.handle_event(&mut context, &event);
112        }
113    })
114}

Source

pub fn new(options: BuildOptions) -> ContextBuilder

Creates a new ContextBuilder, using the specified BuildOptions

Source

pub fn register_theme<'a, T: Deserializer<'a>>( &mut self, theme: T, ) -> Result<(), T::Error>

Sets the theme for this context. The theme for your UI will be deserialized from theme. For example, theme could be a serde_json Value or serde_yaml Value. See the crate root for a discussion of the theme format. If this method is called multiple times, only the last theme is used

Source

pub fn register_theme_from_file(&mut self, path: &Path) -> Result<(), Error>

Sets the theme for this context by reading from the file at the specified path. The file is deserialized as serde YAML files. See register_theme

Source

pub fn register_theme_from_files( &mut self, paths: &[&Path], ) -> Result<(), Error>

Sets the theme for this context by reading from the specified list of files. The files are each read into a string and then concatenated together. The string is then deserialized as serde YAML. See register_theme

Examples found in repository ?

examples/demo.rs (lines 12-19)

10pub fn register_assets(context_builder: &mut ContextBuilder) {
11    // register resources in thyme by reading from files.  this enables live reload.
12    context_builder.register_theme_from_files(
13        &[
14            Path::new("examples/data/themes/base.yml"),
15            Path::new("examples/data/themes/demo.yml"),
16            // note we dynamically add/remove from this list later if the user selects a new theme
17            Path::new("examples/data/themes/pixel.yml"),
18        ],
19    ).unwrap();
20    context_builder.register_texture_from_file("pixel", Path::new("examples/data/images/pixel.png"));
21    context_builder.register_texture_from_file("fantasy", Path::new("examples/data/images/fantasy.png"));
22    context_builder.register_texture_from_file("transparent", Path::new("examples/data/images/transparent.png"));
23    context_builder.register_texture_from_file("golden", Path::new("examples/data/images/golden.png"));
24    context_builder.register_font_from_file("Roboto-Medium", Path::new("examples/data/fonts/Roboto-Medium.ttf"));
25    context_builder.register_font_from_file("Roboto-Italic", Path::new("examples/data/fonts/Roboto-Italic.ttf"));
26    context_builder.register_font_from_file("Roboto-Bold", Path::new("examples/data/fonts/Roboto-Bold.ttf"));
27    context_builder.register_font_from_file("Roboto-BoldItalic", Path::new("examples/data/fonts/Roboto-BoldItalic.ttf"));
28}

Source

pub fn register_font_from_file<T: Into<String>>(&mut self, id: T, path: &Path)

Registers the font data located in the file at the specified path with Thyme via the specified id. See register_font

Examples found in repository ?

examples/demo.rs (line 24)

10pub fn register_assets(context_builder: &mut ContextBuilder) {
11    // register resources in thyme by reading from files.  this enables live reload.
12    context_builder.register_theme_from_files(
13        &[
14            Path::new("examples/data/themes/base.yml"),
15            Path::new("examples/data/themes/demo.yml"),
16            // note we dynamically add/remove from this list later if the user selects a new theme
17            Path::new("examples/data/themes/pixel.yml"),
18        ],
19    ).unwrap();
20    context_builder.register_texture_from_file("pixel", Path::new("examples/data/images/pixel.png"));
21    context_builder.register_texture_from_file("fantasy", Path::new("examples/data/images/fantasy.png"));
22    context_builder.register_texture_from_file("transparent", Path::new("examples/data/images/transparent.png"));
23    context_builder.register_texture_from_file("golden", Path::new("examples/data/images/golden.png"));
24    context_builder.register_font_from_file("Roboto-Medium", Path::new("examples/data/fonts/Roboto-Medium.ttf"));
25    context_builder.register_font_from_file("Roboto-Italic", Path::new("examples/data/fonts/Roboto-Italic.ttf"));
26    context_builder.register_font_from_file("Roboto-Bold", Path::new("examples/data/fonts/Roboto-Bold.ttf"));
27    context_builder.register_font_from_file("Roboto-BoldItalic", Path::new("examples/data/fonts/Roboto-BoldItalic.ttf"));
28}

Source

pub fn register_font<T: Into<String>>(&mut self, id: T, data: Vec<u8>)

Registers the font data for use with Thyme via the specified id. The data must consist of the full binary for a valid TTF or OTF file. Once the font has been registered, it can be accessed in your theme file via the font source.

Source

pub fn register_texture_from_file<T: Into<String>>( &mut self, id: T, path: &Path, )

Reads a texture from the specified image file. See register_texture. Requires you to enable the image feature in Cargo.toml to enable the dependancy on the image crate.

Examples found in repository ?

examples/demo.rs (line 20)

10pub fn register_assets(context_builder: &mut ContextBuilder) {
11    // register resources in thyme by reading from files.  this enables live reload.
12    context_builder.register_theme_from_files(
13        &[
14            Path::new("examples/data/themes/base.yml"),
15            Path::new("examples/data/themes/demo.yml"),
16            // note we dynamically add/remove from this list later if the user selects a new theme
17            Path::new("examples/data/themes/pixel.yml"),
18        ],
19    ).unwrap();
20    context_builder.register_texture_from_file("pixel", Path::new("examples/data/images/pixel.png"));
21    context_builder.register_texture_from_file("fantasy", Path::new("examples/data/images/fantasy.png"));
22    context_builder.register_texture_from_file("transparent", Path::new("examples/data/images/transparent.png"));
23    context_builder.register_texture_from_file("golden", Path::new("examples/data/images/golden.png"));
24    context_builder.register_font_from_file("Roboto-Medium", Path::new("examples/data/fonts/Roboto-Medium.ttf"));
25    context_builder.register_font_from_file("Roboto-Italic", Path::new("examples/data/fonts/Roboto-Italic.ttf"));
26    context_builder.register_font_from_file("Roboto-Bold", Path::new("examples/data/fonts/Roboto-Bold.ttf"));
27    context_builder.register_font_from_file("Roboto-BoldItalic", Path::new("examples/data/fonts/Roboto-BoldItalic.ttf"));
28}

Source

pub fn register_texture<T: Into<String>>( &mut self, id: T, data: Vec<u8>, dimensions: (u32, u32), )

Registers the image data for use with Thyme via the specified id. The data must consist of raw binary image data in RGBA format, with 4 bytes per pixel. The data must start at the bottom-left hand corner pixel and progress left-to-right and bottom-to-top. data.len() must equal dimensions.0 * dimensions.1 * 4 Once the image has been registered, it can be accessed in your theme file via the image source.

Source

pub fn build<R: Renderer, I: IO>( self, renderer: &mut R, io: &mut I, ) -> Result<Context, Error>

Consumes this builder and releases the borrows on the Renderer and IO, so they can be used further. Builds a Context.

Examples found in repository ?

examples/demo_glium.rs (line 34)

10fn main() -> Result<(), Box<dyn std::error::Error>> {
11    use glium::glutin::{window::WindowBuilder};
12    use glium::{Display, Surface};
13
14    // initialize our very basic logger so error messages go to stdout
15    thyme::log::init(log::Level::Warn).unwrap();
16
17    let window_size = [1280.0, 720.0];
18    let events_loop = EventLoop::new();
19
20    // create glium display
21    let builder = WindowBuilder::new()
22        .with_title("Thyme Demo")
23        .with_inner_size(glium::glutin::dpi::LogicalSize::new(window_size[0], window_size[1]));
24    let context = glium::glutin::ContextBuilder::new();
25    let display = Display::new(builder, context, &events_loop)?;
26
27    // create thyme backend
28    let mut renderer = thyme::GliumRenderer::new(&display)?;
29    let mut io = thyme::WinitIo::new(&events_loop, window_size.into())?;
30    let mut context_builder = thyme::ContextBuilder::with_defaults();
31
32    demo::register_assets(&mut context_builder);
33
34    let mut context = context_builder.build(&mut renderer, &mut io)?;
35
36    let mut party = demo::Party::default();
37
38    let mut last_frame = std::time::Instant::now();
39    let frame_time = std::time::Duration::from_millis(16);
40    
41    // run main loop
42    events_loop.run(move |event, _, control_flow| match event {
43        Event::MainEventsCleared => {
44            if std::time::Instant::now() > last_frame + frame_time {
45                display.gl_window().window().request_redraw();
46            }
47            *control_flow = ControlFlow::WaitUntil(last_frame + frame_time);
48        },
49        Event::RedrawRequested(_) => {
50            last_frame = std::time::Instant::now();
51
52            party.check_context_changes(&mut context, &mut renderer);
53
54            let mut target = display.draw();
55            target.clear_color(0.21404, 0.21404, 0.21404, 1.0); // manual sRGB conversion for 0.5
56
57            bench::run("thyme", || {
58                display.gl_window().window().set_cursor_visible(!party.theme_has_mouse_cursor());
59
60                let mut ui = context.create_frame();
61
62                bench::run("frame", || {
63                    demo::build_ui(&mut ui, &mut party);
64                });
65
66                bench::run("draw", || {
67                    renderer.draw_frame(&mut target, ui).unwrap();
68                });
69            });
70
71            target.finish().unwrap();
72        },
73        Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => *control_flow = ControlFlow::Exit,
74        event => {
75            io.handle_event(&mut context, &event);
76        }
77    })
78}

More examples

Hide additional examples

examples/demo_gl.rs (line 51)

16fn main() -> Result<(), Box<dyn std::error::Error>> {
17    // initialize our very basic logger so error messages go to stdout
18    thyme::log::init(log::Level::Warn).unwrap();
19
20    // create glium display
21    let event_loop = glutin::event_loop::EventLoop::new();
22    let window_builder = glutin::window::WindowBuilder::new()
23        .with_title("Hello world!")
24        .with_inner_size(glutin::dpi::LogicalSize::new(1280.0, 720.0));
25
26    let windowed_context = glutin::ContextBuilder::new()
27        .with_gl(glutin::GlRequest::Specific(
28            glutin::Api::OpenGl,
29            (OPENGL_MAJOR_VERSION, OPENGL_MINOR_VERSION),
30        ))
31        .build_windowed(window_builder, &event_loop)?;
32
33    let windowed_context = unsafe {
34        windowed_context
35            .make_current().map_err(|(_context, e)| e)?
36    };
37
38    {
39        let gl_context = windowed_context.context();
40        gl::load_with(|ptr| gl_context.get_proc_address(ptr) as *const _)
41    }
42
43    // create thyme backend
44    let mut renderer = thyme::GLRenderer::new();
45    let mut context_builder = thyme::ContextBuilder::with_defaults();
46
47    demo::register_assets(&mut context_builder);
48
49    let window_size = [1280.0, 720.0];
50    let mut io = thyme::WinitIo::new(&event_loop, window_size.into())?;
51    let mut context = context_builder.build(&mut renderer, &mut io)?;
52    let mut party = demo::Party::default();
53
54    let mut last_frame = std::time::Instant::now();
55    let frame_time = std::time::Duration::from_millis(16);
56
57    // run main loop
58    event_loop.run(move |event, _, control_flow| match event {
59        Event::MainEventsCleared => {
60            if std::time::Instant::now() > last_frame + frame_time {
61                windowed_context.window().request_redraw();
62            }
63            *control_flow = ControlFlow::WaitUntil(last_frame + frame_time);
64        }
65        Event::RedrawRequested(_) => {
66            last_frame = std::time::Instant::now();
67
68            party.check_context_changes(&mut context, &mut renderer);
69
70            renderer.clear_color(0.5, 0.5, 0.5, 1.0);
71
72            bench::run("thyme", || {
73                windowed_context.window().set_cursor_visible(!party.theme_has_mouse_cursor());
74
75                let mut ui = context.create_frame();
76
77                bench::run("frame", || {
78                    demo::build_ui(&mut ui, &mut party);
79                });
80
81                bench::run("draw", || {
82                    renderer.draw_frame(ui);
83                });
84            });
85
86            windowed_context.swap_buffers().unwrap();
87        }
88        Event::WindowEvent {
89            event: WindowEvent::CloseRequested,
90            ..
91        } => *control_flow = ControlFlow::Exit,
92        event => {
93            io.handle_event(&mut context, &event);
94        }
95    })
96}

examples/demo_wgpu.rs (line 45)

12fn main() -> Result<(), Box<dyn std::error::Error>> {
13    use winit::{ window::WindowBuilder };
14
15    // initialize our very basic logger so error messages go to stdout
16    thyme::log::init(log::Level::Warn).unwrap();
17
18    let window_size = [1280.0, 720.0];
19    let events_loop = EventLoop::new();
20
21    // create winit window
22    let window = WindowBuilder::new()
23        .with_title("Thyme WGPU Demo")
24        .with_inner_size(winit::dpi::LogicalSize::new(window_size[0], window_size[1]))
25        .build(&events_loop)?;
26
27    // setup WGPU
28    let instance_desc = wgpu::InstanceDescriptor {
29        backends: wgpu::Backends::PRIMARY,
30        dx12_shader_compiler: wgpu::Dx12Compiler::Fxc,
31    };
32    let instance = wgpu::Instance::new(instance_desc);
33    let surface = unsafe { instance.create_surface(&window).map_err(thyme::Error::WgpuSurface)? };
34    let (_adapter, device, queue) = futures::executor::block_on(setup_wgpu(&instance, &surface));
35    let surface_config = get_surface_config(window_size[0] as u32, window_size[1] as u32);
36    surface.configure(&device, &surface_config);
37
38    // create thyme backend
39    let mut renderer = thyme::WgpuRenderer::new(Arc::clone(&device), Arc::clone(&queue));
40    let mut io = thyme::WinitIo::new(&events_loop, window_size.into())?;
41    let mut context_builder = thyme::ContextBuilder::with_defaults();
42
43    demo::register_assets(&mut context_builder);
44
45    let mut context = context_builder.build(&mut renderer, &mut io)?;
46
47    let mut party = demo::Party::default();
48
49    let mut last_frame = std::time::Instant::now();
50    let frame_time = std::time::Duration::from_millis(16);
51
52    // run main loop
53    events_loop.run(move |event, _, control_flow| match event {
54        Event::MainEventsCleared => {
55            if std::time::Instant::now() > last_frame + frame_time {
56                window.request_redraw();
57            }
58            *control_flow = ControlFlow::WaitUntil(last_frame + frame_time);
59        },
60        Event::RedrawRequested(_) => {
61            last_frame = std::time::Instant::now();
62
63            party.check_context_changes(&mut context, &mut renderer);
64
65            let frame = surface.get_current_texture().unwrap();
66            let view = frame.texture.create_view(&wgpu::TextureViewDescriptor::default());
67            let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
68
69            bench::run("thyme", || {
70                window.set_cursor_visible(!party.theme_has_mouse_cursor());
71
72                let mut ui = context.create_frame();
73
74                bench::run("frame", || {
75                    demo::build_ui(&mut ui, &mut party);
76                });
77
78                bench::run("draw", || {
79                    {
80                        let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
81                            label: None,
82                            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
83                                view: &view,
84                                resolve_target: None,
85                                ops: wgpu::Operations {
86                                    load: wgpu::LoadOp::Clear(wgpu::Color { r: 0.5, g: 0.5, b: 0.5, a: 1.0 }),
87                                    store: true,
88                                },
89                            })],
90                            depth_stencil_attachment: None,
91                        });
92
93                        renderer.draw_frame(ui, &mut render_pass);
94                    }
95
96                    queue.submit(Some(encoder.finish()));
97                    frame.present();
98                });
99            });
100        },
101        Event::WindowEvent { event: WindowEvent::CloseRequested, .. } => *control_flow = ControlFlow::Exit,
102        event => {
103            // recreate swap chain on resize, but also still pass the event to thyme
104            if let Event::WindowEvent { event: WindowEvent::Resized(_), ..} = event {
105                let size: (u32, u32) = window.inner_size().into();
106
107                let surface_config = get_surface_config(size.0, size.1);
108                surface.configure(&device, &surface_config);
109            }
110
111            io.handle_event(&mut context, &event);
112        }
113    })
114}