2014-08-03 04:49:48 +10:00
//! The purpose of this library is to provide an OpenGL context on as many
//! platforms as possible.
//!
//! # Building a window
2014-09-04 19:38:33 +10:00
//!
2014-08-03 04:49:48 +10:00
//! There are two ways to create a window:
2014-09-04 19:38:33 +10:00
//!
2014-08-03 04:49:48 +10:00
//! - Calling `Window::new()`.
//! - Calling `let builder = WindowBuilder::new()` then `builder.build()`.
//!
//! The first way is the simpliest way and will give you default values.
//!
//! The second way allows you to customize the way your window and GL context
//! will look and behave.
2014-10-05 04:17:02 +11:00
//!
//! # Features
//!
//! This crate has two Cargo features: `window` and `headless`.
//!
//! - `window` allows you to create regular windows and enables the `WindowBuilder` object.
//! - `headless` allows you to do headless rendering, and enables
//! the `HeadlessRendererBuilder` object.
//!
//! By default only `window` is enabled.
2014-08-03 04:49:48 +10:00
2015-04-03 17:33:51 +11:00
#[ macro_use ]
extern crate lazy_static ;
2015-04-27 22:25:53 +10:00
#[ macro_use ]
extern crate shared_library ;
2014-07-27 18:55:37 +10:00
extern crate libc ;
2014-12-02 04:24:15 +11:00
#[ cfg(target_os = " windows " ) ]
extern crate winapi ;
2015-01-26 13:52:17 +11:00
#[ cfg(target_os = " windows " ) ]
2015-03-28 21:07:41 +11:00
extern crate kernel32 ;
2015-01-26 13:52:17 +11:00
#[ cfg(target_os = " windows " ) ]
2015-06-24 08:05:37 +10:00
extern crate shell32 ;
#[ cfg(target_os = " windows " ) ]
2015-03-30 14:58:13 +11:00
extern crate gdi32 ;
2015-01-26 13:52:17 +11:00
#[ cfg(target_os = " windows " ) ]
2015-03-30 14:58:13 +11:00
extern crate user32 ;
2015-05-21 02:46:10 +10:00
#[ cfg(target_os = " windows " ) ]
extern crate dwmapi ;
2015-06-05 23:38:21 +10:00
#[ cfg(any(target_os = " macos " , target_os = " ios " )) ]
2015-03-22 16:31:32 +11:00
#[ macro_use ]
extern crate objc ;
#[ cfg(target_os = " macos " ) ]
2015-06-16 07:28:29 +10:00
extern crate cgl ;
#[ cfg(target_os = " macos " ) ]
2014-10-04 23:49:39 +10:00
extern crate cocoa ;
#[ cfg(target_os = " macos " ) ]
extern crate core_foundation ;
2014-11-05 04:03:38 +11:00
#[ cfg(target_os = " macos " ) ]
2015-06-04 14:13:18 +10:00
extern crate core_graphics ;
2015-08-30 06:54:17 +10:00
#[ cfg(any(target_os = " linux " , target_os = " freebsd " , target_os = " dragonfly " )) ]
2015-05-07 21:20:25 +10:00
extern crate x11_dl ;
2015-12-05 06:39:52 +11:00
#[ cfg(any(target_os = " linux " , target_os = " freebsd " , target_os = " dragonfly " )) ]
#[ macro_use(wayland_env) ]
extern crate wayland_client ;
2014-10-04 23:49:39 +10:00
2014-07-30 21:11:49 +10:00
pub use events ::* ;
2015-02-16 19:29:37 +11:00
pub use headless ::{ HeadlessRendererBuilder , HeadlessContext } ;
2015-09-26 02:04:55 +10:00
pub use window ::{ WindowBuilder , WindowProxy , PollEventsIterator , WaitEventsIterator } ;
2015-09-24 17:11:59 +10:00
pub use window ::{ AvailableMonitorsIter , MonitorId , get_available_monitors , get_primary_monitor } ;
2015-03-19 08:16:35 +11:00
pub use native_monitor ::NativeMonitorId ;
2014-08-13 22:52:12 +10:00
2015-06-16 18:15:31 +10:00
use std ::io ;
2015-09-29 02:19:36 +10:00
#[ cfg(not(target_os = " macos " )) ]
2015-07-25 23:57:03 +10:00
use std ::cmp ::Ordering ;
2015-06-16 18:15:31 +10:00
2015-04-24 17:51:23 +10:00
mod api ;
2015-04-02 17:27:32 +11:00
mod platform ;
2014-07-27 20:59:45 +10:00
mod events ;
2015-02-16 19:29:37 +11:00
mod headless ;
mod window ;
2014-07-28 04:38:27 +10:00
2015-09-26 02:04:55 +10:00
pub mod os ;
/// Represents an OpenGL context and the Window or environment around it.
///
/// # Example
///
/// ```ignore
/// let window = Window::new().unwrap();
///
/// unsafe { window.make_current() };
///
/// loop {
/// for event in window.poll_events() {
/// match(event) {
/// // process events here
/// _ => ()
/// }
/// }
///
/// // draw everything here
///
/// window.swap_buffers();
/// std::old_io::timer::sleep(17);
/// }
/// ```
pub struct Window {
window : platform ::Window ,
}
2015-04-30 21:23:37 +10:00
/// Trait that describes objects that have access to an OpenGL context.
pub trait GlContext {
/// Sets the context as the current context.
2015-06-16 18:15:31 +10:00
unsafe fn make_current ( & self ) -> Result < ( ) , ContextError > ;
2015-04-30 21:23:37 +10:00
/// Returns true if this context is the current one in this thread.
fn is_current ( & self ) -> bool ;
/// Returns the address of an OpenGL function.
2015-11-04 21:27:50 +11:00
fn get_proc_address ( & self , addr : & str ) -> * const ( ) ;
2015-04-30 21:23:37 +10:00
/// Swaps the buffers in case of double or triple buffering.
///
/// You should call this function every time you have finished rendering, or the image
2015-06-16 18:15:31 +10:00
/// may not be displayed on the screen.
2015-04-30 21:23:37 +10:00
///
/// **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.
2015-06-16 18:15:31 +10:00
fn swap_buffers ( & self ) -> Result < ( ) , ContextError > ;
2015-04-30 21:23:37 +10:00
/// Returns the OpenGL API being used.
fn get_api ( & self ) -> Api ;
/// Returns the pixel format of the main framebuffer of the context.
fn get_pixel_format ( & self ) -> PixelFormat ;
}
2014-11-06 02:42:18 +11:00
/// Error that can happen while creating a window or a headless renderer.
2015-09-20 16:42:32 +10:00
#[ derive(Debug) ]
2014-11-06 02:42:18 +11:00
pub enum CreationError {
OsError ( String ) ,
2015-07-21 03:43:36 +10:00
/// TODO: remove this error
2014-12-29 01:53:24 +11:00
NotSupported ,
2015-09-20 16:42:32 +10:00
NoBackendAvailable ( Box < std ::error ::Error + Send > ) ,
2015-07-21 03:34:34 +10:00
RobustnessNotSupported ,
2015-07-21 03:38:57 +10:00
OpenGlVersionNotSupported ,
2015-07-21 03:42:32 +10:00
NoAvailablePixelFormat ,
2014-11-06 02:42:18 +11:00
}
2015-01-24 12:50:06 +11:00
impl CreationError {
fn to_string ( & self ) -> & str {
2015-02-22 10:07:35 +11:00
match * self {
2015-03-26 05:57:38 +11:00
CreationError ::OsError ( ref text ) = > & text ,
2015-02-22 10:07:35 +11:00
CreationError ::NotSupported = > " Some of the requested attributes are not supported " ,
2015-09-20 16:42:32 +10:00
CreationError ::NoBackendAvailable ( _ ) = > " No backend is available " ,
2015-08-05 11:02:55 +10:00
CreationError ::RobustnessNotSupported = > " You requested robustness, but it is \
2015-07-21 03:34:34 +10:00
not supported . " ,
2015-07-21 03:38:57 +10:00
CreationError ::OpenGlVersionNotSupported = > " The requested OpenGL version is not \
supported . " ,
2015-07-21 03:42:32 +10:00
CreationError ::NoAvailablePixelFormat = > " Couldn't find any pixel format that matches \
the criterias . " ,
2014-11-06 02:42:18 +11:00
}
}
}
2015-01-24 12:50:06 +11:00
impl std ::fmt ::Display for CreationError {
fn fmt ( & self , formatter : & mut std ::fmt ::Formatter ) -> Result < ( ) , std ::fmt ::Error > {
formatter . write_str ( self . to_string ( ) )
}
}
impl std ::error ::Error for CreationError {
fn description ( & self ) -> & str {
self . to_string ( )
2015-09-20 16:42:32 +10:00
}
fn cause ( & self ) -> Option < & std ::error ::Error > {
match * self {
CreationError ::NoBackendAvailable ( ref err ) = > Some ( & * * err ) ,
_ = > None
}
2015-01-24 12:50:06 +11:00
}
}
2015-06-16 18:15:31 +10:00
/// Error that can happen when manipulating an OpenGL context.
#[ derive(Debug) ]
pub enum ContextError {
IoError ( io ::Error ) ,
ContextLost ,
}
2015-08-05 11:01:38 +10:00
impl ContextError {
fn to_string ( & self ) -> & str {
use std ::error ::Error ;
match * self {
ContextError ::IoError ( ref err ) = > err . description ( ) ,
2015-08-05 20:10:38 +10:00
ContextError ::ContextLost = > " Context lost "
2015-08-05 11:01:38 +10:00
}
}
}
impl std ::fmt ::Display for ContextError {
fn fmt ( & self , formatter : & mut std ::fmt ::Formatter ) -> Result < ( ) , std ::fmt ::Error > {
formatter . write_str ( self . to_string ( ) )
}
}
impl std ::error ::Error for ContextError {
fn description ( & self ) -> & str {
self . to_string ( )
}
}
2014-11-19 03:55:26 +11:00
/// All APIs related to OpenGL that you can possibly get while using glutin.
2015-01-24 12:50:06 +11:00
#[ derive(Debug, Clone, Copy, PartialEq, Eq) ]
2014-11-19 03:55:26 +11:00
pub enum Api {
/// The classical OpenGL. Available on Windows, Linux, OS/X.
OpenGl ,
/// OpenGL embedded system. Available on Linux, Android.
OpenGlEs ,
2015-01-30 04:36:03 +11:00
/// OpenGL for the web. Very similar to OpenGL ES.
WebGl ,
2014-11-19 03:55:26 +11:00
}
2015-05-01 13:06:22 +10:00
/// Describes the requested OpenGL context profiles.
#[ derive(Debug, Clone, Copy, PartialEq, Eq) ]
pub enum GlProfile {
/// Include all the immediate more functions and definitions.
Compatibility ,
/// Include all the future-compatible functions and definitions.
Core ,
}
2015-02-19 02:49:53 +11:00
/// Describes the OpenGL API and version that are being requested when a context is created.
#[ derive(Debug, Copy, Clone) ]
pub enum GlRequest {
/// Request the latest version of the "best" API of this platform.
///
/// On desktop, will try OpenGL.
Latest ,
/// Request a specific version of a specific API.
///
/// Example: `GlRequest::Specific(Api::OpenGl, (3, 3))`.
Specific ( Api , ( u8 , u8 ) ) ,
/// If OpenGL is available, create an OpenGL context with the specified `opengl_version`.
/// Else if OpenGL ES or WebGL is available, create a context with the
/// specified `opengles_version`.
GlThenGles {
/// The version to use for OpenGL.
opengl_version : ( u8 , u8 ) ,
/// The version to use for OpenGL ES.
opengles_version : ( u8 , u8 ) ,
} ,
}
2015-04-30 13:05:47 +10:00
impl GlRequest {
/// Extract the desktop GL version, if any.
pub fn to_gl_version ( & self ) -> Option < ( u8 , u8 ) > {
match self {
& GlRequest ::Specific ( Api ::OpenGl , version ) = > Some ( version ) ,
& GlRequest ::GlThenGles { opengl_version : version , .. } = > Some ( version ) ,
_ = > None ,
}
}
}
/// The minimum core profile GL context. Useful for getting the minimum
/// required GL version while still running on OSX, which often forbids
/// the compatibility profile features.
pub static GL_CORE : GlRequest = GlRequest ::Specific ( Api ::OpenGl , ( 3 , 2 ) ) ;
2015-06-23 01:58:32 +10:00
/// Specifies the tolerance of the OpenGL context to faults. If you accept raw OpenGL commands
/// and/or raw shader code from an untrusted source, you should definitely care about this.
#[ derive(Debug, Copy, Clone, PartialEq, Eq) ]
pub enum Robustness {
/// Not everything is checked. Your application can crash if you do something wrong with your
/// shaders.
NotRobust ,
2015-06-25 17:34:33 +10:00
/// The driver doesn't check anything. This option is very dangerous. Please know what you're
/// doing before using it. See the `GL_KHR_no_error` extension.
///
/// Since this option is purely an optimisation, no error will be returned if the backend
/// doesn't support it. Instead it will automatically fall back to `NotRobust`.
NoError ,
2015-06-23 01:58:32 +10:00
/// Everything is checked to avoid any crash. The driver will attempt to avoid any problem,
/// but if a problem occurs the behavior is implementation-defined. You are just guaranteed not
/// to get a crash.
RobustNoResetNotification ,
/// Same as `RobustNoResetNotification` but the context creation doesn't fail if it's not
/// supported.
TryRobustNoResetNotification ,
/// Everything is checked to avoid any crash. If a problem occurs, the context will enter a
/// "context lost" state. It must then be recreated. For the moment, glutin doesn't provide a
/// way to recreate a context with the same window :-/
RobustLoseContextOnReset ,
/// Same as `RobustLoseContextOnReset` but the context creation doesn't fail if it's not
/// supported.
TryRobustLoseContextOnReset ,
}
2015-12-19 21:24:09 +11:00
/// The behavior of the driver when you change the current context.
#[ derive(Debug, Copy, Clone, PartialEq, Eq) ]
pub enum ReleaseBehavior {
/// Doesn't do anything. Most notably doesn't flush.
None ,
/// Flushes the context that was previously current as if `glFlush` was called.
Flush ,
}
2015-04-04 03:36:57 +11:00
#[ derive(Debug, Copy, Clone) ]
2015-01-13 11:22:37 +11:00
pub enum MouseCursor {
/// The platform-dependent default cursor.
Default ,
/// A simple crosshair.
Crosshair ,
/// A hand (often used to indicate links in web browsers).
Hand ,
/// Self explanatory.
Arrow ,
/// Indicates something is to be moved.
Move ,
/// Indicates text that may be selected or edited.
Text ,
/// Program busy indicator.
Wait ,
/// Help indicator (often rendered as a "?")
Help ,
/// Progress indicator. Shows that processing is being done. But in contrast
/// with "Wait" the user may still interact with the program. Often rendered
2015-01-26 14:28:12 +11:00
/// as a spinning beach ball, or an arrow with a watch or hourglass.
2015-01-13 11:22:37 +11:00
Progress ,
/// Cursor showing that something cannot be done.
NotAllowed ,
ContextMenu ,
NoneCursor ,
Cell ,
VerticalText ,
Alias ,
Copy ,
NoDrop ,
Grab ,
Grabbing ,
AllScroll ,
ZoomIn ,
ZoomOut ,
/// Indicate that some edge is to be moved. For example, the 'SeResize' cursor
/// is used when the movement starts from the south-east corner of the box.
EResize ,
NResize ,
NeResize ,
NwResize ,
SResize ,
SeResize ,
SwResize ,
WResize ,
EwResize ,
NsResize ,
NeswResize ,
NwseResize ,
ColResize ,
RowResize ,
}
2015-03-27 03:04:01 +11:00
/// Describes how glutin handles the cursor.
2015-04-04 03:36:57 +11:00
#[ derive(Debug, Copy, Clone) ]
2015-03-27 03:04:01 +11:00
pub enum CursorState {
/// Normal cursor behavior.
Normal ,
/// The cursor will be invisible when over the window.
Hide ,
/// Grabs the mouse cursor. The cursor's motion will be confined to this
/// window and the window has exclusive access to further events regarding
/// the cursor.
///
/// This is useful for first-person cameras for example.
Grab ,
}
2015-02-17 01:36:32 +11:00
/// Describes a possible format. Unused.
#[ allow(missing_docs) ]
2015-03-01 21:46:58 +11:00
#[ derive(Debug, Clone) ]
2015-02-17 01:36:32 +11:00
pub struct PixelFormat {
2015-03-01 21:07:46 +11:00
pub hardware_accelerated : bool ,
2015-04-30 23:41:21 +10:00
pub color_bits : u8 ,
2015-02-17 01:36:32 +11:00
pub alpha_bits : u8 ,
pub depth_bits : u8 ,
pub stencil_bits : u8 ,
pub stereoscopy : bool ,
pub double_buffer : bool ,
pub multisampling : Option < u16 > ,
pub srgb : bool ,
}
2015-09-22 02:57:35 +10:00
2015-12-19 21:24:09 +11:00
/// Describes how the backend should choose a pixel format.
2015-12-19 23:06:50 +11:00
// TODO: swap method? (swap, copy)
2015-09-21 18:11:32 +10:00
#[ derive(Clone, Debug) ]
pub struct PixelFormatRequirements {
2015-12-19 21:24:09 +11:00
/// If true, only hardware-accelerated formats will be conisdered. If false, only software
/// renderers. `None` means "don't care". Default is `Some(true)`.
pub hardware_accelerated : Option < bool > ,
/// Minimum number of bits for the color buffer, excluding alpha. `None` means "don't care".
/// The default is `Some(24)`.
2015-09-21 18:11:32 +10:00
pub color_bits : Option < u8 > ,
2015-12-19 21:24:09 +11:00
/// If true, the color buffer must be in a floating point format. Default is `false`.
///
/// Using floating points allows you to write values outside of the `[0.0, 1.0]` range.
pub float_color_buffer : bool ,
/// Minimum number of bits for the alpha in the color buffer. `None` means "don't care".
/// The default is `Some(8)`.
2015-09-21 18:11:32 +10:00
pub alpha_bits : Option < u8 > ,
2015-12-19 21:24:09 +11:00
/// Minimum number of bits for the depth buffer. `None` means "don't care".
/// The default value is `Some(24)`.
pub depth_bits : Option < u8 > ,
/// Minimum number of bits for the depth buffer. `None` means "don't care".
/// The default value is `Some(8)`.
pub stencil_bits : Option < u8 > ,
/// If true, only double-buffered formats will be considered. If false, only single-buffer
/// formats. `None` means "don't care". The default is `Some(true)`.
pub double_buffer : Option < bool > ,
/// Contains the minimum number of samples per pixel in the color, depth and stencil buffers.
/// `None` means "don't care". Default is `None`.
/// A value of `Some(0)` indicates that multisampling must not be enabled.
pub multisampling : Option < u16 > ,
/// If true, only stereoscopic formats will be considered. If false, only non-stereoscopic
/// formats. The default is `false`.
2015-09-21 18:11:32 +10:00
pub stereoscopy : bool ,
2015-12-19 21:24:09 +11:00
/// If true, only sRGB-capable formats will be considered. If false, don't care.
/// The default is `false`.
pub srgb : bool ,
/// The behavior when changing the current context. Default is `Flush`.
pub release_behavior : ReleaseBehavior ,
2015-09-21 18:11:32 +10:00
}
2015-09-21 17:33:41 +10:00
impl Default for PixelFormatRequirements {
2015-09-21 22:42:05 +10:00
#[ inline ]
2015-09-21 17:33:41 +10:00
fn default ( ) -> PixelFormatRequirements {
PixelFormatRequirements {
2015-12-19 21:24:09 +11:00
hardware_accelerated : Some ( true ) ,
color_bits : Some ( 24 ) ,
float_color_buffer : false ,
alpha_bits : Some ( 8 ) ,
depth_bits : Some ( 24 ) ,
stencil_bits : Some ( 8 ) ,
2015-12-31 09:09:27 +11:00
double_buffer : None ,
2015-09-21 17:33:41 +10:00
multisampling : None ,
stereoscopy : false ,
2015-12-19 21:24:09 +11:00
srgb : false ,
release_behavior : ReleaseBehavior ::Flush ,
2015-09-21 17:33:41 +10:00
}
}
}
2015-09-21 17:15:53 +10:00
/// Attributes to use when creating a window.
#[ derive(Clone) ]
pub struct WindowAttributes {
/// The dimensions of the window. If this is `None`, some platform-specific dimensions will be
/// used.
///
/// The default is `None`.
pub dimensions : Option < ( u32 , u32 ) > ,
2015-11-09 22:13:52 +11:00
/// The minimum dimensions a window can be, If this is `None`, the window will have no minimum dimensions (aside from reserved).
2015-11-09 20:42:54 +11:00
///
/// The default is `None`.
pub min_dimensions : Option < ( u32 , u32 ) > ,
2015-11-09 22:13:52 +11:00
/// The maximum dimensions a window can be, If this is `None`, the maximum will have no maximum or will be set to the primary monitor's dimensions by the platform.
2015-11-09 20:42:54 +11:00
///
/// The default is `None`.
pub max_dimensions : Option < ( u32 , u32 ) > ,
2015-09-21 17:15:53 +10:00
/// If `Some`, the window will be in fullscreen mode with the given monitor.
///
/// The default is `None`.
2015-09-24 17:11:59 +10:00
pub monitor : Option < platform ::MonitorId > ,
2015-09-21 17:15:53 +10:00
/// The title of the window in the title bar.
///
/// The default is `"glutin window"`.
pub title : String ,
/// Whether the window should be immediately visible upon creation.
///
/// The default is `true`.
pub visible : bool ,
/// Whether the the window should be transparent. If this is true, writing colors
/// with alpha values different than `1.0` will produce a transparent window.
///
/// The default is `false`.
pub transparent : bool ,
/// Whether the window should have borders and bars.
///
/// The default is `true`.
pub decorations : bool ,
2015-09-22 02:57:35 +10:00
/// [iOS only] Enable multitouch, see [UIView#multipleTouchEnabled]
/// (https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIView_Class/#//apple_ref/occ/instp/UIView/multipleTouchEnabled)
2015-09-21 17:15:53 +10:00
pub multitouch : bool ,
}
impl Default for WindowAttributes {
2015-09-21 22:42:05 +10:00
#[ inline ]
2015-09-21 17:15:53 +10:00
fn default ( ) -> WindowAttributes {
WindowAttributes {
dimensions : None ,
2015-11-09 20:42:54 +11:00
min_dimensions : None ,
max_dimensions : None ,
2015-09-21 17:15:53 +10:00
monitor : None ,
title : " glutin window " . to_owned ( ) ,
visible : true ,
transparent : false ,
decorations : true ,
multitouch : false ,
}
}
}
2015-09-20 17:29:22 +10:00
/// Attributes to use when creating an OpenGL context.
#[ derive(Clone) ]
pub struct GlAttributes < S > {
/// An existing context to share the new the context with.
///
/// The default is `None`.
pub sharing : Option < S > ,
/// Version to try create. See `GlRequest` for more infos.
///
/// The default is `Latest`.
pub version : GlRequest ,
/// OpenGL profile to use.
///
/// The default is `None`.
pub profile : Option < GlProfile > ,
/// Whether to enable the `debug` flag of the context.
///
/// Debug contexts are usually slower but give better error reporting.
///
/// The default is `true` in debug mode and `false` in release mode.
pub debug : bool ,
/// How the OpenGL context should detect errors.
///
/// The default is `NotRobust` because this is what is typically expected when you create an
/// OpenGL context. However for safety you should consider `TryRobustLoseContextOnReset`.
pub robustness : Robustness ,
/// Whether to use vsync. If vsync is enabled, calling `swap_buffers` will block until the
/// screen refreshes. This is typically used to prevent screen tearing.
///
/// The default is `false`.
pub vsync : bool ,
}
2015-09-21 17:57:35 +10:00
impl < S > GlAttributes < S > {
/// Turns the `sharing` parameter into another type by calling a closure.
2015-09-21 22:42:05 +10:00
#[ inline ]
2015-09-21 17:57:35 +10:00
pub fn map_sharing < F , T > ( self , f : F ) -> GlAttributes < T > where F : FnOnce ( S ) -> T {
GlAttributes {
sharing : self . sharing . map ( f ) ,
version : self . version ,
profile : self . profile ,
debug : self . debug ,
robustness : self . robustness ,
vsync : self . vsync ,
}
}
}
2015-09-20 17:29:22 +10:00
impl < S > Default for GlAttributes < S > {
2015-09-21 22:42:05 +10:00
#[ inline ]
2015-09-20 17:29:22 +10:00
fn default ( ) -> GlAttributes < S > {
GlAttributes {
sharing : None ,
version : GlRequest ::Latest ,
profile : None ,
debug : cfg ! ( debug_assertions ) ,
robustness : Robustness ::NotRobust ,
vsync : false ,
}
}
}
2015-03-19 08:16:35 +11:00
mod native_monitor {
/// Native platform identifier for a monitor. Different platforms use fundamentally different types
/// to represent a monitor ID.
2015-07-19 21:53:40 +10:00
#[ derive(Clone, PartialEq, Eq) ]
2015-03-19 08:16:35 +11:00
pub enum NativeMonitorId {
/// Cocoa and X11 use a numeric identifier to represent a monitor.
Numeric ( u32 ) ,
/// Win32 uses a Unicode string to represent a monitor.
Name ( String ) ,
/// Other platforms (Android) don't support monitor identification.
Unavailable
}
}