/*!
Easy to use, light OpenGL 3+ wrapper

glin aims to be a mostly bindless, simple wrapper over opengl that simplifies and provides a safe
api for opengl without aiming to cover every possible case but instead making it easy to use unsafe
calls in combination with the safe api when one needs to use extensions or any opengl api that is
not covered (yet).

That means for example that in certain cases functions will take GLenums directly as parameters
when the particular parameter can change or have several options not originally on the standard
through extensions, while parameters that have clearly defined options in the standard will have
an enum representation.

# Usage

The first thing needed to use glin is a Context. A context needs an instance implementing GLWindow
to be able to load the Open GL or Open GL ES functions:

```no_run
#[cfg(feature = "glfw")]
use glfw::Context;

#[cfg(feature = "glfw")]
fn main(){
    let mut glfw_instance = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();

    glfw_instance.window_hint(glfw::WindowHint::ContextVersion(4, 1));
    glfw_instance.window_hint(glfw::WindowHint::OpenGlProfile( glfw::OpenGlProfileHint::Core ));
    glfw_instance.window_hint(glfw::WindowHint::OpenGlForwardCompat(true));
    let (mut window, receiver) = glfw_instance
        .create_window(1280, 720, "triangle", glfw::WindowMode::Windowed).unwrap();
    window.set_key_polling(true);
    window.make_current();
    glfw_instance.set_swap_interval(glfw::SwapInterval::Sync(1));

    let gl = glin::Context::new(&mut window).unwrap();
}

#[cfg(feature = "egli")]
use egli::Display;

#[cfg(feature = "egli")]
fn main(){
    use std::ptr;

    let mut display = Display::from_default_display()
        .expect("failed to get EGL display");

    display.initialize()
        .expect("failed to initialize");

    let configs = display.config_filter()
                         .choose_configs()
                         .expect("failed to get configurations");

    let config = *configs.first().unwrap();
    let surface = display.create_window_surface(config, ptr::null_mut()).unwrap();

    let context = display
        .create_context_with_client_version(config, egli::ContextClientVersion::OpenGlEs2)
        .unwrap();

    display.make_current(&surface, &surface, &context).unwrap();

    let gl = glin::Context::new(&mut display).unwrap();
}


#[cfg(feature = "glutin")]
use glutin::GlContext;

#[cfg(feature = "glutin")]
fn main(){
    let mut events_loop = glutin::EventsLoop::new();
    let window = glutin::WindowBuilder::new()
        .with_title("Hello, world!")
        .with_dimensions(1024, 768);
    let context = glutin::ContextBuilder::new()
        .with_vsync(true);
    let mut gl_window = glutin::GlWindow::new(window, context, &events_loop).unwrap();

    unsafe {
        gl_window.make_current().unwrap();
    }

    let gl = glin::Context::new(&mut gl_window).unwrap();
}

#[cfg(not(any(feature="glfw", feature="egli", feature="glutin")))]
fn main() {}
```

Once we have a context we can start creating glin objects and issuing draw calls through it.

# Creating glin Objects

To create any glin object you need a context and the constructor calls are done through that context
which generally returns a builder that can be customized with more parameters to finally create
the desired object:

```no_run
# use std::mem;
use glin::gl;

struct Vertex{
    position: [f32;3],
}

fn main(){
    # let gl: glin::Context = unsafe{ mem::MaybeUninit::uninit().assume_init() };
    let buffer_object: glin::Buffer<Vertex> = gl.new_buffer().empty().unwrap();
    let program = gl.new_program().from_src(&[
            (gl::VERTEX_SHADER, "// vertex shader source"),
            (gl::FRAGMENT_SHADER, "// fragment shader source"),
        ]).unwrap();
    let _texture = gl.new_texture().from_format(glin::texture::Format{
        target: gl::TEXTURE_2D,
        internal_format: gl::RGBA,
        width: 640,
        height: 480,
        levels: 1,
        #[cfg(all(not(feature = "gles"), not(feature="webgl")))]
        samples: 0,
    });
}
```

# Drawing

Drawing geometry in glin is done through vaos. A VAO is just an OpenGL vertex array object but also
contains a memory reference to the buffers it uses internally.

Apart from the geometry in order to draw something in glin you'll need a glsl program, it's
uniforms and optionally some properties that customize the drawing.

To use a set of properties, just call with on an exisiting context to create a new context with
the original properties + the new properties passed as parameter:

```no_run
#[macro_use] extern crate glin;
use std::mem;
use glin::gl;

#[derive(VertexFormat)]
struct Vertex{
    position: [f32;3],
}

fn main(){
    let gl: glin::Context = unsafe{ mem::uninitialized() };
    let buffer_object: glin::Buffer<Vertex> = gl.new_buffer().empty().unwrap();
    let program = gl.new_program().from_src(&[
            (gl::VERTEX_SHADER, "// vertex shader source"),
            (gl::FRAGMENT_SHADER, "// fragment shader source"),
        ]).unwrap();
    let vao: glin::SimpleVao<Vertex> = gl.new_simple_vao()
        .empty_from_bindings(&program, gl::TRIANGLES)
        .unwrap();
    let gl = gl.with(&[glin::Property::DepthTest(true)]);
    gl.draw(&vao, &program, &[]).is_ok();
}
```
*/
// #![warn(clippy::all)]
#[macro_use] extern crate mopa;
extern crate regex;
#[macro_use] extern crate bitflags;
#[cfg(feature = "webgl")]
#[macro_use] extern crate stdweb;
#[cfg(feature = "webgl")]
#[macro_use] extern crate stdweb_derive;
#[cfg(feature = "webgl")]
extern crate serde;
#[cfg(feature = "webgl")]
#[macro_use] extern crate serde_derive;
#[cfg(feature = "webgl")]
extern crate densevec;
#[cfg(feature = "webgl")]
extern crate mem_cmp;
#[macro_use] extern crate log;
#[macro_use] extern crate lazy_static;
extern crate indexmap;
#[cfg(feature="glsl_optimizer")]
extern crate glsl_optimizer_sys;

#[doc(inline)]
pub use program::Program;
#[doc(inline)]
pub use attributes::{VertexFormat, Bindings};
#[doc(inline)]
pub use vao::{Vao, VaoRange, VaoDraw};
#[doc(inline)]
pub use vao::simple_vao::{self, SimpleVao};
#[doc(inline)]
pub use fbo::Fbo;
#[doc(inline)]
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
pub use buffer::{Buffer, SharedBuffer, BufferStorage, SharedBufferStorage,
    MapReadFlags, MapWriteFlags, MapReadWriteFlags, BufferRange, BufferRangeMut};
#[doc(inline)]
#[cfg(any(feature = "gles", feature="webgl"))]
pub use buffer::{Buffer, SharedBuffer, BufferRange, BufferRangeMut};
#[doc(inline)]
pub use texture::{Texture, TextureSampler};
#[doc(inline)]
pub use cubemap::CubeMap;
#[doc(inline)]
pub use state::{Property, Vendor};
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
#[doc(inline)]
pub use state::{DebugInfo, DebugSeverity, DebugSource, DebugType};
#[doc(inline)]
pub use context::{
    Context, CreationContext, CreationContextMut, CreationProxy,
    SurfaceCreationContext, Screen, RenderSurface
};
#[doc(inline)]
pub use state::State;
#[doc(inline)]
pub use utils::Rect;
#[doc(inline)]
pub use features::traits::{Image, CubemapImage};
#[cfg(not(feature="webgl"))]
#[doc(inline)]
pub use features::traits::GlWindow;
#[cfg(feature="webgl")]
#[doc(inline)]
pub use features::traits::WebGlWindow;
#[doc(inline)]
pub use error::{Error, ErrorKind};
#[doc(inline)]
pub use offscreen_buffer::{OffscreenBuffer, UntypedOffscreenBuffer};
#[doc(inline)]
pub use sampler::Sampler;
#[doc(inline)]
pub use utils::{gl_format_from_internal, gl_type_from_internal, Color};
#[doc(inline)]
pub use state::{Capabilities, Viewport};
#[doc(inline)]
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
pub use sync::Fence;
#[cfg(not(feature="webgl"))]
pub use debug_group::DebugGroup;
pub use indexmap::{IndexMap as HashMap, indexmap as hash_map};

#[cfg(feature = "gles")]
pub use gles as gl;

#[cfg(feature = "webgl")]
pub use webgl2 as gl;

use std::result;

#[macro_use] pub mod macros;
#[macro_use] mod utils;
pub mod program;
pub mod texture;
pub mod cubemap;
pub mod buffer;
pub mod fbo;
mod state;
mod context;
mod features;
pub mod attributes;
pub mod vao;
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
pub mod gl;
#[cfg(feature = "gles")]
pub mod gles;
#[cfg(feature = "webgl")]
pub mod webgl2;
mod error;
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
pub mod query;
mod offscreen_buffer;
mod sampler;
#[cfg(all(not(feature = "gles"), not(feature="webgl")))]
mod sync;
#[cfg(not(feature="webgl"))]
mod debug_group;

pub type IndexT = u32;
pub type Result<T> = result::Result<T,Error>;

#[cfg(feature = "derive")]
#[allow(unused_imports)]
#[macro_use]
extern crate glin_derive;

#[cfg(feature = "derive")]
#[doc(hidden)]
pub use glin_derive::*;



use std::os::raw::c_uint;

#[repr(C)]
pub struct DrawElementsIndirectCommand{
    pub count: c_uint,
    pub instance_count: c_uint,
    pub first_index: c_uint,
    pub base_vertex: c_uint,
    pub base_instance: c_uint,
}

#[repr(C)]
pub struct DrawArraysIndirectCommand{
    pub count: c_uint,
    pub instance_count: c_uint,
    pub first: c_uint,
    pub base_instance: c_uint,
}