Crate glfw[][src]

Expand description

An idiomatic wrapper for the GLFW library.

Example

extern crate glfw;

use glfw::{Action, Context, Key};

fn main() {
   let mut glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();

    // Create a windowed mode window and its OpenGL context
    let (mut window, events) = glfw.create_window(300, 300, "Hello this is window", glfw::WindowMode::Windowed)
        .expect("Failed to create GLFW window.");

    // Make the window's context current
    window.make_current();
    window.set_key_polling(true);

    // Loop until the user closes the window
    while !window.should_close() {
        // Swap front and back buffers
        window.swap_buffers();

        // Poll for and process events
        glfw.poll_events();
        for (_, event) in glfw::flush_messages(&events) {
            println!("{:?}", event);
            match event {
                glfw::WindowEvent::Key(Key::Escape, _, Action::Press, _) => {
                    window.set_should_close(true)
                },
                _ => {},
            }
        }
    }
}

Cargo Features

Use the vulkan feature flag to enable all Vulkan functions and types.

Use the image feature flag to enable use of the image library for cursors and icons.

Use the all feature flag to enable both at the same time.

Re-exports

pub use self::MouseButton::Button1 as MouseButtonLeft;
pub use self::MouseButton::Button2 as MouseButtonRight;
pub use self::MouseButton::Button3 as MouseButtonMiddle;

Modules

Low-level function bindings and constants pertaining to the underlying GLFW library.

Structs

Represents a window cursor that can be used to display any of the standard cursors or load a custom cursor from an image.

Formats the type using aliases rather than the default variant names.

An iterator that yields until no more messages are contained in the Receiver’s queue.

State of a gamepad.

Describes the gamma ramp of a monitor.

A token from which to call various GLFW functions. It can be obtained by calling the init function. This cannot be sent to other tasks, and should only be initialized on the main platform thread. Whilst this might make performing some operations harder, this is to ensure thread safety is enforced statically.

A joystick handle.

Joystick hats.

Key modifiers (e.g., Shift, Control, Alt, Super)

A struct that wraps a *GLFWmonitor handle.

When not using the image library, or if you just want to, you can specify an image from its raw pixel data using this structure.

A rendering context that can be shared between tasks.

Describes a single video mode.

A struct that wraps a *GLFWwindow handle.

Enums

Input actions.

Client API tokens.

Specifies the API to use to create the context

ContextReleaseBehavior specifies the release behavior to be used by the context.

Context robustness tokens.

Cursor modes.

Tokens corresponding to various error types.

Axis identifier tokens.

Button identifier tokens.

An error that might be returned when glfw::init is called.

Initialization hints that can be set using the init_hint function.

Joystick events.

Joystick identifier tokens.

Input keys.

Monitor events.

Mouse buttons. The MouseButtonLeft, MouseButtonRight, and MouseButtonMiddle aliases are supplied for convenience.

OpenGL profile tokens.

Standard cursors provided by GLFW

Specifies how the context should handle swapping the buffers.

Window event messages.

Window hints that can be set using the window_hint function.

Describes the mode of a window

Statics

A callback that triggers a task failure when an error is encountered.

A callback that logs each error as it is encountered without triggering a task failure.

Traits

Methods common to renderable contexts

Functions

The function to be used with the FAIL_ON_ERRORS callback.

Returns an iterator that yields until no more messages are contained in the Receiver’s queue. This is useful for event handling where the blocking behaviour of Receiver::iter is undesirable.

Wrapper around glfwGetKeyName

Wrapper around glfwGetKeyScancode.

Wrapper for glfwGetVersion.

Wrapper for glfwGetVersionString.

Initializes the GLFW library. This must be called on the main platform thread.

Sets hints for the next initialization of GLFW.

key_nameDeprecated

Wrapper around glfwGetKeyName

The function to be used with the LOG_ERRORS callback.

Wrapper for glfwMakeContextCurrent.

Replacement for String::from_raw_buf

Like string_from_c_str, but handles null pointers correctly

Replacement for ToCStr::with_c_str

Type Definitions

An error callback. This can be supplied with some user data to be passed to the callback function when it is triggered.

An OpenGL process address.

An joystick callback. This can be supplied with some user data to be passed to the callback function when it is triggered.

An monitor callback. This can be supplied with some user data to be passed to the callback function when it is triggered.

Keyboard code returned by the OS

Unique identifier for a Window.