pub struct GlWindow { /* private fields */ }
Expand description
Represents an OpenGL context and a Window with which it is associated.
Example
let mut events_loop = glutin::EventsLoop::new();
let window = glutin::WindowBuilder::new();
let context = glutin::ContextBuilder::new();
let gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();
unsafe { gl_window.make_current().unwrap() };
loop {
events_loop.poll_events(|event| {
match event {
// process events here
_ => ()
}
});
// draw everything here
gl_window.swap_buffers();
std::thread::sleep(std::time::Duration::from_millis(17));
}
Implementations§
source§impl GlWindow
impl GlWindow
sourcepub fn new(
window_builder: WindowBuilder,
context_builder: ContextBuilder<'_>,
events_loop: &EventsLoop
) -> Result<Self, CreationError>
pub fn new( window_builder: WindowBuilder, context_builder: ContextBuilder<'_>, events_loop: &EventsLoop ) -> Result<Self, CreationError>
Builds the given window along with the associated GL context, returning the pair as a
GlWindow
.
The context made can be shared with:
- headless contexts made with the
shareable_with_windowed_contexts
flag set totrue
; and - contexts made when creating a
GlWindow
.
You are not guaranteed to receive an error if you share a context with an other context which you’re not permitted to share it with, as according to:
- the restrictions stated by us above; and
- the restrictions imposed on you by the platform your application runs
on. (Please refer to
README-SHARING.md
)
Failing to follow all the context sharing restrictions imposed on you may result in unsafe behavior.
This safe variant of new_shared
will panic if you try to share it with
an existing context.
Error should be very rare and only occur in case of permission denied, incompatible system out of memory, etc.
Examples found in repository?
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
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.context());
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
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
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.context());
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();
}
}
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
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.context());
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();
}
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
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.context());
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) if input.state == glutin::ElementState::Pressed => {
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();
}
}
Builds the given window along with the associated GL context, returning the pair as a
GlWindow
.
The context made can be shared with:
- headless contexts made with the
shareable_with_windowed_contexts
flag set totrue
; and - contexts made when creating a
GlWindow
.
You are not guaranteed to receive an error if you share a context with an other context which you’re not permitted to share it with, as according to:
- the restrictions stated by us above; and
- the restrictions imposed on you by the platform your application runs
on. (Please refer to
README-SHARING.md
)
Failing to follow all the context sharing restrictions imposed on you may result in unsafe behavior.
Error should be very rare and only occur in case of permission denied, incompatible system out of memory, etc.
Examples found in repository?
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
fn main() {
let mut events_loop = glutin::EventsLoop::new();
let mut size = glutin::dpi::PhysicalSize::new(768., 480.);
let context = glutin::ContextBuilder::new();
let gl_context = glutin::Context::new(&events_loop, context, true).unwrap();
let window = glutin::WindowBuilder::new().with_title("A fantastic window!")
.with_dimensions(glutin::dpi::LogicalSize::from_physical(size, 1.0));
let context = glutin::ContextBuilder::new()
.with_shared_lists(&gl_context);
let gl_window = unsafe { glutin::GlWindow::new_shared(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 glw = support::load(&gl_window.context());
let mut render_tex = 0;
unsafe {
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
}
let mut window_fb = 0;
unsafe {
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
}
let _ = unsafe { gl_context.make_current() };
let glc = support::load(&gl_context);
let mut context_fb = 0;
unsafe {
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
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 _ = unsafe { gl_window.make_current() };
let dpi_factor = gl_window.get_hidpi_factor();
size = logical_size.to_physical(dpi_factor);
gl_window.resize(size);
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
},
_ => (),
},
_ => ()
}
});
let _ = unsafe { gl_context.make_current() };
glc.draw_frame([1.0, 0.5, 0.7, 1.0]);
let _ = unsafe { gl_window.make_current() };
unsafe {
glw.gl.BlitFramebuffer(
0, 0, size.width as _, size.height as _,
0, 0, size.width as _, size.height as _,
gl::COLOR_BUFFER_BIT,
gl::NEAREST,
);
}
let _ = gl_window.swap_buffers();
}
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
}
}
sourcepub fn context(&self) -> &Context
pub fn context(&self) -> &Context
Borrow the inner GL Context
.
Examples found in repository?
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
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.context());
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
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
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.context());
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();
}
}
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
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.context());
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();
}
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
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.context());
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) if input.state == glutin::ElementState::Pressed => {
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();
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
fn main() {
let mut events_loop = glutin::EventsLoop::new();
let mut size = glutin::dpi::PhysicalSize::new(768., 480.);
let context = glutin::ContextBuilder::new();
let gl_context = glutin::Context::new(&events_loop, context, true).unwrap();
let window = glutin::WindowBuilder::new().with_title("A fantastic window!")
.with_dimensions(glutin::dpi::LogicalSize::from_physical(size, 1.0));
let context = glutin::ContextBuilder::new()
.with_shared_lists(&gl_context);
let gl_window = unsafe { glutin::GlWindow::new_shared(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 glw = support::load(&gl_window.context());
let mut render_tex = 0;
unsafe {
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
}
let mut window_fb = 0;
unsafe {
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
}
let _ = unsafe { gl_context.make_current() };
let glc = support::load(&gl_context);
let mut context_fb = 0;
unsafe {
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
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 _ = unsafe { gl_window.make_current() };
let dpi_factor = gl_window.get_hidpi_factor();
size = logical_size.to_physical(dpi_factor);
gl_window.resize(size);
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
},
_ => (),
},
_ => ()
}
});
let _ = unsafe { gl_context.make_current() };
glc.draw_frame([1.0, 0.5, 0.7, 1.0]);
let _ = unsafe { gl_window.make_current() };
unsafe {
glw.gl.BlitFramebuffer(
0, 0, size.width as _, size.height as _,
0, 0, size.width as _, size.height as _,
gl::COLOR_BUFFER_BIT,
gl::NEAREST,
);
}
let _ = gl_window.swap_buffers();
}
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
}
}
sourcepub fn swap_buffers(&self) -> Result<(), ContextError>
pub fn swap_buffers(&self) -> Result<(), ContextError>
Swaps the buffers in case of double or triple buffering.
You should call this function every time you have finished rendering, or the image may not be displayed on the screen.
Warning: if you enabled vsync, this function will block until the next time the screen
is refreshed. However drivers can choose to override your vsync settings, which means that
you can’t know in advance whether swap_buffers
will block or not.
Examples found in repository?
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
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.context());
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
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
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.context());
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();
}
}
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
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.context());
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();
}
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
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.context());
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) if input.state == glutin::ElementState::Pressed => {
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();
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
fn main() {
let mut events_loop = glutin::EventsLoop::new();
let mut size = glutin::dpi::PhysicalSize::new(768., 480.);
let context = glutin::ContextBuilder::new();
let gl_context = glutin::Context::new(&events_loop, context, true).unwrap();
let window = glutin::WindowBuilder::new().with_title("A fantastic window!")
.with_dimensions(glutin::dpi::LogicalSize::from_physical(size, 1.0));
let context = glutin::ContextBuilder::new()
.with_shared_lists(&gl_context);
let gl_window = unsafe { glutin::GlWindow::new_shared(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 glw = support::load(&gl_window.context());
let mut render_tex = 0;
unsafe {
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
}
let mut window_fb = 0;
unsafe {
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
}
let _ = unsafe { gl_context.make_current() };
let glc = support::load(&gl_context);
let mut context_fb = 0;
unsafe {
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
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 _ = unsafe { gl_window.make_current() };
let dpi_factor = gl_window.get_hidpi_factor();
size = logical_size.to_physical(dpi_factor);
gl_window.resize(size);
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
},
_ => (),
},
_ => ()
}
});
let _ = unsafe { gl_context.make_current() };
glc.draw_frame([1.0, 0.5, 0.7, 1.0]);
let _ = unsafe { gl_window.make_current() };
unsafe {
glw.gl.BlitFramebuffer(
0, 0, size.width as _, size.height as _,
0, 0, size.width as _, size.height as _,
gl::COLOR_BUFFER_BIT,
gl::NEAREST,
);
}
let _ = gl_window.swap_buffers();
}
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
}
}
sourcepub fn get_pixel_format(&self) -> PixelFormat
pub fn get_pixel_format(&self) -> PixelFormat
Returns the pixel format of the main framebuffer of the context.
Examples found in repository?
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
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.context());
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
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
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.context());
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();
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
fn main() {
let mut events_loop = glutin::EventsLoop::new();
let mut size = glutin::dpi::PhysicalSize::new(768., 480.);
let context = glutin::ContextBuilder::new();
let gl_context = glutin::Context::new(&events_loop, context, true).unwrap();
let window = glutin::WindowBuilder::new().with_title("A fantastic window!")
.with_dimensions(glutin::dpi::LogicalSize::from_physical(size, 1.0));
let context = glutin::ContextBuilder::new()
.with_shared_lists(&gl_context);
let gl_window = unsafe { glutin::GlWindow::new_shared(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 glw = support::load(&gl_window.context());
let mut render_tex = 0;
unsafe {
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
}
let mut window_fb = 0;
unsafe {
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
}
let _ = unsafe { gl_context.make_current() };
let glc = support::load(&gl_context);
let mut context_fb = 0;
unsafe {
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
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 _ = unsafe { gl_window.make_current() };
let dpi_factor = gl_window.get_hidpi_factor();
size = logical_size.to_physical(dpi_factor);
gl_window.resize(size);
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
},
_ => (),
},
_ => ()
}
});
let _ = unsafe { gl_context.make_current() };
glc.draw_frame([1.0, 0.5, 0.7, 1.0]);
let _ = unsafe { gl_window.make_current() };
unsafe {
glw.gl.BlitFramebuffer(
0, 0, size.width as _, size.height as _,
0, 0, size.width as _, size.height as _,
gl::COLOR_BUFFER_BIT,
gl::NEAREST,
);
}
let _ = gl_window.swap_buffers();
}
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
}
}
sourcepub fn resize(&self, size: PhysicalSize)
pub fn resize(&self, size: PhysicalSize)
Resize the context.
Some platforms (macOS, Wayland) require being manually updated when their window or surface is resized.
The easiest way of doing this is to take every Resized
window event that
is received with a LogicalSize
and convert it to a PhysicalSize
and
pass it into this function.
Examples found in repository?
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
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.context());
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
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
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.context());
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();
}
}
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
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.context());
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();
}
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
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.context());
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) if input.state == glutin::ElementState::Pressed => {
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();
}
}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
fn main() {
let mut events_loop = glutin::EventsLoop::new();
let mut size = glutin::dpi::PhysicalSize::new(768., 480.);
let context = glutin::ContextBuilder::new();
let gl_context = glutin::Context::new(&events_loop, context, true).unwrap();
let window = glutin::WindowBuilder::new().with_title("A fantastic window!")
.with_dimensions(glutin::dpi::LogicalSize::from_physical(size, 1.0));
let context = glutin::ContextBuilder::new()
.with_shared_lists(&gl_context);
let gl_window = unsafe { glutin::GlWindow::new_shared(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 glw = support::load(&gl_window.context());
let mut render_tex = 0;
unsafe {
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
}
let mut window_fb = 0;
unsafe {
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
}
let _ = unsafe { gl_context.make_current() };
let glc = support::load(&gl_context);
let mut context_fb = 0;
unsafe {
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
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 _ = unsafe { gl_window.make_current() };
let dpi_factor = gl_window.get_hidpi_factor();
size = logical_size.to_physical(dpi_factor);
gl_window.resize(size);
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
glw.gl.GenTextures(1, &mut render_tex);
glw.gl.BindTexture(gl::TEXTURE_2D, render_tex);
glw.gl.TexStorage2D(
gl::TEXTURE_2D,
1,
gl::SRGB8_ALPHA8,
size.width as _,
size.height as _,
);
glw.gl.GenFramebuffers(1, &mut window_fb);
glw.gl.BindFramebuffer(gl::READ_FRAMEBUFFER, window_fb);
glw.gl.BindFramebuffer(gl::DRAW_FRAMEBUFFER, 0);
glw.gl.FramebufferTexture2D(
gl::READ_FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
glc.gl.GenFramebuffers(1, &mut context_fb);
glc.gl.BindFramebuffer(gl::FRAMEBUFFER, context_fb);
glc.gl.FramebufferTexture2D(
gl::FRAMEBUFFER,
gl::COLOR_ATTACHMENT0,
gl::TEXTURE_2D,
render_tex,
0,
);
glc.gl.Viewport(0, 0, size.width as _, size.height as _);
}
},
_ => (),
},
_ => ()
}
});
let _ = unsafe { gl_context.make_current() };
glc.draw_frame([1.0, 0.5, 0.7, 1.0]);
let _ = unsafe { gl_window.make_current() };
unsafe {
glw.gl.BlitFramebuffer(
0, 0, size.width as _, size.height as _,
0, 0, size.width as _, size.height as _,
gl::COLOR_BUFFER_BIT,
gl::NEAREST,
);
}
let _ = gl_window.swap_buffers();
}
unsafe {
let _ = gl_window.make_current();
glw.gl.DeleteTextures(1, &render_tex);
glw.gl.DeleteFramebuffers(1, &window_fb);
let _ = gl_context.make_current();
glc.gl.DeleteFramebuffers(1, &context_fb);
}
}
Methods from Deref<Target = Window>§
sourcepub fn set_title(&self, title: &str)
pub fn set_title(&self, title: &str)
Modifies the title of the window.
This is a no-op if the window has already been closed.
sourcepub fn get_position(&self) -> Option<LogicalPosition>
pub fn get_position(&self) -> Option<LogicalPosition>
Returns the position of the top-left hand corner of the window relative to the top-left hand corner of the desktop.
Note that the top-left hand corner of the desktop is not necessarily the same as the screen. If the user uses a desktop with multiple monitors, the top-left hand corner of the desktop is the top-left hand corner of the monitor at the top-left of the desktop.
The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region.
Returns None
if the window no longer exists.
sourcepub fn get_inner_position(&self) -> Option<LogicalPosition>
pub fn get_inner_position(&self) -> Option<LogicalPosition>
Returns the position of the top-left hand corner of the window’s client area relative to the top-left hand corner of the desktop.
The same conditions that apply to get_position
apply to this method.
sourcepub fn set_position(&self, position: LogicalPosition)
pub fn set_position(&self, position: LogicalPosition)
Modifies the position of the window.
See get_position
for more information about the coordinates.
This is a no-op if the window has already been closed.
sourcepub fn get_inner_size(&self) -> Option<LogicalSize>
pub fn get_inner_size(&self) -> Option<LogicalSize>
Returns the logical size of the window’s client area.
The client area is the content of the window, excluding the title bar and borders.
Converting the returned LogicalSize
to PhysicalSize
produces the size your framebuffer should be.
Returns None
if the window no longer exists.
sourcepub fn get_outer_size(&self) -> Option<LogicalSize>
pub fn get_outer_size(&self) -> Option<LogicalSize>
Returns the logical size of the entire window.
These dimensions include the title bar and borders. If you don’t want that (and you usually don’t),
use get_inner_size
instead.
Returns None
if the window no longer exists.
sourcepub fn set_inner_size(&self, size: LogicalSize)
pub fn set_inner_size(&self, size: LogicalSize)
Modifies the inner size of the window.
See get_inner_size
for more information about the values.
This is a no-op if the window has already been closed.
sourcepub fn set_min_dimensions(&self, dimensions: Option<LogicalSize>)
pub fn set_min_dimensions(&self, dimensions: Option<LogicalSize>)
Sets a minimum dimension size for the window.
sourcepub fn set_max_dimensions(&self, dimensions: Option<LogicalSize>)
pub fn set_max_dimensions(&self, dimensions: Option<LogicalSize>)
Sets a maximum dimension size for the window.
sourcepub fn set_resizable(&self, resizable: bool)
pub fn set_resizable(&self, resizable: bool)
Sets whether the window is resizable or not.
Note that making the window unresizable doesn’t exempt you from handling Resized
, as that event can still be
triggered by DPI scaling, entering fullscreen mode, etc.
Platform-specific
This only has an effect on desktop platforms.
Due to a bug in XFCE, this has no effect on Xfwm.
sourcepub fn get_hidpi_factor(&self) -> f64
pub fn get_hidpi_factor(&self) -> f64
Returns the DPI factor that can be used to map logical pixels to physical pixels, and vice versa.
See the dpi
module for more information.
Note that this value can change depending on user action (for example if the window is
moved to another screen); as such, tracking WindowEvent::HiDpiFactorChanged
events is
the most robust way to track the DPI you need to use to draw.
Platform-specific
- X11: Can be overridden using the
WINIT_HIDPI_FACTOR
environment variable. - Android: Always returns 1.0.
sourcepub fn set_cursor(&self, cursor: MouseCursor)
pub fn set_cursor(&self, cursor: MouseCursor)
Modifies the mouse cursor of the window. Has no effect on Android.
sourcepub fn set_cursor_position(
&self,
position: LogicalPosition
) -> Result<(), String>
pub fn set_cursor_position( &self, position: LogicalPosition ) -> Result<(), String>
Changes the position of the cursor in window coordinates.
sourcepub fn grab_cursor(&self, grab: bool) -> Result<(), String>
pub fn grab_cursor(&self, grab: bool) -> Result<(), String>
Grabs the cursor, preventing it from leaving the window.
Platform-specific
On macOS, this presently merely locks the cursor in a fixed location, which looks visually awkward.
This has no effect on Android or iOS.
sourcepub fn hide_cursor(&self, hide: bool)
pub fn hide_cursor(&self, hide: bool)
Hides the cursor, making it invisible but still usable.
Platform-specific
On Windows and X11, the cursor is only hidden within the confines of the window.
On macOS, the cursor is hidden as long as the window has input focus, even if the cursor is outside of the window.
This has no effect on Android or iOS.
sourcepub fn set_maximized(&self, maximized: bool)
pub fn set_maximized(&self, maximized: bool)
Sets the window to maximized or back
sourcepub fn set_fullscreen(&self, monitor: Option<MonitorId>)
pub fn set_fullscreen(&self, monitor: Option<MonitorId>)
Sets the window to fullscreen or back
sourcepub fn set_decorations(&self, decorations: bool)
pub fn set_decorations(&self, decorations: bool)
Turn window decorations on or off.
sourcepub fn set_always_on_top(&self, always_on_top: bool)
pub fn set_always_on_top(&self, always_on_top: bool)
Change whether or not the window will always be on top of other windows.
sourcepub fn set_window_icon(&self, window_icon: Option<Icon>)
pub fn set_window_icon(&self, window_icon: Option<Icon>)
Sets the window icon. On Windows and X11, this is typically the small icon in the top-left corner of the titlebar.
For more usage notes, see WindowBuilder::with_window_icon
.
Platform-specific
This only has an effect on Windows and X11.
sourcepub fn set_ime_spot(&self, position: LogicalPosition)
pub fn set_ime_spot(&self, position: LogicalPosition)
Sets location of IME candidate box in client area coordinates relative to the top left.
sourcepub fn get_current_monitor(&self) -> MonitorId
pub fn get_current_monitor(&self) -> MonitorId
Returns the monitor on which the window currently resides
sourcepub fn get_available_monitors(&self) -> AvailableMonitorsIter ⓘ
pub fn get_available_monitors(&self) -> AvailableMonitorsIter ⓘ
Returns the list of all the monitors available on the system.
This is the same as EventsLoop::get_available_monitors
, and is provided for convenience.
sourcepub fn get_primary_monitor(&self) -> MonitorId
pub fn get_primary_monitor(&self) -> MonitorId
Returns the primary monitor of the system.
This is the same as EventsLoop::get_primary_monitor
, and is provided for convenience.