Struct glutin::ContextBuilder

source ·

pub struct ContextBuilder<'a> {
    pub gl_attr: GlAttributes<&'a Context>,
    /* private fields */
}

Expand description

Object that allows you to build Contexts.

Fields§

§gl_attr: GlAttributes<&'a Context>

The attributes to use to create the context.

Implementations§

source §

impl<'a> ContextBuilder<'a>

source

pub fn new() -> Self

Initializes a new ContextBuilder with default values.

Examples found in repository ?

examples/window.rs (line 10)

fn main() {
    let mut events_loop = glutin::EventsLoop::new();
    let window = glutin::WindowBuilder::new().with_title("A fantastic window!");
    let context = glutin::ContextBuilder::new();
    let gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();

    let _ = unsafe { gl_window.make_current() };

    println!("Pixel format of the window's GL context: {:?}", gl_window.get_pixel_format());

    let gl = support::load(&gl_window);

    let mut running = true;
    while running {
        events_loop.poll_events(|event| {
            println!("{:?}", event);
            match event {
                glutin::Event::WindowEvent { event, .. } => match event {
                    glutin::WindowEvent::CloseRequested => running = false,
                    glutin::WindowEvent::Resized(logical_size) => {
                        let dpi_factor = gl_window.get_hidpi_factor();
                        gl_window.resize(logical_size.to_physical(dpi_factor));
                    },
                    _ => (),
                },
                _ => ()
            }
        });

        gl.draw_frame([1.0, 0.5, 0.7, 1.0]);
        let _ = gl_window.swap_buffers();
    }
}

More examples

Hide additional examples

examples/transparent.rs (line 13)

fn main() {
    let mut events_loop = glutin::EventsLoop::new();
    let window = glutin::WindowBuilder::new()
        .with_title("A transparent window!")
        .with_decorations(false)
        .with_transparency(true);
    let context = glutin::ContextBuilder::new();
    let gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();

    let _ = unsafe { gl_window.make_current() };

    println!("Pixel format of the window's GL context: {:?}", gl_window.get_pixel_format());

    let gl = support::load(&gl_window);

    let mut running = true;
    while running {
        events_loop.poll_events(|event| {
            println!("{:?}", event);
            match event {
                glutin::Event::WindowEvent { event, .. } => match event {
                    glutin::WindowEvent::CloseRequested => running = false,
                    glutin::WindowEvent::Resized(logical_size) => {
                        let dpi_factor = gl_window.get_hidpi_factor();
                        gl_window.resize(logical_size.to_physical(dpi_factor));
                    },
                    glutin::WindowEvent::KeyboardInput { input: glutin::KeyboardInput {
                        virtual_keycode: Some(glutin::VirtualKeyCode::Escape),
                        ..
                    }, .. } => running = false,
                    _ => (),
                },
                _ => ()
            }
        });

        gl.draw_frame([0.0; 4]);
        let _ = gl_window.swap_buffers();
    }
}

examples/multiwindow.rs (line 14)

fn main() {
    let mut events_loop = glutin::EventsLoop::new();

    let mut windows = std::collections::HashMap::new();
    for index in 0..3 {
        let title = format!("Charming Window #{}", index + 1);
        let window = glutin::WindowBuilder::new().with_title(title);
        let context = glutin::ContextBuilder::new();
        let gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();
        let _ = unsafe { gl_window.make_current() };
        let gl = support::load(&gl_window);
        let window_id = gl_window.id();
        windows.insert(window_id, (gl_window, gl));
    }

    while !windows.is_empty() {
        events_loop.poll_events(|event| {
            println!("{:?}", event);
            match event {
                glutin::Event::WindowEvent { event, window_id } => match event {
                    glutin::WindowEvent::Resized(logical_size) => {
                        let gl_window = &windows[&window_id].0;
                        let dpi_factor = gl_window.get_hidpi_factor();
                        gl_window.resize(logical_size.to_physical(dpi_factor));
                    },
                    glutin::WindowEvent::CloseRequested => {
                        if windows.remove(&window_id).is_some() {
                            println!("Window with ID {:?} has been closed", window_id);
                        }
                    },
                    _ => (),
                },
                _ => (),
            }
        });

        for (index, window) in windows.values().enumerate() {
            let mut color = [1.0, 0.5, 0.7, 1.0];
            color.swap(0, index % 3);
            let _ = unsafe { window.0.make_current() };
            window.1.draw_frame(color);
            let _ = window.0.swap_buffers();
        }
    }
}

examples/fullscreen.rs (line 33)

fn main() {
    let mut events_loop = glutin::EventsLoop::new();

    // enumerating monitors
    let monitor = {
        for (num, monitor) in events_loop.get_available_monitors().enumerate() {
            println!("Monitor #{}: {:?}", num, monitor.get_name());
        }

        print!("Please write the number of the monitor to use: ");
        io::stdout().flush().unwrap();

        let mut num = String::new();
        io::stdin().read_line(&mut num).unwrap();
        let num = num.trim().parse().ok().expect("Please enter a number");
        let monitor = events_loop.get_available_monitors().nth(num).expect("Please enter a valid ID");

        println!("Using {:?}", monitor.get_name());

        monitor
    };

    let window = glutin::WindowBuilder::new()
        .with_title("Hello world!")
        .with_fullscreen(Some(monitor));
    let context = glutin::ContextBuilder::new();
    let gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();

    let _ = unsafe { gl_window.make_current() };

    let gl = support::load(&gl_window);

    let mut fullscreen = true;
    let mut running = true;
    while running {
        events_loop.poll_events(|event| {
            println!("{:?}", event);
            match event {
                glutin::Event::WindowEvent { event, .. } => match event {
                    glutin::WindowEvent::CloseRequested => running = false,
                    glutin::WindowEvent::Resized(logical_size) => {
                        let dpi_factor = gl_window.get_hidpi_factor();
                        gl_window.resize(logical_size.to_physical(dpi_factor));
                    },
                    glutin::WindowEvent::KeyboardInput { input, .. } => {
                        match input.virtual_keycode {
                            Some(glutin::VirtualKeyCode::Escape) => running = false,
                            Some(glutin::VirtualKeyCode::F) => {
                                let monitor = if fullscreen {
                                    None
                                } else {
                                    Some(gl_window.get_current_monitor())
                                };
                                gl_window.set_fullscreen(monitor);
                                fullscreen = !fullscreen;
                            },
                            _ => (),
                        }
                    },
                    _ => (),
                },
                _ => ()
            }
        });

        gl.draw_frame([1.0, 0.5, 0.7, 1.0]);
        let _ = gl_window.swap_buffers();
    }
}

source

pub fn with_gl(self, request: GlRequest) -> Self

Sets how the backend should choose the OpenGL API and version.

source

pub fn with_gl_profile(self, profile: GlProfile) -> Self

Sets the desired OpenGL context profile.

source

pub fn with_gl_debug_flag(self, flag: bool) -> Self

Sets the debug flag for the OpenGL context.

The default value for this flag is cfg!(debug_assertions), which means that it’s enabled when you run cargo build and disabled when you run cargo build --release.

source