aboutsummaryrefslogtreecommitdiffstats
path: root/build.rs
blob: e15d270bf3c8d890cc73d624159503fbbb4d78fa (plain)
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
extern crate gl_generator;
extern crate khronos_api;

use std::env;
use std::fs::File;
use std::path::PathBuf;

fn main() {
    let target = env::var("TARGET").unwrap();
    let dest = PathBuf::from(&env::var("OUT_DIR").unwrap());

    if target.contains("windows") {
        let mut file = File::create(&dest.join("wgl_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StaticGenerator,
                                        gl_generator::registry::Ns::Wgl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::WGL_XML, vec![],
                                        "1.0", "core", &mut file).unwrap();

        let mut file = File::create(&dest.join("wgl_extra_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StructGenerator,
                                        gl_generator::registry::Ns::Wgl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::WGL_XML,
                                        vec![
                                            "WGL_ARB_create_context".to_string(),
                                            "WGL_ARB_create_context_profile".to_string(),
                                            "WGL_ARB_create_context_robustness".to_string(),
                                            "WGL_ARB_extensions_string".to_string(),
                                            "WGL_ARB_framebuffer_sRGB".to_string(),
                                            "WGL_ARB_multisample".to_string(),
                                            "WGL_ARB_pixel_format".to_string(),
                                            "WGL_EXT_create_context_es2_profile".to_string(),
                                            "WGL_EXT_extensions_string".to_string(),
                                            "WGL_EXT_framebuffer_sRGB".to_string(),
                                            "WGL_EXT_swap_control".to_string(),
                                        ],
                                        "1.0", "core", &mut file).unwrap();

        let mut file = File::create(&dest.join("egl_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StructGenerator,
                                        gl_generator::registry::Ns::Egl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::EGL_XML,
                                        vec![
                                            "EGL_KHR_create_context".to_string(),
                                            "EGL_EXT_create_context_robustness".to_string(),
                                            "EGL_KHR_create_context_no_error".to_string(),
                                            "EGL_KHR_platform_x11".to_string(),
                                            "EGL_KHR_platform_android".to_string(),
                                            "EGL_KHR_platform_wayland".to_string(),
                                            "EGL_KHR_platform_gbm".to_string(),
                                            "EGL_EXT_platform_base".to_string(),
                                            "EGL_EXT_platform_x11".to_string(),
                                            "EGL_MESA_platform_gbm".to_string(),
                                            "EGL_EXT_platform_wayland".to_string(),
                                            "EGL_EXT_platform_device".to_string(),
                                        ],
                                        "1.5", "core", &mut file).unwrap();
    }

    if target.contains("linux") {
        let mut file = File::create(&dest.join("glx_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StructGenerator,
                                        gl_generator::registry::Ns::Glx,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::GLX_XML, vec![],
                                        "1.4", "core", &mut file).unwrap();

        let mut file = File::create(&dest.join("glx_extra_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StructGenerator,
                                        gl_generator::registry::Ns::Glx,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::GLX_XML,
                                        vec![
                                            "GLX_ARB_create_context".to_string(),
                                            "GLX_ARB_create_context_profile".to_string(),
                                            "GLX_ARB_create_context_robustness".to_string(),
                                            "GLX_ARB_framebuffer_sRGB".to_string(),
                                            "GLX_EXT_framebuffer_sRGB".to_string(),
                                            "GLX_EXT_swap_control".to_string(),
                                            "GLX_SGI_swap_control".to_string()
                                        ],
                                        "1.4", "core", &mut file).unwrap();

        let mut file = File::create(&dest.join("egl_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StructGenerator,
                                        gl_generator::registry::Ns::Egl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::EGL_XML,
                                        vec![
                                            "EGL_KHR_create_context".to_string(),
                                            "EGL_EXT_create_context_robustness".to_string(),
                                            "EGL_KHR_create_context_no_error".to_string(),
                                            "EGL_KHR_platform_x11".to_string(),
                                            "EGL_KHR_platform_android".to_string(),
                                            "EGL_KHR_platform_wayland".to_string(),
                                            "EGL_KHR_platform_gbm".to_string(),
                                            "EGL_EXT_platform_base".to_string(),
                                            "EGL_EXT_platform_x11".to_string(),
                                            "EGL_MESA_platform_gbm".to_string(),
                                            "EGL_EXT_platform_wayland".to_string(),
                                            "EGL_EXT_platform_device".to_string(),
                                        ],
                                        "1.5", "core", &mut file).unwrap();
    }

    if target.contains("android") {
        let mut file = File::create(&dest.join("egl_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StaticStructGenerator,
                                        gl_generator::registry::Ns::Egl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::EGL_XML,
                                        vec![
                                            "EGL_KHR_create_context".to_string(),
                                            "EGL_EXT_create_context_robustness".to_string(),
                                            "EGL_KHR_create_context_no_error".to_string(),
                                            "EGL_KHR_platform_x11".to_string(),
                                            "EGL_KHR_platform_android".to_string(),
                                            "EGL_KHR_platform_wayland".to_string(),
                                            "EGL_KHR_platform_gbm".to_string(),
                                            "EGL_EXT_platform_base".to_string(),
                                            "EGL_EXT_platform_x11".to_string(),
                                            "EGL_MESA_platform_gbm".to_string(),
                                            "EGL_EXT_platform_wayland".to_string(),
                                            "EGL_EXT_platform_device".to_string(),
                                        ],
                                        "1.5", "core", &mut file).unwrap();
    }

    if target.contains("ios") {
        let mut file = File::create(&dest.join("egl_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StaticStructGenerator,
                                        gl_generator::registry::Ns::Egl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::EGL_XML,
                                        vec![
                                            "EGL_KHR_create_context".to_string(),
                                            "EGL_EXT_create_context_robustness".to_string(),
                                            "EGL_KHR_create_context_no_error".to_string(),
                                            "EGL_KHR_platform_x11".to_string(),
                                            "EGL_KHR_platform_android".to_string(),
                                            "EGL_KHR_platform_wayland".to_string(),
                                            "EGL_KHR_platform_gbm".to_string(),
                                            "EGL_EXT_platform_base".to_string(),
                                            "EGL_EXT_platform_x11".to_string(),
                                            "EGL_MESA_platform_gbm".to_string(),
                                            "EGL_EXT_platform_wayland".to_string(),
                                            "EGL_EXT_platform_device".to_string(),
                                        ],
                                        "1.5", "core", &mut file).unwrap();

        let mut file = File::create(&dest.join("gles2_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::StaticStructGenerator,
                                        gl_generator::registry::Ns::Gles2,
                                        gl_generator::Fallbacks::None,
                                        khronos_api::GL_XML,
                                        vec![],
                                        "2.0", "core", &mut file).unwrap();
    }

    if target.contains("darwin") {
        let mut file = File::create(&dest.join("gl_bindings.rs")).unwrap();
        gl_generator::generate_bindings(gl_generator::GlobalGenerator,
                                        gl_generator::registry::Ns::Gl,
                                        gl_generator::Fallbacks::All,
                                        khronos_api::GL_XML,
                                        vec!["GL_EXT_framebuffer_object".to_string()],
                                        "3.2", "core", &mut file).unwrap();
    }

    // TODO: only build the bindings below if we run tests/examples

    let mut file = File::create(&dest.join("test_gl_bindings.rs")).unwrap();
    gl_generator::generate_bindings(gl_generator::StructGenerator,
                                    gl_generator::registry::Ns::Gles2,
                                    gl_generator::Fallbacks::All,
                                    khronos_api::GL_XML, vec![],
                                    "2.0", "core", &mut file).unwrap();
}