Struct PWindow

pub struct PWindow(/* private fields */);

Methods from Deref<Target = Window>

pub fn get_proc_address(&mut self, procname: &str) -> *const c_void

Returns the address of the specified client API or extension function if it is supported by the context associated with this Window. If this Window is not the current context, it will make it the current context.

Wrapper for glfwGetProcAddress.

pub fn create_shared( &self, width: u32, height: u32, title: &str, mode: WindowMode<'_>, ) -> Option<(PWindow, GlfwReceiver<(f64, WindowEvent)>)>

Creates a new shared window.

Wrapper for glfwCreateWindow.

pub fn render_context(&mut self) -> PRenderContext

Returns a render context that can be shared between tasks, allowing for concurrent rendering.

pub fn should_close(&self) -> bool

Wrapper for glfwWindowShouldClose.

Examples found in repository

examples/simple2d.rs (line 21)

fn main() {
    let mut el = EventLoop::new(600, 600);
    let mut renderer = Renderer::new();

    /* default projection type is perspective */
    renderer.camera.set_projection(ProjectionType::Orthographic);
    renderer.add_light(Light { position: vec3(0.0, 0.0, 1.0), color: Vec3::ONE })
        .unwrap();

    /* we'll represent our player using a quad */
    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
        .unwrap();

    while !el.window.should_close() {
        el.update();

        /* we can modify the player by indexing into it in the renderer's meshes */
        let player = &mut renderer.meshes[player_handle];
        player.color = vec3(0.5, 0.0, el.time.sin());
        move_player(&el, &mut player.position);
    
        renderer.camera.update(Vec3::ZERO, &el);
    
        let frame = el.ui.frame(&mut el.window);
        frame.text("hello, world! this is imgui");

        unsafe {
            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
            ClearColor(0.1, 0.2, 0.3, 1.0);
            
            renderer.draw();
            el.ui.draw();
        }
    }
}

examples/ik.rs (line 45)

fn main() {
    let mut el = EventLoop::new(600, 600);
    let mut renderer = Renderer::new();

    unsafe {
        Enable(DEPTH_TEST);
    }

    /* default projection type is perspective */
    renderer.camera.set_projection(ProjectionType::Orthographic);
    renderer.add_light(Light { position: vec3(0.0, 0.0, 3.0), color: Vec3::ONE })
        .unwrap();

    /* we'll represent our player using a quad */
    let player_handle = renderer.add_mesh(Quad::new(Vec3::ONE * 0.1, Vec4::ONE).mesh())
        .unwrap();

    renderer.meshes[player_handle].position = Vec3::Z * 2.0; // so the player stays in front of everything

    let mut segments = vec![];
    for _ in 0..128 {
        let new_segment = Segment::new(vec3(0.0, 0.0, 0.0), 0.05, &mut renderer);

        segments.push(new_segment);
    }

    renderer.meshes[segments[0].handle].hidden = true;
    renderer.meshes[segments[segments.len()-1].handle].hidden = true;

    renderer.meshes[player_handle].hidden = true;
    

    segments[0].pos = Vec3::new(-2.0, -2.0, 0.0);

    let mut clamped_pos;
    let mut player_vel;
    let mut old_pos = Vec3::ZERO;

    while !el.window.should_close() {
        el.update();
        renderer.update();
        
        segments.iter_mut().for_each(|s| {
            s.update(&mut renderer);
        });
        
        let player = &mut renderer.meshes[player_handle];
        let mp = el.event_handler.mouse_pos / el.event_handler.width * 2.0;
        let clamped_player_pos = {
            // clamped_pos = lerp(clamped_pos, player.position, 0.1);
            clamped_pos = player.position;

            vec3(clamped_pos.x, clamped_pos.y, 0.0)
        };
        fabrik(&mut segments, {
            if el.event_handler.lmb {
                clamped_player_pos + vec3(mp.x, mp.y, 0.0)
            } else {
                clamped_player_pos
            }
        }, 0.0, 2);

        let first_segment_position = segments[0].pos;
        let seg_amm = segments.len() as f32;
        let distance = first_segment_position.distance(segments[segments.len()-1].pos);
        let len = segments[0].length;
        if distance > segments.len() as f32 * segments[0].length + segments[0].length {
            segments[0].pos += ((clamped_player_pos - first_segment_position) / seg_amm) * len * f32::powf(distance, 2.3);
        }

        player_vel = player.position - old_pos;
        old_pos = player.position;

        player.color = vec3(0.5, 0.0, el.time.sin());
        move_player(&el, &mut player.position);
    
        renderer.camera.update(lerp(renderer.camera.pos, player.position, 0.125), &el);
        renderer.camera.mouse_callback(el.event_handler.mouse_pos, &el.window);

        let frame = el.ui.frame(&mut el.window);
        frame.text("Hello, world! This is imgui.");
        frame.text(format!("p: {:.1}\nv: {:.3}", player.position, player_vel));

        unsafe {
            Clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);
            ClearColor(0.1, 0.2, 0.3, 1.0);
            
            renderer.draw();
            el.ui.draw();
        }
    }
}

pub fn set_should_close(&mut self, value: bool)

Wrapper for glfwSetWindowShouldClose.

pub fn set_title(&mut self, title: &str)

Sets the title of the window.

Wrapper for glfwSetWindowTitle.

pub fn get_pos(&self) -> (i32, i32)

Wrapper for glfwGetWindowPos.

pub fn set_pos(&mut self, xpos: i32, ypos: i32)

Wrapper for glfwSetWindowPos.

pub fn get_size(&self) -> (i32, i32)

Wrapper for glfwGetWindowSize.

pub fn set_size(&mut self, width: i32, height: i32)

Wrapper for glfwSetWindowSize.

pub fn get_frame_size(&self) -> (i32, i32, i32, i32)

Wrapper for glfwGetWindowFrameSize

Returns (left, top, right, bottom) edge window frame sizes, in screen coordinates.

pub fn get_framebuffer_size(&self) -> (i32, i32)

Wrapper for glfwGetFramebufferSize.

pub fn set_aspect_ratio(&mut self, numer: u32, denum: u32)

Wrapper for glfwSetWindowAspectRatio.

pub fn set_size_limits( &mut self, minwidth: Option<u32>, minheight: Option<u32>, maxwidth: Option<u32>, maxheight: Option<u32>, )

Wrapper for glfwSetWindowSizeLimits.

A value of None is equivalent to GLFW_DONT_CARE. If minwidth or minheight are None, no minimum size is enforced. If maxwidth or maxheight are None, no maximum size is enforced.

pub fn iconify(&mut self)

Wrapper for glfwIconifyWindow.

pub fn restore(&mut self)

Wrapper for glfwRestoreWindow.

pub fn maximize(&mut self)

Wrapper for glfwMaximizeWindow

pub fn show(&mut self)

Wrapper for glfwShowWindow.

pub fn hide(&mut self)

Wrapper for glfwHideWindow.

pub fn with_window_mode<T, F>(&self, f: F) -> T

where F: FnOnce(WindowMode<'_>) -> T,

Returns whether the window is fullscreen or windowed.

Example

window.with_window_mode(|mode| {
    match mode {
        glfw::Windowed => println!("Windowed"),
        glfw::FullScreen(m) => println!("FullScreen({})", m.get_name()),
    }
});

pub fn set_monitor( &mut self, mode: WindowMode<'_>, xpos: i32, ypos: i32, width: u32, height: u32, refresh_rate: Option<u32>, )

Wrapper for glfwSetWindowMonitor

pub fn focus(&mut self)

Wrapper for glfwFocusWindow

It is NOT recommended to use this function, as it steals focus from other applications and can be extremely disruptive to the user.

pub fn is_focused(&self) -> bool

Wrapper for glfwGetWindowAttrib called with FOCUSED.

pub fn is_iconified(&self) -> bool

Wrapper for glfwGetWindowAttrib called with ICONIFIED.

pub fn is_maximized(&self) -> bool

Wrapper for glfwGetWindowattrib called with MAXIMIZED.

pub fn get_client_api(&self) -> i32

Wrapper for glfwGetWindowAttrib called with CLIENT_API.

pub fn get_context_version(&self) -> Version

Wrapper for glfwGetWindowAttrib called with CONTEXT_VERSION_MAJOR, CONTEXT_VERSION_MINOR and CONTEXT_REVISION.

Returns

The client API version of the window’s context in a version struct.

pub fn get_context_robustness(&self) -> i32

Wrapper for glfwGetWindowAttrib called with CONTEXT_ROBUSTNESS.

pub fn is_opengl_forward_compat(&self) -> bool

Wrapper for glfwGetWindowAttrib called with OPENGL_FORWARD_COMPAT.

pub fn is_opengl_debug_context(&self) -> bool

Wrapper for glfwGetWindowAttrib called with OPENGL_DEBUG_CONTEXT.

pub fn get_opengl_profile(&self) -> i32

Wrapper for glfwGetWindowAttrib called with OPENGL_PROFILE.

pub fn is_resizable(&self) -> bool

Wrapper for glfwGetWindowAttrib called with RESIZABLE.

pub fn set_resizable(&mut self, resizable: bool)

Wrapper for glfwSetWindowAttrib called with RESIZABLE.

pub fn is_visible(&self) -> bool

Wrapper for glfwGetWindowAttrib called with VISIBLE.

pub fn is_decorated(&self) -> bool

Wrapper for glfwGetWindowAttrib called with DECORATED.

pub fn set_decorated(&mut self, decorated: bool)

Wrapper for glfwSetWindowAttrib called with DECORATED.

pub fn is_auto_iconify(&self) -> bool

Wrapper for glfwGetWindowAttrib called with AUTO_ICONIFY.

pub fn set_auto_iconify(&mut self, auto_iconify: bool)

Wrapper for glfwSetWindowAttrib called with AUTO_ICONIFY.

pub fn is_floating(&self) -> bool

Wrapper for glfwGetWindowAttrib called with FLOATING.

pub fn set_floating(&mut self, floating: bool)

Wrapper for glfwSetWindowAttrib called with FLOATING.

pub fn is_framebuffer_transparent(&self) -> bool

Wrapper for glfwGetWindowAttrib called with TRANSPARENT_FRAMEBUFFER.

pub fn is_focus_on_show(&self) -> bool

Wrapper for glfwGetWindowAttrib called with FOCUS_ON_SHOW.

pub fn set_focus_on_show(&mut self, focus_on_show: bool)

Wrapper for glfwSetWindowAttrib called with FOCUS_ON_SHOW.

pub fn is_hovered(&self) -> bool

Wrapper for glfwGetWindowAttrib called with HOVERED.

pub fn set_pos_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, i32, i32) + 'static,

Wrapper for glfwSetWindowPosCallback.

pub fn unset_pos_callback(&mut self)

Wrapper for glfwSetWindowPosCallback.

pub fn set_pos_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowPosCallback.

pub fn set_size_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, i32, i32) + 'static,

Wrapper for glfwSetWindowSizeCallback.

pub fn unset_size_callback(&mut self)

Wrapper for glfwSetWindowSizeCallback.

pub fn set_size_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowSizeCallback.

pub fn set_close_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window) + 'static,

Wrapper for glfwSetWindowCloseCallback.

pub fn unset_close_callback(&mut self)

Wrapper for glfwSetWindowCloseCallback.

pub fn set_close_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowCloseCallback.

pub fn set_refresh_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window) + 'static,

Wrapper for glfwSetWindowRefreshCallback.

pub fn unset_refresh_callback(&mut self)

Wrapper for glfwSetWindowRefreshCallback.

pub fn set_refresh_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowRefreshCallback.

pub fn set_focus_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, bool) + 'static,

Wrapper for glfwSetWindowFocusCallback.

pub fn unset_focus_callback(&mut self)

Wrapper for glfwSetWindowFocusCallback.

pub fn set_focus_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowFocusCallback.

pub fn set_iconify_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, bool) + 'static,

Wrapper for glfwSetWindowIconifyCallback.

pub fn unset_iconify_callback(&mut self)

Wrapper for glfwSetWindowIconifyCallback.

pub fn set_iconify_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowIconifyCallback.

pub fn set_framebuffer_size_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, i32, i32) + 'static,

Wrapper for glfwSetFramebufferSizeCallback.

pub fn unset_framebuffer_size_callback(&mut self)

Wrapper for glfwSetFramebufferSizeCallback.

pub fn set_framebuffer_size_polling(&mut self, should_poll: bool)

Wrapper for glfwSetFramebufferSizeCallback.

pub fn set_key_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, Key, i32, Action, Modifiers) + 'static,

Wrapper for glfwSetKeyCallback.

pub fn unset_key_callback(&mut self)

Wrapper for glfwSetKeyCallback.

pub fn set_key_polling(&mut self, should_poll: bool)

Wrapper for glfwSetKeyCallback.

pub fn set_char_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, char) + 'static,

Wrapper for glfwSetCharCallback.

pub fn unset_char_callback(&mut self)

Wrapper for glfwSetCharCallback.

pub fn set_char_polling(&mut self, should_poll: bool)

Wrapper for glfwSetCharCallback.

pub fn set_char_mods_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, char, Modifiers) + 'static,

Wrapper for glfwSetCharModsCallback.

pub fn unset_char_mods_callback(&mut self)

Wrapper for glfwSetCharModsCallback.

pub fn set_char_mods_polling(&mut self, should_poll: bool)

Wrapper for glfwSetCharModsCallback.

pub fn set_mouse_button_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, MouseButton, Action, Modifiers) + 'static,

Wrapper for glfwSetMouseButtonCallback.

pub fn unset_mouse_button_callback(&mut self)

Wrapper for glfwSetMouseButtonCallback.

pub fn set_mouse_button_polling(&mut self, should_poll: bool)

Wrapper for glfwSetMouseButtonCallback.

pub fn set_cursor_pos_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, f64, f64) + 'static,

Wrapper for glfwSetCursorPosCallback.

pub fn unset_cursor_pos_callback(&mut self)

Wrapper for glfwSetCursorPosCallback.

pub fn set_cursor_pos_polling(&mut self, should_poll: bool)

Wrapper for glfwSetCursorPosCallback.

pub fn set_cursor_enter_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, bool) + 'static,

Wrapper for glfwSetCursorEnterCallback.

pub fn unset_cursor_enter_callback(&mut self)

Wrapper for glfwSetCursorEnterCallback.

pub fn set_cursor_enter_polling(&mut self, should_poll: bool)

Wrapper for glfwSetCursorEnterCallback.

pub fn set_scroll_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, f64, f64) + 'static,

Wrapper for glfwSetScrollCallback.

pub fn unset_scroll_callback(&mut self)

Wrapper for glfwSetScrollCallback.

pub fn set_scroll_polling(&mut self, should_poll: bool)

Wrapper for glfwSetScrollCallback.

pub fn set_drag_and_drop_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, Vec<PathBuf>) + 'static,

Wrapper for glfwSetDropCallback.

pub fn unset_drag_and_drop_callback(&mut self)

Wrapper for glfwSetDropCallback.

pub fn set_drag_and_drop_polling(&mut self, should_poll: bool)

Wrapper for glfwSetDropCallback.

pub fn set_maximize_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, bool) + 'static,

Wrapper for glfwSetWindowMaximizeCallback.

pub fn unset_maximize_callback(&mut self)

Wrapper for glfwSetWindowMaximizeCallback.

pub fn set_maximize_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowMaximizeCallback.

pub fn set_content_scale_callback<T>(&mut self, callback: T)

where T: FnMut(&mut Window, f32, f32) + 'static,

Wrapper for glfwSetWindowContentScaleCallback.

pub fn unset_content_scale_callback(&mut self)

Wrapper for glfwSetWindowContentScaleCallback.

pub fn set_content_scale_polling(&mut self, should_poll: bool)

Wrapper for glfwSetWindowContentScaleCallback.

pub fn set_all_polling(&mut self, should_poll: bool)

Starts or stops polling for all available events

pub fn get_cursor_mode(&self) -> CursorMode

Wrapper for glfwGetInputMode called with CURSOR.

pub fn set_cursor_mode(&mut self, mode: CursorMode)

Wrapper for glfwSetInputMode called with CURSOR.

pub fn set_cursor(&mut self, cursor: Option<Cursor>) -> Option<Cursor>

Wrapper for glfwSetCursor using Cursor

The window will take ownership of the cursor, and will not Drop it until it is replaced or the window itself is destroyed.

Returns the previously set Cursor or None if no cursor was set.

pub fn set_icon_from_pixels(&mut self, images: Vec<PixelImage>)

Sets the window icon via glfwSetWindowIcon from a set a set of vectors containing pixels in RGBA format (one pixel per 32-bit integer)

pub fn has_sticky_keys(&self) -> bool

Wrapper for glfwGetInputMode called with STICKY_KEYS.

pub fn set_sticky_keys(&mut self, value: bool)

Wrapper for glfwSetInputMode called with STICKY_KEYS.

pub fn has_sticky_mouse_buttons(&self) -> bool

Wrapper for glfwGetInputMode called with STICKY_MOUSE_BUTTONS.

pub fn set_sticky_mouse_buttons(&mut self, value: bool)

Wrapper for glfwSetInputMode called with STICKY_MOUSE_BUTTONS.

pub fn does_store_lock_key_mods(&self) -> bool

Wrapper for glfwGetInputMode called with LOCK_KEY_MODS

pub fn set_store_lock_key_mods(&mut self, value: bool)

Wrapper for glfwSetInputMode called with LOCK_KEY_MODS

pub fn uses_raw_mouse_motion(&self) -> bool

Wrapper for glfwGetInputMode called with RAW_MOUSE_MOTION

pub fn set_raw_mouse_motion(&mut self, value: bool)

Wrapper for glfwSetInputMode called with RAW_MOUSE_MOTION

pub fn get_key(&self, key: Key) -> Action

Wrapper for glfwGetKey.

pub fn get_mouse_button(&self, button: MouseButton) -> Action

Wrapper for glfwGetMouseButton.

pub fn get_cursor_pos(&self) -> (f64, f64)

Wrapper for glfwGetCursorPos.

pub fn set_cursor_pos(&mut self, xpos: f64, ypos: f64)

Wrapper for glfwSetCursorPos.

pub fn set_clipboard_string(&mut self, string: &str)

Wrapper for glfwGetClipboardString.

pub fn get_clipboard_string(&self) -> Option<String>

Wrapper for glfwGetClipboardString.

pub fn get_opacity(&self) -> f32

Wrapper for glfwGetWindowOpacity.

pub fn set_opacity(&mut self, opacity: f32)

Wrapper for glfwSetWindowOpacity.

pub fn request_attention(&mut self)

Wrapper for glfwRequestWindowAttention.

pub fn get_content_scale(&self) -> (f32, f32)

Wrapper for glfwGetWindowContentScale.

pub fn get_x11_window(&self) -> *mut c_void

Wrapper for glfwGetX11Window

pub fn get_glx_context(&self) -> *mut c_void

Wrapper for glfwGetGLXContext

Trait Implementations

impl Debug for PWindow

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for PWindow

type Target = Window

The resulting type after dereferencing.

fn deref(&self) -> &<PWindow as Deref>::Target

Dereferences the value.

impl DerefMut for PWindow

fn deref_mut(&mut self) -> &mut <PWindow as Deref>::Target

Mutably dereferences the value.

impl HasDisplayHandle for PWindow

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.

impl HasWindowHandle for PWindow

fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>

Get a handle to the window.

impl Send for PWindow

impl Sync for PWindow