gl-headless 0.2.2

Easiest way to create a headless OpenGL context
Documentation 
1
2
3
4
5
6
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
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

# gl-headless


[![Latest Version](https://img.shields.io/crates/v/gl-headless.svg)](https://crates.io/crates/gl-headless)
[![Docs](https://docs.rs/gl-headless/badge.svg)](https://docs.rs/gl-headless)
[![License](https://img.shields.io/github/license/vallentin/gl-headless.svg)](https://github.com/vallentin/gl-headless)

Easiest way to create a headless OpenGL context.

Simply add <code>#[[gl_headless]]</code> to any function (even `main`), then call that function as you otherwise would. Within the scope of the function, an OpenGL context will be available.

See all available options in the documentation for
<code>#[[gl_headless]]</code>.

## Simple Example


```toml
[dependencies]
gl = "0.14"
gl-headless = "0.2"
```

```rust
use gl_headless::gl_headless;

#[gl_headless]

unsafe fn main() {
    let (mut major, mut minor) = (0, 0);
    gl::GetIntegerv(gl::MAJOR_VERSION, &mut major);
    gl::GetIntegerv(gl::MINOR_VERSION, &mut minor);
    println!("OpenGL {major}.{minor}");
}
```

## Specify OpenGL Version


By default <code>#[[gl_headless]]</code> attempts to create an OpenGL 4.6 context. To use a specific version add, e.g. `version = "3.3"`:

```rust
use gl_headless::gl_headless;

#[gl_headless(version = "3.3")]

unsafe fn main() {
    let (mut major, mut minor) = (0, 0);
    gl::GetIntegerv(gl::MAJOR_VERSION, &mut major);
    gl::GetIntegerv(gl::MINOR_VERSION, &mut minor);
    println!("OpenGL {major}.{minor}");
}
```

## Parameters & Return Type


Specify function parameters and return type as you otherwise would:

```rust
use gl_headless::gl_headless;

fn main() {
    let version = get_version("OpenGL");
    println!("{version}");
}

#[gl_headless]

fn get_version(prefix: &str) -> String {
    let (mut major, mut minor) = (0, 0);
    unsafe {
        gl::GetIntegerv(gl::MAJOR_VERSION, &mut major);
        gl::GetIntegerv(gl::MINOR_VERSION, &mut minor);
    }
    format!("{prefix} {major}.{minor}")
}
```

## Multiple Functions


Multiple functions can use <code>#[[gl_headless]]</code>:

```rust
use gl_headless::gl_headless;

fn main() {
    unsafe {
        example1();
        example2();
    }
}

#[gl_headless(version = "3.3")]

unsafe fn example1() {
    let (mut major, mut minor) = (0, 0);
    gl::GetIntegerv(gl::MAJOR_VERSION, &mut major);
    gl::GetIntegerv(gl::MINOR_VERSION, &mut minor);
    println!("OpenGL {major}.{minor}");
}

#[gl_headless]

unsafe fn example2() {
    let mut handle = 0;
    gl::CreateBuffers(1, &mut handle);

    let data: [f32; 5] = [1.0, 2.0, 3.0, 4.0, 5.0];
    gl::NamedBufferData(
        handle,
        std::mem::size_of_val(&data) as _,
        data.as_ptr() as *const _,
        gl::STATIC_DRAW,
    );

    let mut byte_size = 0;
    gl::GetNamedBufferParameteriv(handle, gl::BUFFER_SIZE, &mut byte_size);
    let float_count = (byte_size as usize) / std::mem::size_of::<f32>() as usize;

    let mut floats = vec![0.0_f32; float_count];
    gl::GetNamedBufferSubData(
        handle,
        0,
        std::mem::size_of_val(floats.as_slice()) as _,
        floats.as_mut_ptr() as *mut _,
    );

    println!("Write: {:?}", data);
    println!("Read:  {:?}", floats);

    assert_eq!(data, floats.as_slice());
}
```

[gl_headless]: https://docs.rs/gl-headless/*/gl_headless/attr.gl_headless.html