├── .gitmodules ├── LICENSE ├── README.org ├── cosmogfx.c ├── cosmogfx.h ├── default.nix ├── demo.c ├── dtrampoline.c ├── dtrampoline.h ├── elf_loader.c ├── elf_loader.h ├── fake ├── alloca.h ├── arpa │ └── inet.h ├── assert.h ├── dlfcn.h ├── dwmapi.h ├── elf.h ├── fcntl.h ├── inttypes.h ├── limits.h ├── netdb.h ├── netinet │ └── in.h ├── setjmp.h ├── stdarg.h ├── stdbool.h ├── stddef.h ├── stdint.h ├── stdio.h ├── stdlib.h ├── string.h ├── sys │ ├── mman.h │ ├── socket.h │ ├── stat.h │ ├── types.h │ └── user.h ├── unistd.h ├── windows.h ├── windowsx.h ├── wingdi.h └── winuser.h ├── gl.c ├── gl.h ├── helper.c ├── helper ├── fbsd ├── nbsd └── obsd ├── mk ├── renderer.c └── renderer.h /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "glcv"] 2 | path = glcv 3 | url = git@github.com:jacereda/glcv 4 | [submodule "microui"] 5 | path = microui 6 | url = git@github.com:jacereda/microui 7 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 jacereda 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.org: -------------------------------------------------------------------------------- 1 | * Build-once run-anywhere OpenGL application 2 | 3 | Standing on the shoulders of [[https://justine.lol/cosmopolitan/index.html][Cosmopolitan libc]] this proof of concept 4 | application should run on Windows and Unix systems running X11 (tested 5 | on NixOS/Debian/FreeBSD for now, feedback about other systems 6 | welcome). 7 | 8 | I don't have any interest right now in macOS given their reluctance to 9 | follow OpenGL/Vulkan standards, but it should be easy to make it run 10 | on that as well. 11 | 12 | * Building 13 | 14 | Just modify the =mk= script to point to your =zipobj.com= and run it. 15 | -------------------------------------------------------------------------------- /cosmogfx.c: -------------------------------------------------------------------------------- 1 | #include "cosmogfx.h" 2 | #include "elf_loader.h" 3 | 4 | #include "glcv/src/cv.c" 5 | 6 | intptr_t osEvent_xlib(ev *e); 7 | intptr_t osEvent_win(ev *e); 8 | extern int cvrun_xlib(int, char **); 9 | extern int cvrun_win(int, char **); 10 | 11 | #define cvrun cvrun_xlib 12 | #define osEvent osEvent_xlib 13 | #include "glcv/src/xlib.c" 14 | #undef osEvent 15 | #undef cvrun 16 | 17 | #include 18 | #undef cvrun 19 | #define cvrun cvrun_win 20 | #define osEvent osEvent_win 21 | #include "glcv/src/win.c" 22 | #undef osEvent 23 | #undef cvrun 24 | 25 | intptr_t 26 | osEvent(ev *e) 27 | { 28 | if (IsWindows()) 29 | return osEvent_win(e); 30 | else 31 | return osEvent_xlib(e); 32 | } 33 | 34 | static int 35 | cont(void **p, int argc, char **argv) 36 | { 37 | z_dlopen = p[0]; 38 | z_dlsym = p[1]; 39 | z_dlclose = p[2]; 40 | z_dlerror = p[3]; 41 | cvrun_xlib(argc, argv); 42 | } 43 | 44 | int 45 | cosmogfx_init(int argc, char **argv, char **envp) 46 | { 47 | 48 | dtrampoline_init(); 49 | if (IsWindows()) 50 | cvrun_win(argc, argv); 51 | else { 52 | argv[argc] = (char *)cont; 53 | char interp[256]; 54 | elf_interp(interp, sizeof(interp), "/usr/bin/env"); 55 | const char *helper; 56 | if (IsOpenbsd()) 57 | helper = "/zip/helper/obsd"; 58 | else if (IsFreebsd()) 59 | helper = "/zip/helper/fbsd"; 60 | else if (IsNetbsd()) 61 | helper = "/zip/helper/nbsd"; 62 | else 63 | helper = "/zip/helper/linux"; 64 | elf_exec(helper, interp, argc, argv, envp); 65 | } 66 | } 67 | 68 | STATIC_YOINK("zip_uri_support"); 69 | -------------------------------------------------------------------------------- /cosmogfx.h: -------------------------------------------------------------------------------- 1 | int cosmogfx_init(int, char **, char **); 2 | -------------------------------------------------------------------------------- /default.nix: -------------------------------------------------------------------------------- 1 | { pkgs ? import {} 2 | }: 3 | with pkgs; 4 | { 5 | shellEnv = 6 | let 7 | cosmopolitan-src = fetchTarball { 8 | name = "cosmopolitan"; 9 | url = "https://github.com/jacereda/cosmopolitan/archive/200fd7a55.tar.gz"; 10 | sha256 = "0jbvsmqrqnwlc9981wlwl6nyyf16mf54k6iwyshw7qzy676g2xd9"; 11 | }; 12 | cosmopolitan = callPackage cosmopolitan-src {}; 13 | mylibs = with xorg; [ glibc libGL libX11 libXcursor libXrender libxkbcommon ]; 14 | in 15 | stdenv.mkDerivation { 16 | name = "shell-environment"; 17 | nativeBuildInputs = with pkgs; [ gdb clang-tools cosmopolitan ]; 18 | buildInputs = mylibs; 19 | LD_LIBRARY_PATH = lib.makeLibraryPath mylibs; 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /demo.c: -------------------------------------------------------------------------------- 1 | #include "microui.h" 2 | #include "renderer.h" 3 | #include "cv.h" 4 | 5 | static char logbuf[64000]; 6 | static int logbuf_updated = 0; 7 | static float bg[3] = { 90, 95, 100 }; 8 | 9 | static void 10 | write_log(const char *text) 11 | { 12 | if (logbuf[0]) { 13 | strcat(logbuf, "\n"); 14 | } 15 | strcat(logbuf, text); 16 | logbuf_updated = 1; 17 | } 18 | 19 | static void 20 | test_window(mu_Context *ctx) 21 | { 22 | /* do window */ 23 | if (mu_begin_window(ctx, "Demo Window", mu_rect(40, 40, 300, 450))) { 24 | mu_Container *win = mu_get_current_container(ctx); 25 | win->rect.w = mu_max(win->rect.w, 240); 26 | win->rect.h = mu_max(win->rect.h, 300); 27 | 28 | /* window info */ 29 | if (mu_header(ctx, "Window Info")) { 30 | mu_Container *win = mu_get_current_container(ctx); 31 | char buf[64]; 32 | mu_layout_row(ctx, 2, (int[]) { 54, -1 }, 0); 33 | mu_label(ctx, "Position:"); 34 | sprintf(buf, "%d, %d", win->rect.x, win->rect.y); 35 | mu_label(ctx, buf); 36 | mu_label(ctx, "Size:"); 37 | sprintf(buf, "%d, %d", win->rect.w, win->rect.h); 38 | mu_label(ctx, buf); 39 | } 40 | 41 | /* labels + buttons */ 42 | if (mu_header_ex(ctx, "Test Buttons", MU_OPT_EXPANDED)) { 43 | mu_layout_row(ctx, 3, (int[]) { 86, -110, -1 }, 0); 44 | mu_label(ctx, "Test buttons 1:"); 45 | if (mu_button(ctx, "Button 1")) { 46 | write_log("Pressed button 1"); 47 | } 48 | if (mu_button(ctx, "Button 2")) { 49 | write_log("Pressed button 2"); 50 | } 51 | mu_label(ctx, "Test buttons 2:"); 52 | if (mu_button(ctx, "Button 3")) { 53 | write_log("Pressed button 3"); 54 | } 55 | if (mu_button(ctx, "Popup")) { 56 | mu_open_popup(ctx, "Test Popup"); 57 | } 58 | if (mu_begin_popup(ctx, "Test Popup")) { 59 | mu_button(ctx, "Hello"); 60 | mu_button(ctx, "World"); 61 | mu_end_popup(ctx); 62 | } 63 | } 64 | 65 | /* tree */ 66 | if (mu_header_ex(ctx, "Tree and Text", MU_OPT_EXPANDED)) { 67 | mu_layout_row(ctx, 2, (int[]) { 140, -1 }, 0); 68 | mu_layout_begin_column(ctx); 69 | if (mu_begin_treenode(ctx, "Test 1")) { 70 | if (mu_begin_treenode(ctx, "Test 1a")) { 71 | mu_label(ctx, "Hello"); 72 | mu_label(ctx, "world"); 73 | mu_end_treenode(ctx); 74 | } 75 | if (mu_begin_treenode(ctx, "Test 1b")) { 76 | if (mu_button(ctx, "Button 1")) { 77 | write_log("Pressed button 1"); 78 | } 79 | if (mu_button(ctx, "Button 2")) { 80 | write_log("Pressed button 2"); 81 | } 82 | mu_end_treenode(ctx); 83 | } 84 | mu_end_treenode(ctx); 85 | } 86 | if (mu_begin_treenode(ctx, "Test 2")) { 87 | mu_layout_row(ctx, 2, (int[]) { 54, 54 }, 0); 88 | if (mu_button(ctx, "Button 3")) { 89 | write_log("Pressed button 3"); 90 | } 91 | if (mu_button(ctx, "Button 4")) { 92 | write_log("Pressed button 4"); 93 | } 94 | if (mu_button(ctx, "Button 5")) { 95 | write_log("Pressed button 5"); 96 | } 97 | if (mu_button(ctx, "Button 6")) { 98 | write_log("Pressed button 6"); 99 | } 100 | mu_end_treenode(ctx); 101 | } 102 | if (mu_begin_treenode(ctx, "Test 3")) { 103 | static int checks[3] = { 1, 0, 1 }; 104 | mu_checkbox(ctx, "Checkbox 1", &checks[0]); 105 | mu_checkbox(ctx, "Checkbox 2", &checks[1]); 106 | mu_checkbox(ctx, "Checkbox 3", &checks[2]); 107 | mu_end_treenode(ctx); 108 | } 109 | mu_layout_end_column(ctx); 110 | 111 | mu_layout_begin_column(ctx); 112 | mu_layout_row(ctx, 1, (int[]) { -1 }, 0); 113 | mu_text(ctx, 114 | "Lorem ipsum dolor sit amet, consectetur adipiscing " 115 | "elit. Maecenas lacinia, sem eu lacinia molestie, mi risus faucibus " 116 | "ipsum, eu varius magna felis a nulla."); 117 | mu_layout_end_column(ctx); 118 | } 119 | 120 | /* background color sliders */ 121 | if (mu_header_ex(ctx, "Background Color", MU_OPT_EXPANDED)) { 122 | mu_layout_row(ctx, 2, (int[]) { -78, -1 }, 74); 123 | /* sliders */ 124 | mu_layout_begin_column(ctx); 125 | mu_layout_row(ctx, 2, (int[]) { 46, -1 }, 0); 126 | mu_label(ctx, "Red:"); 127 | mu_slider(ctx, &bg[0], 0, 255); 128 | mu_label(ctx, "Green:"); 129 | mu_slider(ctx, &bg[1], 0, 255); 130 | mu_label(ctx, "Blue:"); 131 | mu_slider(ctx, &bg[2], 0, 255); 132 | mu_layout_end_column(ctx); 133 | /* color preview */ 134 | mu_Rect r = mu_layout_next(ctx); 135 | mu_draw_rect( 136 | ctx, r, mu_color(bg[0], bg[1], bg[2], 255)); 137 | char buf[32]; 138 | sprintf(buf, "#%02X%02X%02X", (int)bg[0], (int)bg[1], 139 | (int)bg[2]); 140 | mu_draw_control_text( 141 | ctx, buf, r, MU_COLOR_TEXT, MU_OPT_ALIGNCENTER); 142 | } 143 | 144 | mu_end_window(ctx); 145 | } 146 | } 147 | 148 | static void 149 | log_window(mu_Context *ctx) 150 | { 151 | if (mu_begin_window(ctx, "Log Window", mu_rect(350, 40, 300, 200))) { 152 | /* output text panel */ 153 | mu_layout_row(ctx, 1, (int[]) { -1 }, -25); 154 | mu_begin_panel(ctx, "Log Output"); 155 | mu_Container *panel = mu_get_current_container(ctx); 156 | mu_layout_row(ctx, 1, (int[]) { -1 }, -1); 157 | mu_text(ctx, logbuf); 158 | mu_end_panel(ctx); 159 | if (logbuf_updated) { 160 | panel->scroll.y = panel->content_size.y; 161 | logbuf_updated = 0; 162 | } 163 | 164 | /* input textbox + submit button */ 165 | static char buf[128]; 166 | int submitted = 0; 167 | mu_layout_row(ctx, 2, (int[]) { -70, -1 }, 0); 168 | if (mu_textbox(ctx, buf, sizeof(buf)) & MU_RES_SUBMIT) { 169 | mu_set_focus(ctx, ctx->last_id); 170 | submitted = 1; 171 | } 172 | if (mu_button(ctx, "Submit")) { 173 | submitted = 1; 174 | } 175 | if (submitted) { 176 | write_log(buf); 177 | buf[0] = '\0'; 178 | } 179 | 180 | mu_end_window(ctx); 181 | } 182 | } 183 | 184 | static int 185 | uint8_slider(mu_Context *ctx, unsigned char *value, int low, int high) 186 | { 187 | static float tmp; 188 | mu_push_id(ctx, &value, sizeof(value)); 189 | tmp = *value; 190 | int res = 191 | mu_slider_ex(ctx, &tmp, low, high, 0, "%.0f", MU_OPT_ALIGNCENTER); 192 | *value = tmp; 193 | mu_pop_id(ctx); 194 | return res; 195 | } 196 | 197 | static void 198 | style_window(mu_Context *ctx) 199 | { 200 | static struct { 201 | const char *label; 202 | int idx; 203 | } colors[] = { { "text:", MU_COLOR_TEXT }, 204 | { "border:", MU_COLOR_BORDER }, 205 | { "windowbg:", MU_COLOR_WINDOWBG }, 206 | { "titlebg:", MU_COLOR_TITLEBG }, 207 | { "titletext:", MU_COLOR_TITLETEXT }, 208 | { "panelbg:", MU_COLOR_PANELBG }, 209 | { "button:", MU_COLOR_BUTTON }, 210 | { "buttonhover:", MU_COLOR_BUTTONHOVER }, 211 | { "buttonfocus:", MU_COLOR_BUTTONFOCUS }, 212 | { "base:", MU_COLOR_BASE }, 213 | { "basehover:", MU_COLOR_BASEHOVER }, 214 | { "basefocus:", MU_COLOR_BASEFOCUS }, 215 | { "scrollbase:", MU_COLOR_SCROLLBASE }, 216 | { "scrollthumb:", MU_COLOR_SCROLLTHUMB }, { NULL } }; 217 | 218 | if (mu_begin_window(ctx, "Style Editor", mu_rect(350, 250, 300, 240))) { 219 | int sw = mu_get_current_container(ctx)->body.w * 0.14; 220 | mu_layout_row(ctx, 6, (int[]) { 80, sw, sw, sw, sw, -1 }, 0); 221 | for (int i = 0; colors[i].label; i++) { 222 | mu_label(ctx, colors[i].label); 223 | uint8_slider(ctx, &ctx->style->colors[i].r, 0, 255); 224 | uint8_slider(ctx, &ctx->style->colors[i].g, 0, 255); 225 | uint8_slider(ctx, &ctx->style->colors[i].b, 0, 255); 226 | uint8_slider(ctx, &ctx->style->colors[i].a, 0, 255); 227 | mu_draw_rect( 228 | ctx, mu_layout_next(ctx), ctx->style->colors[i]); 229 | } 230 | mu_end_window(ctx); 231 | } 232 | } 233 | 234 | static void 235 | process_frame(mu_Context *ctx) 236 | { 237 | mu_begin(ctx); 238 | style_window(ctx); 239 | log_window(ctx); 240 | test_window(ctx); 241 | mu_end(ctx); 242 | } 243 | 244 | static int 245 | text_width(mu_Font font, const char *text, int len) 246 | { 247 | return r_get_text_width(text, len); 248 | } 249 | 250 | static int 251 | text_height(mu_Font font) 252 | { 253 | return r_get_text_height(); 254 | } 255 | 256 | static void 257 | report(const char *name, const char *s) 258 | { 259 | fprintf(stderr, "%s:%s", name, s); 260 | } 261 | 262 | static void 263 | render(mu_Context *ctx, renderer *r) 264 | { 265 | storage s; 266 | r_begin(r, &s, cvWidth(), cvHeight()); 267 | r_clear(r, &s, mu_color(bg[0], bg[1], bg[2], 128)); 268 | mu_Command *cmd = NULL; 269 | while (mu_next_command(ctx, &cmd)) { 270 | switch (cmd->type) { 271 | case MU_COMMAND_TEXT: 272 | r_draw_text(r, &s, cmd->text.str, cmd->text.pos, 273 | cmd->text.color); 274 | break; 275 | case MU_COMMAND_RECT: 276 | r_draw_rect(r, &s, cmd->rect.rect, cmd->rect.color); 277 | break; 278 | case MU_COMMAND_ICON: 279 | r_draw_icon(r, &s, cmd->icon.id, cmd->icon.rect, 280 | cmd->icon.color); 281 | break; 282 | case MU_COMMAND_CLIP: 283 | r_set_clip_rect(r, &s, cmd->clip.rect); 284 | break; 285 | } 286 | } 287 | r_present(r, &s); 288 | } 289 | 290 | intptr_t 291 | event(const ev *e) 292 | { 293 | static mu_Context ctx; 294 | static renderer r; 295 | intptr_t ret = 1; 296 | cveventtype t = evType(e); 297 | switch (t) { 298 | case CVQ_LOGGER: 299 | ret = (intptr_t)report; 300 | break; 301 | case CVQ_NAME: 302 | ret = (intptr_t) "demo"; 303 | break; 304 | case CVQ_XPOS: 305 | ret = 50; 306 | break; 307 | case CVQ_YPOS: 308 | ret = 50; 309 | break; 310 | case CVQ_WIDTH: 311 | ret = 640; 312 | break; 313 | case CVQ_HEIGHT: 314 | ret = 480; 315 | break; 316 | case CVE_INIT: 317 | mu_init(&ctx); 318 | ctx.text_width = text_width; 319 | ctx.text_height = text_height; 320 | break; 321 | case CVE_GLINIT: 322 | r_init(&r); 323 | break; 324 | case CVE_DOWN: 325 | switch (evWhich(e)) { 326 | case CVK_MOUSELEFT: 327 | mu_input_mousedown( 328 | &ctx, cvMouseX(), cvMouseY(), MU_MOUSE_LEFT); 329 | break; 330 | case CVK_ESCAPE: 331 | cvQuit(); 332 | break; 333 | } 334 | break; 335 | case CVE_UP: 336 | switch (evWhich(e)) { 337 | case CVK_MOUSELEFT: 338 | mu_input_mouseup( 339 | &ctx, cvMouseX(), cvMouseY(), MU_MOUSE_LEFT); 340 | break; 341 | } 342 | break; 343 | case CVE_UNICODE: { 344 | uint32_t u = evUnicode(e); 345 | mu_input_text(&ctx, (const char *)&u); 346 | } break; 347 | case CVE_MOTION: 348 | mu_input_mousemove(&ctx, evX(e), evY(e)); 349 | break; 350 | case CVE_CLOSE: 351 | cvQuit(); 352 | break; 353 | case CVE_UPDATE: 354 | process_frame(&ctx); 355 | render(&ctx, &r); 356 | break; 357 | default: 358 | ret = 0; 359 | break; 360 | } 361 | return ret; 362 | } 363 | 364 | #include "cosmogfx.h" 365 | 366 | int 367 | main(int argc, char **argv, char **envp) 368 | { 369 | cosmogfx_init(argc, argv, envp); 370 | } 371 | 372 | STATIC_STACK_SIZE(0x800000); 373 | -------------------------------------------------------------------------------- /dtrampoline.c: -------------------------------------------------------------------------------- 1 | 2 | #include "dtrampoline.h" 3 | 4 | asm("template:\n\t" 5 | "push %rbp \n\t" 6 | "mov %rsp,%rbp \n\t" 7 | "mov $__sysv2nt,%rax \n\t" 8 | "push %rax \n\t" 9 | "movabs $0xdeadbeeffeedc0de,%rax\n\t" 10 | "ret"); 11 | 12 | static uint8_t *mem; 13 | 14 | void 15 | dtrampoline_init() 16 | { 17 | mem = VirtualAlloc(0, 0x10000, 0x3000, 0x40); 18 | } 19 | 20 | void * 21 | dtrampoline(void *f, unsigned arity) 22 | { 23 | if (!f) 24 | return 0; 25 | void *template(); 26 | uint8_t * r = mem; 27 | uintptr_t *p = (uintptr_t *)(r + 14); 28 | uint32_t * a = (uint32_t *)(r + 7); 29 | memcpy(r, template, 32); 30 | *p = (uintptr_t)f; 31 | void *(__sysv2nt)(); 32 | void *(__sysv2nt6)(); 33 | void *(__sysv2nt8)(); 34 | void *(__sysv2nt10)(); 35 | void *(__sysv2nt12)(); 36 | void *(__sysv2nt14)(); 37 | arity = 14; // XXX 38 | switch (arity) { 39 | case 0: 40 | case 1: 41 | case 2: 42 | case 3: 43 | case 4: 44 | *a = (uint32_t)(uintptr_t)__sysv2nt; 45 | break; 46 | case 5: 47 | case 6: 48 | *a = (uint32_t)(uintptr_t)__sysv2nt6; 49 | break; 50 | case 7: 51 | case 8: 52 | *a = (uint32_t)(uintptr_t)__sysv2nt8; 53 | break; 54 | case 9: 55 | case 10: 56 | *a = (uint32_t)(uintptr_t)__sysv2nt10; 57 | break; 58 | case 11: 59 | case 12: 60 | *a = (uint32_t)(uintptr_t)__sysv2nt12; 61 | break; 62 | case 13: 63 | case 14: 64 | *a = (uint32_t)(uintptr_t)__sysv2nt14; 65 | break; 66 | } 67 | mem += 32; 68 | return r; 69 | } 70 | -------------------------------------------------------------------------------- /dtrampoline.h: -------------------------------------------------------------------------------- 1 | void dtrampoline_init(); 2 | void *dtrampoline(void *, unsigned); 3 | -------------------------------------------------------------------------------- /elf_loader.c: -------------------------------------------------------------------------------- 1 | #include "elf_loader.h" 2 | #include "libc/calls/internal.h" 3 | 4 | static const unsigned align_mask = 4095; 5 | 6 | static uintptr_t 7 | pgtrunc(uintptr_t x) 8 | { 9 | return x & ~align_mask; 10 | } 11 | 12 | static uintptr_t 13 | pground(uintptr_t x) 14 | { 15 | return pgtrunc(x + align_mask); 16 | } 17 | 18 | static unsigned 19 | pflags(unsigned x) 20 | { 21 | unsigned r = 0; 22 | if (x & PF_R) 23 | r += PROT_READ; 24 | if (x & PF_W) 25 | r += PROT_WRITE; 26 | if (x & PF_X) 27 | r += PROT_EXEC; 28 | return r; 29 | } 30 | 31 | static void 32 | z_fini(void) 33 | { 34 | } 35 | 36 | static char * 37 | loadelf_anon(int fd, Elf64_Ehdr *ehdr, Elf64_Phdr *phdr) 38 | { 39 | uintptr_t minva = -1; 40 | uintptr_t maxva = 0; 41 | for (Elf64_Phdr *p = phdr; p < &phdr[ehdr->e_phnum]; p++) { 42 | if (p->p_type != PT_LOAD) 43 | continue; 44 | if (p->p_vaddr < minva) 45 | minva = p->p_vaddr; 46 | if (p->p_vaddr + p->p_memsz > maxva) 47 | maxva = p->p_vaddr + p->p_memsz; 48 | } 49 | 50 | minva = pgtrunc(minva); 51 | maxva = pground(maxva); 52 | 53 | uint8_t *base = __sys_mmap( 54 | 0, maxva - minva, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0, 0); 55 | assert(base != (void *)-1); 56 | __sys_munmap(base, maxva - minva); 57 | for (Elf64_Phdr *p = phdr; p < &phdr[ehdr->e_phnum]; p++) { 58 | if (p->p_type != PT_LOAD) 59 | continue; 60 | uintptr_t off = p->p_vaddr & align_mask; 61 | uint8_t * start = base; 62 | start += pgtrunc(p->p_vaddr); 63 | size_t sz = pground(p->p_memsz + off); 64 | uint8_t *m = __sys_mmap(start, sz, PROT_WRITE, 65 | MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0, 0); 66 | assert(m != (void *)-1); 67 | ssize_t sr = lseek(fd, p->p_offset, SEEK_SET); 68 | assert(sr >= 0); 69 | ssize_t rr = read(fd, m + off, p->p_filesz); 70 | assert(rr == (ssize_t)p->p_filesz); 71 | sys_mprotect(m, sz, pflags(p->p_flags)); 72 | } 73 | return base; 74 | } 75 | 76 | struct loaded { 77 | char * base; 78 | char * entry; 79 | Elf64_Ehdr eh; 80 | Elf64_Phdr ph[32]; 81 | }; 82 | 83 | static void 84 | loadfd(struct loaded *l, int fd) 85 | { 86 | assert(fd >= 0); 87 | size_t hsz = read(fd, &l->eh, sizeof(l->eh)); 88 | assert(hsz == sizeof(l->eh)); 89 | assert(l->eh.e_phnum < sizeof(l->ph) / sizeof(l->ph[0])); 90 | int rs = lseek(fd, l->eh.e_phoff, SEEK_SET); 91 | assert(rs >= 0); 92 | int rsz = read(fd, l->ph, l->eh.e_phnum * sizeof(l->ph[0])); 93 | assert(rsz == l->eh.e_phnum * sizeof(l->ph[0])); 94 | l->entry = (uint8_t *)l->eh.e_entry; 95 | } 96 | 97 | static void 98 | load(struct loaded *l, const char *file) 99 | { 100 | int fd = open(file, O_RDONLY); 101 | loadfd(l, fd); 102 | l->base = loadelf_anon(fd, &l->eh, l->ph); 103 | l->entry += (uintptr_t)l->base; 104 | close(fd); 105 | } 106 | 107 | void 108 | elf_interp(char *buf, size_t bsz, const char *file) 109 | { 110 | int fd = open(file, O_RDONLY); 111 | struct loaded l; 112 | size_t sz; 113 | loadfd(&l, fd); 114 | for (unsigned i = 0; i < l.eh.e_phnum; i++) 115 | switch (l.ph[i].p_type) { 116 | case PT_INTERP: 117 | assert(l.ph[i].p_filesz < bsz); 118 | sz = read(fd, buf, l.ph[i].p_filesz); 119 | assert(sz == l.ph[i].p_filesz); 120 | break; 121 | } 122 | close(fd); 123 | } 124 | 125 | void 126 | elf_exec( 127 | const char *file, const char *iinterp, int argc, char *argv[], char **envp) 128 | { 129 | struct loaded prog; 130 | load(&prog, file); 131 | struct loaded interp; 132 | load(&interp, iinterp); 133 | 134 | char **envv = envp; 135 | int envc = 0; 136 | while (*envp++) 137 | envc++; 138 | Elf64_auxv_t *av = (Elf64_auxv_t *)envp; 139 | 140 | char ** sp = argv - 1; 141 | const char **nargv = (const char **)&sp[1]; 142 | int nargc = *(long *)sp; 143 | 144 | #define AVSET(t, expr) \ 145 | do { \ 146 | if (av->a_type == (t)) \ 147 | av->a_un.a_val = (uintptr_t)(expr); \ 148 | } while (0) 149 | 150 | while (av->a_type) { 151 | AVSET(AT_PHDR, prog.base + prog.eh.e_phoff); 152 | AVSET(AT_PHENT, prog.eh.e_phentsize); 153 | AVSET(AT_PHNUM, prog.eh.e_phnum); 154 | AVSET(AT_PAGESZ, 0x1000); 155 | AVSET(AT_BASE, interp.base); 156 | AVSET(AT_FLAGS, 0); 157 | AVSET(AT_ENTRY, prog.entry); 158 | AVSET(AT_EXECFN, argv[0]); 159 | ++av; 160 | } 161 | #undef AVSET 162 | 163 | static struct ps_strings { 164 | char **argv; 165 | int argc; 166 | char **envv; 167 | int envc; 168 | } pss; 169 | pss = (struct ps_strings) { argv, argc, envv, envc }; 170 | 171 | asm volatile("mov\t%2,%%rsp\n\t" 172 | "jmpq\t*%1" 173 | : /* no outputs */ 174 | : "D"(IsFreebsd() ? sp : 0), // 175 | "S"(interp.entry), // 176 | "d"(sp), // 177 | "b"(IsNetbsd() ? &pss : 0) 178 | : "memory"); 179 | unreachable; 180 | } 181 | -------------------------------------------------------------------------------- /elf_loader.h: -------------------------------------------------------------------------------- 1 | void elf_exec( 2 | const char *file, const char *interp, int argc, char **argv, char **envp); 3 | void elf_interp(char *buf, size_t sz, const char *file); 4 | -------------------------------------------------------------------------------- /fake/alloca.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/alloca.h -------------------------------------------------------------------------------- /fake/arpa/inet.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/arpa/inet.h -------------------------------------------------------------------------------- /fake/assert.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/assert.h -------------------------------------------------------------------------------- /fake/dlfcn.h: -------------------------------------------------------------------------------- 1 | void *(*z_dlopen)(const char *filename, int flags); 2 | void *(*z_dlsym)(void *handle, const char *symbol); 3 | int (*z_dlclose)(void *handle); 4 | char *(*z_dlerror)(void); 5 | 6 | #define dlopen z_dlopen 7 | #define dlsym z_dlsym 8 | #define dlclose z_dlclose 9 | #define dlerror z_dlerror 10 | -------------------------------------------------------------------------------- /fake/dwmapi.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/dwmapi.h -------------------------------------------------------------------------------- /fake/elf.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/elf.h -------------------------------------------------------------------------------- /fake/fcntl.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/fcntl.h -------------------------------------------------------------------------------- /fake/inttypes.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/inttypes.h -------------------------------------------------------------------------------- /fake/limits.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/limits.h -------------------------------------------------------------------------------- /fake/netdb.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/netdb.h -------------------------------------------------------------------------------- /fake/netinet/in.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/netinet/in.h -------------------------------------------------------------------------------- /fake/setjmp.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/setjmp.h -------------------------------------------------------------------------------- /fake/stdarg.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/stdarg.h -------------------------------------------------------------------------------- /fake/stdbool.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/stdbool.h -------------------------------------------------------------------------------- /fake/stddef.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/stddef.h -------------------------------------------------------------------------------- /fake/stdint.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/stdint.h -------------------------------------------------------------------------------- /fake/stdio.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/stdio.h -------------------------------------------------------------------------------- /fake/stdlib.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/stdlib.h -------------------------------------------------------------------------------- /fake/string.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/string.h -------------------------------------------------------------------------------- /fake/sys/mman.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/sys/mman.h -------------------------------------------------------------------------------- /fake/sys/socket.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/sys/socket.h -------------------------------------------------------------------------------- /fake/sys/stat.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/sys/stat.h -------------------------------------------------------------------------------- /fake/sys/types.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/sys/types.h -------------------------------------------------------------------------------- /fake/sys/user.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/sys/user.h -------------------------------------------------------------------------------- /fake/unistd.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/unistd.h -------------------------------------------------------------------------------- /fake/windows.h: -------------------------------------------------------------------------------- 1 | #define ZeroMemory(Destination, Length) memset((Destination), 0, (Length)) 2 | /* #define HDC uint64_t */ 3 | /* #define HGLRC uint64_t */ 4 | 5 | #define WNDCLASS struct NtWndClass 6 | 7 | #define MSG struct NtMsg 8 | 9 | #define LOWORD(l) ((WORD)(((DWORD_PTR)(l)) & 0xffff)) 10 | #define HIWORD(l) ((WORD)((((DWORD_PTR)(l)) >> 16) & 0xffff)) 11 | #define CALLBACK 12 | 13 | #define __MSABI_LONG(x) x 14 | 15 | #define WINUSERAPI 16 | #define WINAPI 17 | #define WINGDIAPI 18 | 19 | #define MAKEINTRESOURCE(i) ((LPWSTR)((ULONG_PTR)((WORD)(i)))) 20 | 21 | #define MAPVK_VK_TO_VSC_EX (4) 22 | 23 | #define CS_OWNDC 0x0020 24 | 25 | #define CP_UTF8 65001 26 | 27 | #define PFD_MAIN_PLANE 0 28 | #define PFD_TYPE_RGBA 0 29 | #define PFD_DOUBLEBUFFER 0x00000001 30 | #define PFD_DRAW_TO_WINDOW 0x00000004 31 | #define PFD_SUPPORT_OPENGL 0x00000020 32 | 33 | #define DIB_RGB_COLORS 0 34 | #define BI_RGB 0 35 | #define IDC_ARROW MAKEINTRESOURCE(32512) 36 | #define GWL_STYLE (-16) 37 | 38 | #define WM_PAINT 0x000F 39 | #define WM_SETCURSOR 0x0020 40 | #define WM_MOUSEMOVE 0x0200 41 | #define WM_SIZE 0x0005 42 | #define WM_CLOSE 0x0010 43 | #define WM_KEYDOWN 0x0100 44 | #define WM_KEYUP 0x0101 45 | #define WM_SYSKEYDOWN 0x0104 46 | #define WM_SYSKEYUP 0x0105 47 | #define WM_LBUTTONDOWN 0x0201 48 | #define WM_LBUTTONUP 0x0202 49 | #define WM_MBUTTONDOWN 0x0207 50 | #define WM_MBUTTONUP 0x0208 51 | #define WM_MOUSEWHEEL 0x020A 52 | #define WM_RBUTTONDOWN 0x0204 53 | #define WM_RBUTTONUP 0x0205 54 | #define WM_CHAR 0x0102 55 | 56 | #define WS_CLIPSIBLINGS __MSABI_LONG(0x04000000) 57 | #define WS_CLIPCHILDREN __MSABI_LONG(0x02000000) 58 | #define WS_POPUP __MSABI_LONG(0x80000000) 59 | #define WS_OVERLAPPED __MSABI_LONG(0x00000000) 60 | #define WS_CAPTION __MSABI_LONG(0x00C00000) 61 | #define WS_SYSMENU __MSABI_LONG(0x00080000) 62 | #define WS_MINIMIZEBOX __MSABI_LONG(0x00020000) 63 | #define WS_MAXIMIZEBOX __MSABI_LONG(0x00010000) 64 | #define WS_THICKFRAME __MSABI_LONG(0x00040000) 65 | #define WS_EX_APPWINDOW __MSABI_LONG(0x00040000) 66 | 67 | #define SW_SHOWNORMAL 1 68 | #define SW_SHOWMAXIMIZED 3 69 | 70 | #define SWP_NOSIZE 0x0001 71 | #define SWP_NOMOVE 0x0002 72 | #define SWP_NOZORDER 0x0004 73 | #define SWP_FRAMECHANGED 0x0020 74 | #define SWP_SHOWWINDOW 0x0040 75 | 76 | #define HWND_TOPMOST ((HWND)-1) 77 | 78 | #define PM_REMOVE 0x0001 79 | 80 | #define HANDLE_WM_CLOSE(hwnd, wParam, lParam, fn) ((fn)(hwnd), (LRESULT)0) 81 | #define HANDLE_WM_KEYDOWN(hwnd, wParam, lParam, fn) \ 82 | ((fn)((hwnd), (UINT)(wParam), TRUE, (int)(short)LOWORD(lParam), \ 83 | (UINT)HIWORD(lParam)), \ 84 | (LRESULT)0) 85 | #define HANDLE_WM_KEYUP(hwnd, wParam, lParam, fn) \ 86 | ((fn)((hwnd), (UINT)(wParam), FALSE, (int)(short)LOWORD(lParam), \ 87 | (UINT)HIWORD(lParam)), \ 88 | (LRESULT)0) 89 | #define HANDLE_WM_CHAR(hwnd, wParam, lParam, fn) \ 90 | ((fn)((hwnd), (TCHAR)(wParam), (int)(short)LOWORD(lParam)), (LRESULT)0) 91 | 92 | #define HANDLE_WM_SIZE(hwnd, wParam, lParam, fn) \ 93 | ((fn)((hwnd), (UINT)(wParam), (int)(short)LOWORD(lParam), \ 94 | (int)(short)HIWORD(lParam)), \ 95 | (LRESULT)0) 96 | 97 | #define HANDLE_WM_SYSKEYDOWN(hwnd, wParam, lParam, fn) \ 98 | ((fn)((hwnd), (UINT)(wParam), TRUE, (int)(short)LOWORD(lParam), \ 99 | (UINT)HIWORD(lParam)), \ 100 | (LRESULT)0) 101 | #define HANDLE_WM_SYSKEYUP(hwnd, wParam, lParam, fn) \ 102 | ((fn)((hwnd), (UINT)(wParam), FALSE, (int)(short)LOWORD(lParam), \ 103 | (UINT)HIWORD(lParam)), \ 104 | (LRESULT)0) 105 | #define HANDLE_WM_SYSCHAR(hwnd, wParam, lParam, fn) \ 106 | ((fn)((hwnd), (TCHAR)(wParam), (int)(short)LOWORD(lParam)), (LRESULT)0) 107 | #define HANDLE_WM_MOUSEMOVE(hwnd, wParam, lParam, fn) \ 108 | ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), \ 109 | (UINT)(wParam)), \ 110 | (LRESULT)0) 111 | #define HANDLE_WM_LBUTTONDOWN(hwnd, wParam, lParam, fn) \ 112 | ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), \ 113 | (int)(short)HIWORD(lParam), (UINT)(wParam)), \ 114 | (LRESULT)0) 115 | #define HANDLE_WM_LBUTTONUP(hwnd, wParam, lParam, fn) \ 116 | ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), \ 117 | (UINT)(wParam)), \ 118 | (LRESULT)0) 119 | #define HANDLE_WM_MBUTTONDOWN(hwnd, wParam, lParam, fn) \ 120 | ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), \ 121 | (int)(short)HIWORD(lParam), (UINT)(wParam)), \ 122 | (LRESULT)0) 123 | #define HANDLE_WM_MBUTTONUP(hwnd, wParam, lParam, fn) \ 124 | ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), \ 125 | (UINT)(wParam)), \ 126 | (LRESULT)0) 127 | #define HANDLE_WM_RBUTTONDOWN(hwnd, wParam, lParam, fn) \ 128 | ((fn)((hwnd), FALSE, (int)(short)LOWORD(lParam), \ 129 | (int)(short)HIWORD(lParam), (UINT)(wParam)), \ 130 | (LRESULT)0) 131 | #define HANDLE_WM_RBUTTONUP(hwnd, wParam, lParam, fn) \ 132 | ((fn)((hwnd), (int)(short)LOWORD(lParam), (int)(short)HIWORD(lParam), \ 133 | (UINT)(wParam)), \ 134 | (LRESULT)0) 135 | #define HANDLE_WM_SETCURSOR(hwnd, wParam, lParam, fn) \ 136 | (LRESULT)(DWORD)(WINBOOL)(fn)((hwnd), (HWND)(wParam), \ 137 | (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)) 138 | #define HANDLE_WM_PAINT(hwnd, wParam, lParam, fn) ((fn)(hwnd), (LRESULT)0) 139 | 140 | typedef LRESULT(CALLBACK *WNDPROC)(HWND, UINT, WPARAM, LPARAM); 141 | 142 | typedef uint32_t __LONG32; 143 | 144 | typedef struct _ICONINFO { 145 | WINBOOL fIcon; 146 | DWORD xHotspot; 147 | DWORD yHotspot; 148 | HBITMAP hbmMask; 149 | HBITMAP hbmColor; 150 | } ICONINFO; 151 | typedef ICONINFO *PICONINFO; 152 | 153 | typedef __LONG32 FXPT16DOT16, *LPFXPT16DOT16; 154 | typedef __LONG32 FXPT2DOT30, *LPFXPT2DOT30; 155 | 156 | typedef struct tagCIEXYZ { 157 | FXPT2DOT30 ciexyzX; 158 | FXPT2DOT30 ciexyzY; 159 | FXPT2DOT30 ciexyzZ; 160 | } CIEXYZ; 161 | 162 | typedef struct tagICEXYZTRIPLE { 163 | CIEXYZ ciexyzRed; 164 | CIEXYZ ciexyzGreen; 165 | CIEXYZ ciexyzBlue; 166 | } CIEXYZTRIPLE; 167 | 168 | typedef struct { 169 | DWORD bV5Size; 170 | LONG bV5Width; 171 | LONG bV5Height; 172 | WORD bV5Planes; 173 | WORD bV5BitCount; 174 | DWORD bV5Compression; 175 | DWORD bV5SizeImage; 176 | LONG bV5XPelsPerMeter; 177 | LONG bV5YPelsPerMeter; 178 | DWORD bV5ClrUsed; 179 | DWORD bV5ClrImportant; 180 | DWORD bV5RedMask; 181 | DWORD bV5GreenMask; 182 | DWORD bV5BlueMask; 183 | DWORD bV5AlphaMask; 184 | DWORD bV5CSType; 185 | CIEXYZTRIPLE bV5Endpoints; 186 | DWORD bV5GammaRed; 187 | DWORD bV5GammaGreen; 188 | DWORD bV5GammaBlue; 189 | DWORD bV5Intent; 190 | DWORD bV5ProfileData; 191 | DWORD bV5ProfileSize; 192 | DWORD bV5Reserved; 193 | } BITMAPV5HEADER, *LPBITMAPV5HEADER, *PBITMAPV5HEADER; 194 | 195 | typedef struct tagBITMAPINFOHEADER { 196 | DWORD biSize; 197 | LONG biWidth; 198 | LONG biHeight; 199 | WORD biPlanes; 200 | WORD biBitCount; 201 | DWORD biCompression; 202 | DWORD biSizeImage; 203 | LONG biXPelsPerMeter; 204 | LONG biYPelsPerMeter; 205 | DWORD biClrUsed; 206 | DWORD biClrImportant; 207 | } BITMAPINFOHEADER, *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER; 208 | 209 | typedef struct tagRGBQUAD { 210 | BYTE rgbBlue; 211 | BYTE rgbGreen; 212 | BYTE rgbRed; 213 | BYTE rgbReserved; 214 | } RGBQUAD; 215 | 216 | typedef struct tagBITMAPINFO { 217 | BITMAPINFOHEADER bmiHeader; 218 | RGBQUAD bmiColors[1]; 219 | } BITMAPINFO, *LPBITMAPINFO, *PBITMAPINFO; 220 | 221 | typedef struct tagPIXELFORMATDESCRIPTOR { 222 | WORD nSize; 223 | WORD nVersion; 224 | DWORD dwFlags; 225 | BYTE iPixelType; 226 | BYTE cColorBits; 227 | BYTE cRedBits; 228 | BYTE cRedShift; 229 | BYTE cGreenBits; 230 | BYTE cGreenShift; 231 | BYTE cBlueBits; 232 | BYTE cBlueShift; 233 | BYTE cAlphaBits; 234 | BYTE cAlphaShift; 235 | BYTE cAccumBits; 236 | BYTE cAccumRedBits; 237 | BYTE cAccumGreenBits; 238 | BYTE cAccumBlueBits; 239 | BYTE cAccumAlphaBits; 240 | BYTE cDepthBits; 241 | BYTE cStencilBits; 242 | BYTE cAuxBuffers; 243 | BYTE iLayerType; 244 | BYTE bReserved; 245 | DWORD dwLayerMask; 246 | DWORD dwVisibleMask; 247 | DWORD dwDamageMask; 248 | } PIXELFORMATDESCRIPTOR, *PPIXELFORMATDESCRIPTOR, *LPPIXELFORMATDESCRIPTOR; 249 | 250 | typedef struct tagPOINT { 251 | LONG x; 252 | LONG y; 253 | } POINT, *PPOINT; 254 | 255 | typedef struct tagRECT { 256 | LONG left; 257 | LONG top; 258 | LONG right; 259 | LONG bottom; 260 | } RECT, *PRECT, *NPRECT, *LPRECT; 261 | 262 | /* typedef struct tagMSG { */ 263 | /* HWND hwnd; */ 264 | /* UINT message; */ 265 | /* WPARAM wParam; */ 266 | /* LPARAM lParam; */ 267 | /* DWORD time; */ 268 | /* POINT pt; */ 269 | /* } MSG, *PMSG, *NPMSG, *LPMSG; */ 270 | 271 | typedef struct tagWNDCLASSEXA { 272 | UINT cbSize; 273 | UINT style; 274 | WNDPROC lpfnWndProc; 275 | int cbClsExtra; 276 | int cbWndExtra; 277 | HINSTANCE hInstance; 278 | HICON hIcon; 279 | HCURSOR hCursor; 280 | HBRUSH hbrBackground; 281 | LPCSTR lpszMenuName; 282 | LPCSTR lpszClassName; 283 | HICON hIconSm; 284 | } WNDCLASSEXA, *PWNDCLASSEXA, *NPWNDCLASSEXA, *LPWNDCLASSEXA; 285 | 286 | WINUSERAPI int WINAPI MultiByteToWideChar(UINT CodePage, DWORD dwFlags, 287 | LPCCH lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, 288 | int cchWideChar); 289 | 290 | WINUSERAPI WINBOOL WINAPI DestroyIcon(HICON hIcon); 291 | 292 | WINUSERAPI HICON WINAPI CreateIconIndirect(PICONINFO piconinfo); 293 | 294 | // WINUSERAPI LONG WINAPI SetWindowLongA(HWND hWnd, int nIndex, LONG dwNewLong); 295 | WINUSERAPI LONG WINAPI SetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong); 296 | 297 | WINUSERAPI HDC WINAPI GetDC(HWND hWnd); 298 | WINUSERAPI int WINAPI ReleaseDC(HWND hWnd, HDC hDC); 299 | 300 | HMODULE LoadLibraryA(LPCSTR lpLibFileName); 301 | /* WINUSERAPI HCURSOR WINAPI LoadCursorW( */ 302 | /* HINSTANCE hInstance, LPCWSTR lpCursorName); */ 303 | 304 | int32_t PeekMessage(struct NtMsg *lpMsg, int64_t hWnd, uint32_t wMsgFilterMin, 305 | uint32_t wMsgFilterMax, uint32_t); 306 | 307 | // WINUSERAPI WINBOOL WINAPI PeekMessageW(LPMSG lpMsg, HWND hWnd, 308 | // UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg); 309 | // WINUSERAPI LRESULT WINAPI DispatchMessageW(CONST MSG *lpMsg); 310 | WINUSERAPI WINBOOL WINAPI InvalidateRect( 311 | HWND hWnd, CONST RECT *lpRect, WINBOOL bErase); 312 | WINUSERAPI WINBOOL WINAPI UpdateWindow(HWND hWnd); 313 | WINUSERAPI WINBOOL WINAPI AdjustWindowRect( 314 | LPRECT lpRect, DWORD dwStyle, WINBOOL bMenu); 315 | WINUSERAPI UINT WINAPI MapVirtualKeyEx(UINT uCode, UINT uMapType, HKL dwhkl); 316 | WINUSERAPI HKL WINAPI GetKeyboardLayout(DWORD idThread); 317 | 318 | WINGDIAPI HBITMAP WINAPI CreateBitmap( 319 | int nWidth, int nHeight, UINT nPlanes, UINT nBitCount, CONST VOID *lpBits); 320 | WINGDIAPI HBITMAP WINAPI CreateDIBSection(HDC hdc, CONST BITMAPINFO *lpbmi, 321 | UINT usage, VOID **ppvBits, HANDLE hSection, DWORD offset); 322 | WINGDIAPI HRGN WINAPI CreateRectRgn(int x1, int y1, int x2, int y2); 323 | WINGDIAPI WINBOOL WINAPI SwapBuffers(HDC); 324 | WINGDIAPI WINBOOL WINAPI SetPixelFormat( 325 | HDC hdc, int format, CONST PIXELFORMATDESCRIPTOR *ppfd); 326 | WINGDIAPI int WINAPI ChoosePixelFormat( 327 | HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd); 328 | 329 | #define VK_LBUTTON 0x01 330 | #define VK_RBUTTON 0x02 331 | #define VK_CANCEL 0x03 332 | #define VK_MBUTTON 0x04 333 | #define VK_XBUTTON1 0x05 334 | #define VK_XBUTTON2 0x06 335 | #define VK_BACK 0x08 336 | #define VK_TAB 0x09 337 | #define VK_CLEAR 0x0C 338 | #define VK_RETURN 0x0D 339 | #define VK_SHIFT 0x10 340 | #define VK_CONTROL 0x11 341 | #define VK_MENU 0x12 342 | #define VK_PAUSE 0x13 343 | #define VK_CAPITAL 0x14 344 | #define VK_KANA 0x15 345 | #define VK_HANGEUL 0x15 346 | #define VK_HANGUL 0x15 347 | #define VK_JUNJA 0x17 348 | #define VK_FINAL 0x18 349 | #define VK_HANJA 0x19 350 | #define VK_KANJI 0x19 351 | #define VK_ESCAPE 0x1B 352 | #define VK_CONVERT 0x1C 353 | #define VK_NONCONVERT 0x1D 354 | #define VK_ACCEPT 0x1E 355 | #define VK_MODECHANGE 0x1F 356 | #define VK_SPACE 0x20 357 | #define VK_PRIOR 0x21 358 | #define VK_NEXT 0x22 359 | #define VK_END 0x23 360 | #define VK_HOME 0x24 361 | #define VK_LEFT 0x25 362 | #define VK_UP 0x26 363 | #define VK_RIGHT 0x27 364 | #define VK_DOWN 0x28 365 | #define VK_SELECT 0x29 366 | #define VK_PRINT 0x2A 367 | #define VK_EXECUTE 0x2B 368 | #define VK_SNAPSHOT 0x2C 369 | #define VK_INSERT 0x2D 370 | #define VK_DELETE 0x2E 371 | #define VK_HELP 0x2F 372 | 373 | #define VK_LWIN 0x5B 374 | #define VK_RWIN 0x5C 375 | #define VK_APPS 0x5D 376 | #define VK_SLEEP 0x5F 377 | #define VK_NUMPAD0 0x60 378 | #define VK_NUMPAD1 0x61 379 | #define VK_NUMPAD2 0x62 380 | #define VK_NUMPAD3 0x63 381 | #define VK_NUMPAD4 0x64 382 | #define VK_NUMPAD5 0x65 383 | #define VK_NUMPAD6 0x66 384 | #define VK_NUMPAD7 0x67 385 | #define VK_NUMPAD8 0x68 386 | #define VK_NUMPAD9 0x69 387 | #define VK_MULTIPLY 0x6A 388 | #define VK_ADD 0x6B 389 | #define VK_SEPARATOR 0x6C 390 | #define VK_SUBTRACT 0x6D 391 | #define VK_DECIMAL 0x6E 392 | #define VK_DIVIDE 0x6F 393 | #define VK_F1 0x70 394 | #define VK_F2 0x71 395 | #define VK_F3 0x72 396 | #define VK_F4 0x73 397 | #define VK_F5 0x74 398 | #define VK_F6 0x75 399 | #define VK_F7 0x76 400 | #define VK_F8 0x77 401 | #define VK_F9 0x78 402 | #define VK_F10 0x79 403 | #define VK_F11 0x7A 404 | #define VK_F12 0x7B 405 | #define VK_F13 0x7C 406 | #define VK_F14 0x7D 407 | #define VK_F15 0x7E 408 | #define VK_F16 0x7F 409 | #define VK_F17 0x80 410 | #define VK_F18 0x81 411 | #define VK_F19 0x82 412 | #define VK_F20 0x83 413 | #define VK_F21 0x84 414 | #define VK_F22 0x85 415 | #define VK_F23 0x86 416 | #define VK_F24 0x87 417 | #define VK_NUMLOCK 0x90 418 | #define VK_SCROLL 0x91 419 | #define VK_OEM_NEC_EQUAL 0x92 420 | #define VK_OEM_FJ_JISHO 0x92 421 | #define VK_OEM_FJ_MASSHOU 0x93 422 | #define VK_OEM_FJ_TOUROKU 0x94 423 | #define VK_OEM_FJ_LOYA 0x95 424 | #define VK_OEM_FJ_ROYA 0x96 425 | #define VK_LSHIFT 0xA0 426 | #define VK_RSHIFT 0xA1 427 | #define VK_LCONTROL 0xA2 428 | #define VK_RCONTROL 0xA3 429 | #define VK_LMENU 0xA4 430 | #define VK_RMENU 0xA5 431 | #define VK_BROWSER_BACK 0xA6 432 | #define VK_BROWSER_FORWARD 0xA7 433 | #define VK_BROWSER_REFRESH 0xA8 434 | #define VK_BROWSER_STOP 0xA9 435 | #define VK_BROWSER_SEARCH 0xAA 436 | #define VK_BROWSER_FAVORITES 0xAB 437 | #define VK_BROWSER_HOME 0xAC 438 | #define VK_VOLUME_MUTE 0xAD 439 | #define VK_VOLUME_DOWN 0xAE 440 | #define VK_VOLUME_UP 0xAF 441 | #define VK_MEDIA_NEXT_TRACK 0xB0 442 | #define VK_MEDIA_PREV_TRACK 0xB1 443 | #define VK_MEDIA_STOP 0xB2 444 | #define VK_MEDIA_PLAY_PAUSE 0xB3 445 | #define VK_LAUNCH_MAIL 0xB4 446 | #define VK_LAUNCH_MEDIA_SELECT 0xB5 447 | #define VK_LAUNCH_APP1 0xB6 448 | #define VK_LAUNCH_APP2 0xB7 449 | #define VK_OEM_1 0xBA 450 | #define VK_OEM_PLUS 0xBB 451 | #define VK_OEM_COMMA 0xBC 452 | #define VK_OEM_MINUS 0xBD 453 | #define VK_OEM_PERIOD 0xBE 454 | #define VK_OEM_2 0xBF 455 | #define VK_OEM_3 0xC0 456 | #define VK_OEM_4 0xDB 457 | #define VK_OEM_5 0xDC 458 | #define VK_OEM_6 0xDD 459 | #define VK_OEM_7 0xDE 460 | #define VK_OEM_8 0xDF 461 | #define VK_OEM_AX 0xE1 462 | #define VK_OEM_102 0xE2 463 | #define VK_ICO_HELP 0xE3 464 | #define VK_ICO_00 0xE4 465 | #define VK_PROCESSKEY 0xE5 466 | #define VK_ICO_CLEAR 0xE6 467 | #define VK_PACKET 0xE7 468 | #define VK_OEM_RESET 0xE9 469 | #define VK_OEM_JUMP 0xEA 470 | #define VK_OEM_PA1 0xEB 471 | #define VK_OEM_PA2 0xEC 472 | #define VK_OEM_PA3 0xED 473 | #define VK_OEM_WSCTRL 0xEE 474 | #define VK_OEM_CUSEL 0xEF 475 | #define VK_OEM_ATTN 0xF0 476 | #define VK_OEM_FINISH 0xF1 477 | #define VK_OEM_COPY 0xF2 478 | #define VK_OEM_AUTO 0xF3 479 | #define VK_OEM_ENLW 0xF4 480 | #define VK_OEM_BACKTAB 0xF5 481 | #define VK_ATTN 0xF6 482 | #define VK_CRSEL 0xF7 483 | #define VK_EXSEL 0xF8 484 | #define VK_EREOF 0xF9 485 | #define VK_PLAY 0xFA 486 | #define VK_ZOOM 0xFB 487 | #define VK_NONAME 0xFC 488 | #define VK_PA1 0xFD 489 | #define VK_OEM_CLEAR 0xFE 490 | 491 | typedef struct _DWM_BLURBEHIND { 492 | DWORD dwFlags; 493 | BOOL fEnable; 494 | HRGN hRgnBlur; 495 | BOOL fTransitionOnMaximized; 496 | } DWM_BLURBEHIND, *PDWM_BLURBEHIND; 497 | 498 | #define DWM_BB_ENABLE 0x00000001 499 | #define DWM_BB_BLURREGION 0x00000002 500 | -------------------------------------------------------------------------------- /fake/windowsx.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/windowsx.h -------------------------------------------------------------------------------- /fake/wingdi.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/fake/wingdi.h -------------------------------------------------------------------------------- /gl.h: -------------------------------------------------------------------------------- 1 | // clang-format off 2 | 3 | /* This file was auto-generated by Galogen */ 4 | #ifndef _GALOGEN_HEADER_ 5 | #define _GALOGEN_HEADER_ 6 | #if defined(__gl_h_) || defined(__GL_H__) || defined(__glext_h_) || defined(__GLEXT_H_) || defined(__gltypes_h_) || defined(__glcorearb_h_) || defined(__gl_glcorearb_h) 7 | #error Galogen-generated header included after a GL header. 8 | #endif 9 | 10 | #define __gl_h_ 1 11 | #define __gl32_h_ 1 12 | #define __gl31_h_ 1 13 | #define __GL_H__ 1 14 | #define __glext_h_ 1 15 | #define __GLEXT_H_ 1 16 | #define __gltypes_h_ 1 17 | #define __glcorearb_h_ 1 18 | #define __gl_glcorearb_h_ 1 19 | 20 | #if defined(_WIN32) 21 | #define WIN32_LEAN_AND_MEAN 22 | #include 23 | #define GL_APIENTRY APIENTRY 24 | #else 25 | #define GL_APIENTRY 26 | #endif 27 | 28 | #if defined(__cplusplus) 29 | extern "C" { 30 | #endif 31 | 32 | #define GALOGEN_API_NAME "gl" 33 | #define GALOGEN_API_PROFILE "core" 34 | #define GALOGEN_API_VER_MAJ 3 35 | #define GALOGEN_API_VER_MIN 2 36 | typedef unsigned int GLenum; 37 | typedef unsigned int GLuint; 38 | typedef int GLsizei; 39 | typedef char GLchar; 40 | #include 41 | typedef ptrdiff_t GLintptr; 42 | typedef ptrdiff_t GLsizeiptr; 43 | typedef double GLclampd; 44 | typedef unsigned short GLushort; 45 | typedef unsigned char GLubyte; 46 | typedef unsigned char GLboolean; 47 | #ifndef GLEXT_64_TYPES_DEFINED 48 | /* This code block is duplicated in glxext.h, so must be protected */ 49 | #define GLEXT_64_TYPES_DEFINED 50 | /* Define int32_t, int64_t, and uint64_t types for UST/MSC */ 51 | /* (as used in the GL_EXT_timer_query extension). */ 52 | #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 53 | #include 54 | #elif defined(__sun__) || defined(__digital__) 55 | #include 56 | #if defined(__STDC__) 57 | #if defined(__arch64__) || defined(_LP64) 58 | typedef long int int64_t; 59 | typedef unsigned long int uint64_t; 60 | #else 61 | typedef long long int int64_t; 62 | typedef unsigned long long int uint64_t; 63 | #endif /* __arch64__ */ 64 | #endif /* __STDC__ */ 65 | #elif defined( __VMS ) || defined(__sgi) 66 | #include 67 | #elif defined(__SCO__) || defined(__USLC__) 68 | #include 69 | #elif defined(__UNIXOS2__) || defined(__SOL64__) 70 | typedef long int int32_t; 71 | typedef long long int int64_t; 72 | typedef unsigned long long int uint64_t; 73 | #elif defined(_WIN32) && defined(__GNUC__) 74 | #include 75 | #elif defined(_WIN32) 76 | typedef __int32 int32_t; 77 | typedef __int64 int64_t; 78 | typedef unsigned __int64 uint64_t; 79 | #else 80 | /* Fallback if nothing above works */ 81 | #include 82 | #endif 83 | #endif 84 | typedef uint64_t GLuint64; 85 | typedef double GLdouble; 86 | typedef unsigned short GLhalf; 87 | typedef float GLclampf; 88 | typedef unsigned int GLbitfield; 89 | typedef signed char GLbyte; 90 | typedef short GLshort; 91 | typedef void GLvoid; 92 | typedef int64_t GLint64; 93 | typedef float GLfloat; 94 | typedef struct __GLsync * GLsync; 95 | typedef int GLint; 96 | #define GL_MAX_INTEGER_SAMPLES 0x9110 97 | #define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E 98 | #define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B 99 | #define GL_SAMPLER_2D_MULTISAMPLE 0x9108 100 | #define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 101 | #define GL_TEXTURE_SAMPLES 0x9106 102 | #define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 103 | #define GL_SAMPLE_POSITION 0x8E50 104 | #define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 105 | #define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull 106 | #define GL_WAIT_FAILED 0x911D 107 | #define GL_CONDITION_SATISFIED 0x911C 108 | #define GL_TIMEOUT_EXPIRED 0x911B 109 | #define GL_SYNC_FENCE 0x9116 110 | #define GL_SYNC_STATUS 0x9114 111 | #define GL_SYNC_CONDITION 0x9113 112 | #define GL_OBJECT_TYPE 0x9112 113 | #define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 114 | #define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F 115 | #define GL_PROVOKING_VERTEX 0x8E4F 116 | #define GL_LAST_VERTEX_CONVENTION 0x8E4E 117 | #define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A 118 | #define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C 119 | #define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 120 | #define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 121 | #define GL_GEOMETRY_OUTPUT_TYPE 0x8918 122 | #define GL_GEOMETRY_SHADER 0x8DD9 123 | #define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 124 | #define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 125 | #define GL_TRIANGLE_STRIP_ADJACENCY 0x000D 126 | #define GL_TRIANGLES_ADJACENCY 0x000C 127 | #define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 128 | #define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 129 | #define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 130 | #define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 131 | #define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 132 | #define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E 133 | #define GL_UNIFORM_MATRIX_STRIDE 0x8A3D 134 | #define GL_UNIFORM_SIZE 0x8A38 135 | #define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 136 | #define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 137 | #define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 138 | #define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 139 | #define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 140 | #define GL_COPY_WRITE_BUFFER 0x8F37 141 | #define GL_PRIMITIVE_RESTART_INDEX 0x8F9E 142 | #define GL_RGBA16_SNORM 0x8F9B 143 | #define GL_RG16_SNORM 0x8F99 144 | #define GL_R16_SNORM 0x8F98 145 | #define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 146 | #define GL_TEXTURE_RECTANGLE 0x84F5 147 | #define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 148 | #define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 149 | #define GL_RG16I 0x8239 150 | #define GL_RG8UI 0x8238 151 | #define GL_R32UI 0x8236 152 | #define GL_R32I 0x8235 153 | #define GL_R16I 0x8233 154 | #define GL_R8I 0x8231 155 | #define GL_RG32F 0x8230 156 | #define GL_RG16F 0x822F 157 | #define GL_R32F 0x822E 158 | #define GL_RG16 0x822C 159 | #define GL_R16 0x822A 160 | #define GL_RG_INTEGER 0x8228 161 | #define GL_RGB16_SNORM 0x8F9A 162 | #define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC 163 | #define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 164 | #define GL_MAP_WRITE_BIT 0x0002 165 | #define GL_PROGRAM_POINT_SIZE 0x8642 166 | #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 167 | #define GL_MAP_READ_BIT 0x0001 168 | #define GL_FRAMEBUFFER_SRGB 0x8DB9 169 | #define GL_MAX_SAMPLES 0x8D57 170 | #define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 171 | #define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 172 | #define GL_TEXTURE_BUFFER 0x8C2A 173 | #define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 174 | #define GL_ALREADY_SIGNALED 0x911A 175 | #define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 176 | #define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 177 | #define GL_STENCIL_INDEX16 0x8D49 178 | #define GL_STENCIL_INDEX4 0x8D47 179 | #define GL_RENDERBUFFER_HEIGHT 0x8D43 180 | #define GL_STENCIL_ATTACHMENT 0x8D20 181 | #define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 182 | #define GL_DEPTH_ATTACHMENT 0x8D00 183 | #define GL_COLOR_ATTACHMENT31 0x8CFF 184 | #define GL_COLOR_ATTACHMENT29 0x8CFD 185 | #define GL_COLOR_ATTACHMENT27 0x8CFB 186 | #define GL_COLOR_ATTACHMENT26 0x8CFA 187 | #define GL_COLOR_ATTACHMENT23 0x8CF7 188 | #define GL_COLOR_ATTACHMENT19 0x8CF3 189 | #define GL_COLOR_ATTACHMENT18 0x8CF2 190 | #define GL_COLOR_ATTACHMENT17 0x8CF1 191 | #define GL_COLOR_ATTACHMENT15 0x8CEF 192 | #define GL_COLOR_ATTACHMENT14 0x8CEE 193 | #define GL_COLOR_ATTACHMENT12 0x8CEC 194 | #define GL_COLOR_ATTACHMENT11 0x8CEB 195 | #define GL_COLOR_ATTACHMENT10 0x8CEA 196 | #define GL_COLOR_ATTACHMENT9 0x8CE9 197 | #define GL_COLOR_ATTACHMENT8 0x8CE8 198 | #define GL_COLOR_ATTACHMENT7 0x8CE7 199 | #define GL_COLOR_ATTACHMENT6 0x8CE6 200 | #define GL_COLOR_ATTACHMENT4 0x8CE4 201 | #define GL_RGBA8_SNORM 0x8F97 202 | #define GL_COLOR_ATTACHMENT2 0x8CE2 203 | #define GL_COLOR_ATTACHMENT0 0x8CE0 204 | #define GL_R16F 0x822D 205 | #define GL_COLOR_ATTACHMENT30 0x8CFE 206 | #define GL_MAX_COLOR_ATTACHMENTS 0x8CDF 207 | #define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC 208 | #define GL_COLOR_ATTACHMENT22 0x8CF6 209 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 210 | #define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 211 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 212 | #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 213 | #define GL_RENDERBUFFER_SAMPLES 0x8CAB 214 | #define GL_READ_FRAMEBUFFER_BINDING 0x8CAA 215 | #define GL_DRAW_FRAMEBUFFER 0x8CA9 216 | #define GL_RENDERBUFFER_BINDING 0x8CA7 217 | #define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 218 | #define GL_UNSIGNED_NORMALIZED 0x8C17 219 | #define GL_TEXTURE_ALPHA_TYPE 0x8C13 220 | #define GL_RG8I 0x8237 221 | #define GL_TEXTURE_BLUE_TYPE 0x8C12 222 | #define GL_COLOR_ATTACHMENT16 0x8CF0 223 | #define GL_TEXTURE_GREEN_TYPE 0x8C11 224 | #define GL_TEXTURE_STENCIL_SIZE 0x88F1 225 | #define GL_UNSIGNED_INT_24_8 0x84FA 226 | #define GL_DEPTH_STENCIL 0x84F9 227 | #define GL_MAX_RENDERBUFFER_SIZE 0x84E8 228 | #define GL_FRAMEBUFFER_UNDEFINED 0x8219 229 | #define GL_FRAMEBUFFER_DEFAULT 0x8218 230 | #define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 231 | #define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 232 | #define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 233 | #define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 234 | #define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 235 | #define GL_DEPTH32F_STENCIL8 0x8CAD 236 | #define GL_DEPTH_COMPONENT32F 0x8CAC 237 | #define GL_BUFFER_MAP_OFFSET 0x9121 238 | #define GL_BUFFER_MAP_LENGTH 0x9120 239 | #define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 240 | #define GL_QUERY_NO_WAIT 0x8E14 241 | #define GL_QUERY_WAIT 0x8E13 242 | #define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 243 | #define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 244 | #define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 245 | #define GL_INT_SAMPLER_1D_ARRAY 0x8DCE 246 | #define GL_INT_SAMPLER_CUBE 0x8DCC 247 | #define GL_INT_SAMPLER_3D 0x8DCB 248 | #define GL_UNSIGNED_INT_VEC4 0x8DC8 249 | #define GL_UNSIGNED_INT_VEC2 0x8DC6 250 | #define GL_SAMPLER_2D_ARRAY 0x8DC1 251 | #define GL_BGR_INTEGER 0x8D9A 252 | #define GL_BLUE_INTEGER 0x8D96 253 | #define GL_GREEN_INTEGER 0x8D95 254 | #define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 255 | #define GL_RED_INTEGER 0x8D94 256 | #define GL_RGBA8I 0x8D8E 257 | #define GL_RGBA16I 0x8D88 258 | #define GL_RGB32I 0x8D83 259 | #define GL_RGBA32I 0x8D82 260 | #define GL_RGB16UI 0x8D77 261 | #define GL_RGBA16UI 0x8D76 262 | #define GL_RGB32UI 0x8D71 263 | #define GL_RGBA32UI 0x8D70 264 | #define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F 265 | #define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E 266 | #define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A 267 | #define GL_RASTERIZER_DISCARD 0x8C89 268 | #define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 269 | #define GL_PRIMITIVES_GENERATED 0x8C87 270 | #define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 271 | #define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 272 | #define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 273 | #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 274 | #define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F 275 | #define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 276 | #define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 277 | #define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E 278 | #define GL_RGB9_E5 0x8C3D 279 | #define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B 280 | #define GL_R11F_G11F_B10F 0x8C3A 281 | #define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D 282 | #define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C 283 | #define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 284 | #define GL_TEXTURE_1D_ARRAY 0x8C18 285 | #define GL_TEXTURE_2D_MULTISAMPLE 0x9100 286 | #define GL_MAX_VARYING_COMPONENTS 0x8B4B 287 | #define MAX_VARYING_FLOATS 0x8B4B 288 | #define GL_CLAMP_READ_COLOR 0x891C 289 | #define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD 290 | #define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 291 | #define GL_CONTEXT_FLAGS 0x821E 292 | #define GL_FRAMEBUFFER_COMPLETE 0x8CD5 293 | #define GL_NUM_EXTENSIONS 0x821D 294 | #define GL_CLIP_DISTANCE6 0x3006 295 | #define GL_CLIP_DISTANCE4 0x3004 296 | #define GL_CLIP_PLANE4 0x3004 297 | #define GL_INT_SAMPLER_BUFFER 0x8DD0 298 | #define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 299 | #define GL_COMPRESSED_SRGB_ALPHA 0x8C49 300 | #define GL_SRGB8_ALPHA8 0x8C43 301 | #define GL_INT_SAMPLER_1D 0x8DC9 302 | #define GL_SRGB8 0x8C41 303 | #define GL_FLOAT_MAT3x2 0x8B67 304 | #define GL_FLOAT_MAT2x4 0x8B66 305 | #define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF 306 | #define GL_UNIFORM_ARRAY_STRIDE 0x8A3C 307 | #define GL_COMPARE_REF_TO_TEXTURE 0x884E 308 | #define GL_COMPARE_R_TO_TEXTURE 0x884E 309 | #define GL_PIXEL_UNPACK_BUFFER 0x88EC 310 | #define GL_FLOAT_MAT4x2 0x8B69 311 | #define GL_PIXEL_PACK_BUFFER 0x88EB 312 | #define GL_STENCIL_BACK_WRITEMASK 0x8CA5 313 | #define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 314 | #define GL_STENCIL_BACK_REF 0x8CA3 315 | #define GL_UPPER_LEFT 0x8CA2 316 | #define GL_COMPRESSED_SRGB 0x8C48 317 | #define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 318 | #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B 319 | #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A 320 | #define GL_INT_SAMPLER_2D_ARRAY 0x8DCF 321 | #define GL_FLOAT_MAT2x3 0x8B65 322 | #define GL_SHADER_SOURCE_LENGTH 0x8B88 323 | #define GL_ATTACHED_SHADERS 0x8B85 324 | #define GL_COLOR_ATTACHMENT20 0x8CF4 325 | #define GL_INFO_LOG_LENGTH 0x8B84 326 | #define GL_VALIDATE_STATUS 0x8B83 327 | #define GL_DELETE_STATUS 0x8B80 328 | #define GL_UNIFORM_BLOCK_BINDING 0x8A3F 329 | #define GL_SAMPLER_2D_SHADOW 0x8B62 330 | #define GL_SAMPLER_2D 0x8B5E 331 | #define GL_FLOAT_MAT3 0x8B5B 332 | #define GL_BOOL_VEC3 0x8B58 333 | #define GL_BOOL 0x8B56 334 | #define GL_INT_VEC4 0x8B55 335 | #define GL_INT_VEC2 0x8B53 336 | #define GL_FLOAT_VEC3 0x8B51 337 | #define GL_FLOAT_MAT2 0x8B5A 338 | #define GL_FLOAT_VEC2 0x8B50 339 | #define GL_SHADER_TYPE 0x8B4F 340 | #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C 341 | #define GL_MAX_VARYING_FLOATS 0x8B4B 342 | #define GL_TEXTURE_SHARED_SIZE 0x8C3F 343 | #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 344 | #define GL_VERTEX_SHADER 0x8B31 345 | #define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 346 | #define GL_MAX_VERTEX_ATTRIBS 0x8869 347 | #define GL_BLEND_EQUATION_ALPHA 0x883D 348 | #define GL_DRAW_BUFFER15 0x8834 349 | #define GL_DRAW_BUFFER12 0x8831 350 | #define GL_DRAW_BUFFER10 0x882F 351 | #define GL_DRAW_BUFFER8 0x882D 352 | #define GL_DRAW_BUFFER7 0x882C 353 | #define GL_DRAW_BUFFER5 0x882A 354 | #define GL_DRAW_BUFFER2 0x8827 355 | #define GL_BUFFER_ACCESS_FLAGS 0x911F 356 | #define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 357 | #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD 358 | #define GL_DRAW_BUFFER9 0x882E 359 | #define GL_SRC1_ALPHA 0x8589 360 | #define GL_SOURCE1_ALPHA 0x8589 361 | #define GL_VERTEX_ARRAY_BINDING 0x85B5 362 | #define GL_INCR 0x1E02 363 | #define GL_DYNAMIC_COPY 0x88EA 364 | #define GL_DYNAMIC_DRAW 0x88E8 365 | #define GL_STATIC_READ 0x88E5 366 | #define GL_STATIC_DRAW 0x88E4 367 | #define GL_UNPACK_LSB_FIRST 0x0CF1 368 | #define GL_STREAM_READ 0x88E1 369 | #define GL_READ_WRITE 0x88BA 370 | #define GL_WRITE_ONLY 0x88B9 371 | #define GL_SAMPLER_1D_SHADOW 0x8B61 372 | #define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 373 | #define GL_READ_ONLY 0x88B8 374 | #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 375 | #define GL_QUERY_RESULT 0x8866 376 | #define GL_CURRENT_QUERY 0x8865 377 | #define GL_MAX 0x8008 378 | #define GL_MIN 0x8007 379 | #define GL_TEXTURE_CUBE_MAP 0x8513 380 | #define GL_FUNC_SUBTRACT 0x800A 381 | #define GL_FUNC_REVERSE_SUBTRACT 0x800B 382 | #define GL_CONSTANT_COLOR 0x8001 383 | #define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 384 | #define GL_MAX_ELEMENTS_INDICES 0x80E9 385 | #define GL_BLEND_COLOR 0x8005 386 | #define GL_STENCIL_BACK_FAIL 0x8801 387 | #define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 388 | #define GL_TEXTURE3 0x84C3 389 | #define GL_TEXTURE_RED_TYPE 0x8C10 390 | #define GL_DRAW_BUFFER13 0x8832 391 | #define GL_DRAW_BUFFER1 0x8826 392 | #define GL_TEXTURE_COMPARE_MODE 0x884C 393 | #define GL_COLOR_ATTACHMENT21 0x8CF5 394 | #define GL_TEXTURE_DEPTH_SIZE 0x884A 395 | #define GL_RGBA2 0x8055 396 | #define GL_DECR_WRAP 0x8508 397 | #define GL_MAX_DRAW_BUFFERS 0x8824 398 | #define GL_R8 0x8229 399 | #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 400 | #define GL_BLEND_DST_ALPHA 0x80CA 401 | #define GL_TEXTURE_LOD_BIAS 0x8501 402 | #define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 403 | #define GL_LINEAR_MIPMAP_LINEAR 0x2703 404 | #define GL_ELEMENT_ARRAY_BUFFER 0x8893 405 | #define GL_BUFFER_ACCESS 0x88BB 406 | #define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 407 | #define GL_FIRST_VERTEX_CONVENTION 0x8E4D 408 | #define GL_FIXED_ONLY 0x891D 409 | #define GL_SHORT 0x1402 410 | #define GL_DEPTH_TEST 0x0B71 411 | #define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 412 | #define GL_R8UI 0x8232 413 | #define GL_CULL_FACE_MODE 0x0B45 414 | #define GL_CLAMP_TO_BORDER 0x812D 415 | #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 416 | #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 417 | #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 418 | #define GL_SHADING_LANGUAGE_VERSION 0x8B8C 419 | #define GL_LINK_STATUS 0x8B82 420 | #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 421 | #define GL_COMPRESSED_RGBA 0x84EE 422 | #define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 423 | #define GL_BLEND_SRC_ALPHA 0x80CB 424 | #define GL_COMPRESSED_RGB 0x84ED 425 | #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C 426 | #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 427 | #define GL_POINT_SIZE_RANGE 0x0B12 428 | #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 429 | #define GL_SAMPLE_COVERAGE_INVERT 0x80AB 430 | #define GL_FLOAT_MAT4x3 0x8B6A 431 | #define GL_SAMPLE_COVERAGE 0x80A0 432 | #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E 433 | #define GL_RGBA16F 0x881A 434 | #define GL_TEXTURE28 0x84DC 435 | #define GL_CONSTANT_ALPHA 0x8003 436 | #define GL_TEXTURE26 0x84DA 437 | #define GL_TEXTURE25 0x84D9 438 | #define GL_TEXTURE24 0x84D8 439 | #define GL_TEXTURE22 0x84D6 440 | #define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C 441 | #define GL_TEXTURE18 0x84D2 442 | #define GL_MAX_VIEWPORT_DIMS 0x0D3A 443 | #define GL_TEXTURE17 0x84D1 444 | #define GL_TEXTURE16 0x84D0 445 | #define GL_TEXTURE13 0x84CD 446 | #define GL_TEXTURE11 0x84CB 447 | #define GL_READ_FRAMEBUFFER 0x8CA8 448 | #define GL_TEXTURE10 0x84CA 449 | #define GL_TEXTURE8 0x84C8 450 | #define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 451 | #define GL_TEXTURE7 0x84C7 452 | #define GL_MAJOR_VERSION 0x821B 453 | #define GL_TEXTURE6 0x84C6 454 | #define GL_TEXTURE2 0x84C2 455 | #define GL_TEXTURE0 0x84C0 456 | #define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF 457 | #define GL_LINES_ADJACENCY 0x000A 458 | #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 459 | #define GL_LINE_WIDTH_RANGE 0x0B22 460 | #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 461 | #define GL_POINT_SIZE_RANGE 0x0B12 462 | #define GL_TEXTURE_MIN_LOD 0x813A 463 | #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F 464 | #define GL_TEXTURE19 0x84D3 465 | #define GL_CLAMP_TO_EDGE 0x812F 466 | #define GL_RGB8_SNORM 0x8F96 467 | #define GL_MAX_ELEMENTS_VERTICES 0x80E8 468 | #define GL_DRAW_BUFFER4 0x8829 469 | #define GL_BGR 0x80E0 470 | #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 471 | #define GL_RGB16I 0x8D89 472 | #define GL_TEXTURE15 0x84CF 473 | #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 474 | #define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C 475 | #define GL_UNSIGNED_SHORT_5_6_5 0x8363 476 | #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 477 | #define GL_MAX_3D_TEXTURE_SIZE 0x8073 478 | #define GL_TEXTURE_WRAP_R 0x8072 479 | #define GL_INT_VEC3 0x8B54 480 | #define GL_DRAW_BUFFER11 0x8830 481 | #define GL_TEXTURE_DEPTH 0x8071 482 | #define GL_PACK_SKIP_IMAGES 0x806B 483 | #define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 484 | #define GL_TEXTURE_BINDING_3D 0x806A 485 | #define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 486 | #define GL_UNSIGNED_INT_10_10_10_2 0x8036 487 | #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 488 | #define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED 489 | #define GL_NEAREST_MIPMAP_NEAREST 0x2700 490 | #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 491 | #define GL_FLOAT_MAT4 0x8B5C 492 | #define GL_UNSIGNED_INT_VEC3 0x8DC7 493 | #define GL_SRC_ALPHA_SATURATE 0x0308 494 | #define GL_POINT 0x1B00 495 | #define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 496 | #define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 497 | #define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 498 | #define GL_SAMPLE_MASK 0x8E51 499 | #define GL_DEPTH_STENCIL_ATTACHMENT 0x821A 500 | #define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 501 | #define GL_R8_SNORM 0x8F94 502 | #define GL_CURRENT_VERTEX_ATTRIB 0x8626 503 | #define GL_TEXTURE31 0x84DF 504 | #define GL_INT_SAMPLER_2D_RECT 0x8DCD 505 | #define GL_R16UI 0x8234 506 | #define GL_UNIFORM_NAME_LENGTH 0x8A39 507 | #define GL_STREAM_DRAW 0x88E0 508 | #define GL_VIEWPORT 0x0BA2 509 | #define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 510 | #define GL_FRONT_FACE 0x0B46 511 | #define GL_ONE 1 512 | #define GL_BLEND_EQUATION_RGB 0x8009 513 | #define GL_RG8 0x822B 514 | #define GL_DEPTH_COMPONENT24 0x81A6 515 | #define GL_NEAREST_MIPMAP_LINEAR 0x2702 516 | #define GL_BGRA_INTEGER 0x8D9B 517 | #define GL_UNIFORM_TYPE 0x8A37 518 | #define GL_UNSIGNALED 0x9118 519 | #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 520 | #define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 521 | #define GL_POLYGON_OFFSET_POINT 0x2A01 522 | #define GL_OR 0x1507 523 | #define GL_BUFFER_USAGE 0x8765 524 | #define GL_SAMPLER_2D_RECT 0x8B63 525 | #define GL_RGBA16 0x805B 526 | #define GL_RGBA12 0x805A 527 | #define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 528 | #define GL_RGB10_A2 0x8059 529 | #define GL_RGBA8 0x8058 530 | #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 531 | #define GL_COLOR_ATTACHMENT1 0x8CE1 532 | #define GL_RGBA4 0x8056 533 | #define GL_RGB8 0x8051 534 | #define GL_FLOAT_VEC4 0x8B52 535 | #define GL_PROXY_TEXTURE_2D 0x8064 536 | #define GL_QUERY_BY_REGION_WAIT 0x8E15 537 | #define GL_PROXY_TEXTURE_1D 0x8063 538 | #define GL_BUFFER_MAPPED 0x88BC 539 | #define GL_TEXTURE_BLUE_SIZE 0x805E 540 | #define GL_ARRAY_BUFFER 0x8892 541 | #define GL_DOUBLE 0x140A 542 | #define GL_TEXTURE_ALPHA_SIZE 0x805F 543 | #define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 544 | #define GL_TEXTURE_GREEN_SIZE 0x805D 545 | #define GL_SIGNALED 0x9119 546 | #define GL_UNIFORM_BUFFER_START 0x8A29 547 | #define GL_TEXTURE_INTERNAL_FORMAT 0x1003 548 | #define GL_COLOR_ATTACHMENT13 0x8CED 549 | #define GL_RGB32F 0x8815 550 | #define GL_CLEAR 0x1500 551 | #define GL_SAMPLES_PASSED 0x8914 552 | #define GL_INVALID_OPERATION 0x0502 553 | #define GL_TEXTURE_BINDING_2D 0x8069 554 | #define GL_TEXTURE_BINDING_1D 0x8068 555 | #define GL_POLYGON_OFFSET_LINE 0x2A02 556 | #define GL_STENCIL_WRITEMASK 0x0B98 557 | #define GL_POLYGON_OFFSET_UNITS 0x2A00 558 | #define GL_LOWER_LEFT 0x8CA1 559 | #define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 560 | #define GL_STENCIL 0x1802 561 | #define GL_COLOR_LOGIC_OP 0x0BF2 562 | #define GL_RGB16F 0x881B 563 | #define GL_CURRENT_PROGRAM 0x8B8D 564 | #define GL_BGRA 0x80E1 565 | #define GL_CLIP_DISTANCE7 0x3007 566 | #define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 567 | #define GL_SRGB 0x8C40 568 | #define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D 569 | #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 570 | #define GL_RGB12 0x8053 571 | #define GL_RG16UI 0x823A 572 | #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 573 | #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 574 | #define GL_POINT_SIZE_GRANULARITY 0x0B13 575 | #define GL_UNIFORM_BLOCK_INDEX 0x8A3A 576 | #define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D 577 | #define GL_BLEND_SRC_RGB 0x80C9 578 | #define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 579 | #define GL_LINE_SMOOTH_HINT 0x0C52 580 | #define GL_DEPTH_RANGE 0x0B70 581 | #define GL_SAMPLE_BUFFERS 0x80A8 582 | #define GL_TEXTURE_2D 0x0DE1 583 | #define GL_ARRAY_BUFFER_BINDING 0x8894 584 | #define GL_MINOR_VERSION 0x821C 585 | #define GL_DEPTH 0x1801 586 | #define GL_FRONT_RIGHT 0x0401 587 | #define GL_RGB4 0x804F 588 | #define GL_FRONT 0x0404 589 | #define GL_BOOL_VEC2 0x8B57 590 | #define GL_BUFFER_MAP_POINTER 0x88BD 591 | #define GL_STENCIL_BUFFER_BIT 0x00000400 592 | #define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD 593 | #define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE 594 | #define GL_LINE_SMOOTH 0x0B20 595 | #define GL_TEXTURE29 0x84DD 596 | #define GL_TEXTURE27 0x84DB 597 | #define GL_COMPRESSED_RG 0x8226 598 | #define GL_DONT_CARE 0x1100 599 | #define GL_DEPTH_CLAMP 0x864F 600 | #define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B 601 | #define GL_NOR 0x1508 602 | #define GL_POINT_SIZE_GRANULARITY 0x0B13 603 | #define GL_POLYGON_SMOOTH 0x0B41 604 | #define GL_COMPRESSED_RG_RGTC2 0x8DBD 605 | #define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 606 | #define GL_PACK_LSB_FIRST 0x0D01 607 | #define GL_RGB16 0x8054 608 | #define GL_REPEAT 0x2901 609 | #define GL_LINE_WIDTH 0x0B21 610 | #define GL_RGB8I 0x8D8F 611 | #define GL_RGBA 0x1908 612 | #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E 613 | #define GL_TEXTURE_RED_SIZE 0x805C 614 | #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 615 | #define GL_DECR 0x1E03 616 | #define GL_BLEND_DST_RGB 0x80C8 617 | #define GL_SEPARATE_ATTRIBS 0x8C8D 618 | #define GL_DEPTH_COMPONENT32 0x81A7 619 | #define GL_INT_SAMPLER_2D 0x8DCA 620 | #define GL_DRAW_BUFFER 0x0C01 621 | #define GL_R3_G3_B2 0x2A10 622 | #define GL_INT 0x1404 623 | #define GL_FRAGMENT_SHADER 0x8B30 624 | #define GL_LINE_WIDTH_RANGE 0x0B22 625 | #define GL_SAMPLER_CUBE_SHADOW 0x8DC5 626 | #define GL_FLOAT 0x1406 627 | #define GL_UNIFORM_OFFSET 0x8A3B 628 | #define GL_STENCIL_INDEX1 0x8D46 629 | #define GL_TEXTURE_MAX_LOD 0x813B 630 | #define GL_UNPACK_ALIGNMENT 0x0CF5 631 | #define GL_SCISSOR_BOX 0x0C10 632 | #define GL_TEXTURE1 0x84C1 633 | #define GL_DEPTH_COMPONENT 0x1902 634 | #define GL_UNPACK_SKIP_PIXELS 0x0CF4 635 | #define GL_COPY_READ_BUFFER 0x8F36 636 | #define GL_COLOR_ATTACHMENT5 0x8CE5 637 | #define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 638 | #define GL_LINE_STRIP_ADJACENCY 0x000B 639 | #define GL_RG8_SNORM 0x8F95 640 | #define GL_ONE_MINUS_DST_ALPHA 0x0305 641 | #define GL_COLOR 0x1800 642 | #define GL_TEXTURE_2D_ARRAY 0x8C1A 643 | #define GL_TRIANGLES 0x0004 644 | #define GL_DOUBLEBUFFER 0x0C32 645 | #define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 646 | #define GL_LINE 0x1B01 647 | #define GL_BLEND_EQUATION 0x8009 648 | #define GL_NAND 0x150E 649 | #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B 650 | #define GL_COLOR_ATTACHMENT24 0x8CF8 651 | #define GL_AND 0x1501 652 | #define GL_FLOAT_MAT3x4 0x8B68 653 | #define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F 654 | #define GL_UNSIGNED_INT_8_8_8_8 0x8035 655 | #define GL_CLIP_DISTANCE5 0x3005 656 | #define GL_CLIP_PLANE5 0x3005 657 | #define GL_POLYGON_OFFSET_FACTOR 0x8038 658 | #define GL_UNSIGNED_BYTE 0x1401 659 | #define GL_UNIFORM_BUFFER_BINDING 0x8A28 660 | #define GL_DEPTH_FUNC 0x0B74 661 | #define GL_TEXTURE_MAG_FILTER 0x2800 662 | #define GL_PACK_IMAGE_HEIGHT 0x806C 663 | #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 664 | #define GL_SAMPLE_ALPHA_TO_ONE 0x809F 665 | #define GL_NONE 0 666 | #define GL_CLIP_DISTANCE1 0x3001 667 | #define GL_CLIP_PLANE1 0x3001 668 | #define GL_BACK_LEFT 0x0402 669 | #define GL_XOR 0x1506 670 | #define GL_SRC_COLOR 0x0300 671 | #define GL_SAMPLER_1D_ARRAY 0x8DC0 672 | #define GL_SAMPLER_BUFFER 0x8DC2 673 | #define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 674 | #define GL_BUFFER_SIZE 0x8764 675 | #define GL_STREAM_COPY 0x88E2 676 | #define GL_BYTE 0x1400 677 | #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A 678 | #define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 679 | #define GL_COLOR_CLEAR_VALUE 0x0C22 680 | #define GL_LINE_STRIP 0x0003 681 | #define GL_TEXTURE_3D 0x806F 682 | #define GL_LOGIC_OP_MODE 0x0BF0 683 | #define GL_CW 0x0900 684 | #define GL_ACTIVE_ATTRIBUTES 0x8B89 685 | #define GL_LINEAR 0x2601 686 | #define GL_RENDERBUFFER 0x8D41 687 | #define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB 688 | #define GL_BACK_RIGHT 0x0403 689 | #define GL_TEXTURE_MAX_LEVEL 0x813D 690 | #define GL_TEXTURE30 0x84DE 691 | #define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 692 | #define GL_AND_REVERSE 0x1502 693 | #define GL_QUERY_COUNTER_BITS 0x8864 694 | #define GL_DEPTH_CLEAR_VALUE 0x0B73 695 | #define GL_TEXTURE_BINDING_BUFFER 0x8C2C 696 | #define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A 697 | #define GL_OUT_OF_MEMORY 0x0505 698 | #define GL_SAMPLER_CUBE 0x8B60 699 | #define GL_UNSIGNED_BYTE_3_3_2 0x8032 700 | #define GL_GEQUAL 0x0206 701 | #define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF 702 | #define GL_COLOR_BUFFER_BIT 0x00004000 703 | #define GL_TEXTURE_COMPRESSION_HINT 0x84EF 704 | #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 705 | #define GL_LINE_WIDTH_GRANULARITY 0x0B23 706 | #define GL_SIGNED_NORMALIZED 0x8F9C 707 | #define GL_INVALID_ENUM 0x0500 708 | #define GL_GEOMETRY_INPUT_TYPE 0x8917 709 | #define GL_RGBA32F 0x8814 710 | #define GL_SAMPLER_1D 0x8B5D 711 | #define GL_BOOL_VEC4 0x8B59 712 | #define GL_CLIP_DISTANCE0 0x3000 713 | #define GL_CLIP_PLANE0 0x3000 714 | #define GL_UNPACK_SKIP_IMAGES 0x806D 715 | #define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B 716 | #define GL_DYNAMIC_READ 0x88E9 717 | #define GL_SAMPLES 0x80A9 718 | #define GL_COLOR_ATTACHMENT25 0x8CF9 719 | #define GL_TEXTURE9 0x84C9 720 | #define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 721 | #define GL_TEXTURE 0x1702 722 | #define GL_AND_INVERTED 0x1504 723 | #define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 724 | #define GL_ACTIVE_TEXTURE 0x84E0 725 | #define GL_BLEND 0x0BE2 726 | #define GL_SRGB_ALPHA 0x8C42 727 | #define GL_ONE_MINUS_SRC_ALPHA 0x0303 728 | #define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B 729 | #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 730 | #define GL_COLOR_WRITEMASK 0x0C23 731 | #define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 732 | #define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 733 | #define GL_MAX_CLIP_DISTANCES 0x0D32 734 | #define GL_MAX_CLIP_PLANES 0x0D32 735 | #define GL_TEXTURE_WRAP_T 0x2803 736 | #define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 737 | #define GL_RGBA_INTEGER 0x8D99 738 | #define GL_INVALID_VALUE 0x0501 739 | #define GL_TEXTURE_WRAP_S 0x2802 740 | #define GL_TEXTURE_MIN_FILTER 0x2801 741 | #define GL_LINEAR_MIPMAP_NEAREST 0x2701 742 | #define GL_DRAW_BUFFER3 0x8828 743 | #define GL_EXTENSIONS 0x1F03 744 | #define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD 745 | #define GL_RENDERER 0x1F01 746 | #define GL_NO_ERROR 0 747 | #define GL_REPLACE 0x1E01 748 | #define GL_STENCIL_BACK_FUNC 0x8800 749 | #define GL_KEEP 0x1E00 750 | #define GL_FILL 0x1B02 751 | #define GL_CCW 0x0901 752 | #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 753 | #define GL_TEXTURE14 0x84CE 754 | #define GL_DEPTH24_STENCIL8 0x88F0 755 | #define GL_TEXTURE_WIDTH 0x1000 756 | #define GL_NOOP 0x1505 757 | #define GL_RGB 0x1907 758 | #define GL_ALPHA 0x1906 759 | #define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 760 | #define GL_BLUE 0x1905 761 | #define GL_GREEN 0x1904 762 | #define GL_UNPACK_IMAGE_HEIGHT 0x806E 763 | #define GL_UNIFORM_BUFFER_SIZE 0x8A2A 764 | #define GL_INVALID_INDEX 0xFFFFFFFFu 765 | #define GL_RENDERBUFFER_RED_SIZE 0x8D50 766 | #define GL_STENCIL_INDEX 0x1901 767 | #define GL_SET 0x150F 768 | #define GL_TRIANGLE_STRIP 0x0005 769 | #define GL_SUBPIXEL_BITS 0x0D50 770 | #define GL_STENCIL_FUNC 0x0B92 771 | #define GL_FALSE 0 772 | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 773 | #define GL_COPY_INVERTED 0x150C 774 | #define GL_ZERO 0 775 | #define GL_CULL_FACE 0x0B44 776 | #define GL_OR_REVERSE 0x150B 777 | #define GL_INVERT 0x150A 778 | #define GL_PACK_ALIGNMENT 0x0D05 779 | #define GL_EQUIV 0x1509 780 | #define GL_POINT_SIZE 0x0B11 781 | #define GL_TEXTURE20 0x84D4 782 | #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D 783 | #define GL_COPY 0x1503 784 | #define GL_TEXTURE_COMPRESSED 0x86A1 785 | #define GL_UNSIGNED_INT 0x1405 786 | #define GL_TEXTURE4 0x84C4 787 | #define GL_HALF_FLOAT 0x140B 788 | #define GL_STATIC_COPY 0x88E6 789 | #define GL_UNSIGNED_SHORT 0x1403 790 | #define GL_TEXTURE_1D 0x0DE0 791 | #define GL_MAX_TEXTURE_SIZE 0x0D33 792 | #define GL_PACK_SKIP_PIXELS 0x0D04 793 | #define GL_NEAREST 0x2600 794 | #define GL_BLEND_SRC 0x0BE1 795 | #define GL_SAMPLE_MASK_VALUE 0x8E52 796 | #define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 797 | #define GL_PACK_SKIP_ROWS 0x0D03 798 | #define GL_RG32I 0x823B 799 | #define GL_PACK_ROW_LENGTH 0x0D02 800 | #define GL_TEXTURE12 0x84CC 801 | #define GL_GEOMETRY_VERTICES_OUT 0x8916 802 | #define GL_SCISSOR_TEST 0x0C11 803 | #define GL_COMPRESSED_RED 0x8225 804 | #define GL_LEQUAL 0x0203 805 | #define GL_POLYGON_MODE 0x0B40 806 | #define GL_BLEND_DST 0x0BE0 807 | #define GL_SAMPLER_3D 0x8B5F 808 | #define GL_STENCIL_VALUE_MASK 0x0B93 809 | #define GL_COMPRESSED_RED_RGTC1 0x8DBB 810 | #define GL_OR_INVERTED 0x150D 811 | #define GL_DRAW_BUFFER0 0x8825 812 | #define GL_READ_BUFFER 0x0C02 813 | #define GL_NICEST 0x1102 814 | #define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D 815 | #define GL_STENCIL_TEST 0x0B90 816 | #define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 817 | #define GL_DITHER 0x0BD0 818 | #define GL_STENCIL_INDEX8 0x8D48 819 | #define GL_DEPTH_COMPONENT16 0x81A5 820 | #define GL_PACK_SWAP_BYTES 0x0D00 821 | #define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 822 | #define GL_TEXTURE_BORDER_COLOR 0x1004 823 | #define GL_STENCIL_REF 0x0B97 824 | #define GL_PROXY_TEXTURE_3D 0x8070 825 | #define GL_RENDERBUFFER_WIDTH 0x8D42 826 | #define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 827 | #define GL_RG32UI 0x823C 828 | #define GL_EQUAL 0x0202 829 | #define GL_STENCIL_CLEAR_VALUE 0x0B91 830 | #define GL_UNPACK_SWAP_BYTES 0x0CF0 831 | #define GL_POLYGON_SMOOTH_HINT 0x0C53 832 | #define GL_CONTEXT_PROFILE_MASK 0x9126 833 | #define GL_FRAMEBUFFER 0x8D40 834 | #define GL_TEXTURE_HEIGHT 0x1001 835 | #define GL_TEXTURE_BASE_LEVEL 0x813C 836 | #define GL_RGB5 0x8050 837 | #define GL_TRIANGLE_FAN 0x0006 838 | #define GL_UNPACK_ROW_LENGTH 0x0CF2 839 | #define GL_TEXTURE21 0x84D5 840 | #define GL_LINES 0x0001 841 | #define GL_TEXTURE_DEPTH_TYPE 0x8C16 842 | #define GL_DEPTH_BUFFER_BIT 0x00000100 843 | #define GL_TEXTURE_COMPARE_FUNC 0x884D 844 | #define GL_RIGHT 0x0407 845 | #define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 846 | #define GL_SRC_ALPHA 0x0302 847 | #define GL_INCR_WRAP 0x8507 848 | #define GL_LESS 0x0201 849 | #define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E 850 | #define GL_MULTISAMPLE 0x809D 851 | #define GL_DRAW_BUFFER6 0x882B 852 | #define GL_SYNC_FLAGS 0x9115 853 | #define GL_FRONT_AND_BACK 0x0408 854 | #define GL_LEFT 0x0406 855 | #define GL_FRAMEBUFFER_BINDING 0x8CA6 856 | #define GL_RGB8UI 0x8D7D 857 | #define GL_LINE_WIDTH_GRANULARITY 0x0B23 858 | #define GL_BACK 0x0405 859 | #define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 860 | #define GL_RGB10 0x8052 861 | #define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 862 | #define GL_CLIP_DISTANCE3 0x3003 863 | #define GL_CLIP_PLANE3 0x3003 864 | #define GL_STENCIL_FAIL 0x0B94 865 | #define GL_RG 0x8227 866 | #define GL_SAMPLE_COVERAGE_VALUE 0x80AA 867 | #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 868 | #define GL_ALWAYS 0x0207 869 | #define GL_COLOR_ATTACHMENT28 0x8CFC 870 | #define GL_FUNC_ADD 0x8006 871 | #define GL_CLIP_DISTANCE2 0x3002 872 | #define GL_CLIP_PLANE2 0x3002 873 | #define GL_QUERY_RESULT_AVAILABLE 0x8867 874 | #define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 875 | #define GL_FRONT_LEFT 0x0400 876 | #define GL_DEPTH_WRITEMASK 0x0B72 877 | #define GL_DRAW_BUFFER14 0x8833 878 | #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 879 | #define GL_ONE_MINUS_DST_COLOR 0x0307 880 | #define GL_LINE_LOOP 0x0002 881 | #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A 882 | #define GL_NOTEQUAL 0x0205 883 | #define GL_TEXTURE5 0x84C5 884 | #define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F 885 | #define GL_DST_COLOR 0x0306 886 | #define GL_COMPILE_STATUS 0x8B81 887 | #define GL_RED 0x1903 888 | #define GL_ACTIVE_UNIFORMS 0x8B86 889 | #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 890 | #define GL_RGB_INTEGER 0x8D98 891 | #define GL_FASTEST 0x1101 892 | #define GL_COLOR_ATTACHMENT3 0x8CE3 893 | #define GL_DST_ALPHA 0x0304 894 | #define GL_STEREO 0x0C33 895 | #define GL_RGB5_A1 0x8057 896 | #define GL_UNPACK_SKIP_ROWS 0x0CF3 897 | #define GL_GREATER 0x0204 898 | #define GL_POLYGON_OFFSET_FILL 0x8037 899 | #define GL_PRIMITIVE_RESTART 0x8F9D 900 | #define GL_TRUE 1 901 | #define GL_NEVER 0x0200 902 | #define GL_VENDOR 0x1F00 903 | #define GL_POINTS 0x0000 904 | #define GL_ONE_MINUS_SRC_COLOR 0x0301 905 | #define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 906 | #define GL_MIRRORED_REPEAT 0x8370 907 | #define GL_RGBA8UI 0x8D7C 908 | #define GL_VERSION 0x1F02 909 | #define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B 910 | #define GL_UNIFORM_BUFFER 0x8A11 911 | #define GL_TEXTURE23 0x84D7 912 | #define GL_INTERLEAVED_ATTRIBS 0x8C8C 913 | 914 | typedef void (GL_APIENTRY *PFN_glGetMultisamplefv)(GLenum pname, GLuint index, GLfloat * val); 915 | extern PFN_glGetMultisamplefv _glptr_glGetMultisamplefv; 916 | #define glGetMultisamplefv _glptr_glGetMultisamplefv 917 | 918 | typedef void (GL_APIENTRY *PFN_glTexImage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); 919 | extern PFN_glTexImage3DMultisample _glptr_glTexImage3DMultisample; 920 | #define glTexImage3DMultisample _glptr_glTexImage3DMultisample 921 | 922 | typedef void (GL_APIENTRY *PFN_glFramebufferTexture)(GLenum target, GLenum attachment, GLuint texture, GLint level); 923 | extern PFN_glFramebufferTexture _glptr_glFramebufferTexture; 924 | #define glFramebufferTexture _glptr_glFramebufferTexture 925 | 926 | typedef void (GL_APIENTRY *PFN_glGetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 * params); 927 | extern PFN_glGetBufferParameteri64v _glptr_glGetBufferParameteri64v; 928 | #define glGetBufferParameteri64v _glptr_glGetBufferParameteri64v 929 | 930 | typedef void (GL_APIENTRY *PFN_glGetInteger64i_v)(GLenum target, GLuint index, GLint64 * data); 931 | extern PFN_glGetInteger64i_v _glptr_glGetInteger64i_v; 932 | #define glGetInteger64i_v _glptr_glGetInteger64i_v 933 | 934 | typedef void (GL_APIENTRY *PFN_glWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); 935 | extern PFN_glWaitSync _glptr_glWaitSync; 936 | #define glWaitSync _glptr_glWaitSync 937 | 938 | typedef GLboolean (GL_APIENTRY *PFN_glIsSync)(GLsync sync); 939 | extern PFN_glIsSync _glptr_glIsSync; 940 | #define glIsSync _glptr_glIsSync 941 | 942 | typedef GLsync (GL_APIENTRY *PFN_glFenceSync)(GLenum condition, GLbitfield flags); 943 | extern PFN_glFenceSync _glptr_glFenceSync; 944 | #define glFenceSync _glptr_glFenceSync 945 | 946 | typedef void (GL_APIENTRY *PFN_glMultiDrawElementsBaseVertex)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex); 947 | extern PFN_glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex; 948 | #define glMultiDrawElementsBaseVertex _glptr_glMultiDrawElementsBaseVertex 949 | 950 | typedef void (GL_APIENTRY *PFN_glDrawElementsInstancedBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex); 951 | extern PFN_glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex; 952 | #define glDrawElementsInstancedBaseVertex _glptr_glDrawElementsInstancedBaseVertex 953 | 954 | typedef void (GL_APIENTRY *PFN_glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName); 955 | extern PFN_glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName; 956 | #define glGetActiveUniformBlockName _glptr_glGetActiveUniformBlockName 957 | 958 | typedef GLuint (GL_APIENTRY *PFN_glGetUniformBlockIndex)(GLuint program, const GLchar * uniformBlockName); 959 | extern PFN_glGetUniformBlockIndex _glptr_glGetUniformBlockIndex; 960 | #define glGetUniformBlockIndex _glptr_glGetUniformBlockIndex 961 | 962 | typedef void (GL_APIENTRY *PFN_glGetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName); 963 | extern PFN_glGetActiveUniformName _glptr_glGetActiveUniformName; 964 | #define glGetActiveUniformName _glptr_glGetActiveUniformName 965 | 966 | typedef void (GL_APIENTRY *PFN_glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices); 967 | extern PFN_glGetUniformIndices _glptr_glGetUniformIndices; 968 | #define glGetUniformIndices _glptr_glGetUniformIndices 969 | 970 | typedef void (GL_APIENTRY *PFN_glTexBuffer)(GLenum target, GLenum internalformat, GLuint buffer); 971 | extern PFN_glTexBuffer _glptr_glTexBuffer; 972 | #define glTexBuffer _glptr_glTexBuffer 973 | 974 | typedef GLboolean (GL_APIENTRY *PFN_glIsVertexArray)(GLuint array); 975 | extern PFN_glIsVertexArray _glptr_glIsVertexArray; 976 | #define glIsVertexArray _glptr_glIsVertexArray 977 | 978 | typedef void (GL_APIENTRY *PFN_glBindVertexArray)(GLuint array); 979 | extern PFN_glBindVertexArray _glptr_glBindVertexArray; 980 | #define glBindVertexArray _glptr_glBindVertexArray 981 | 982 | typedef void (GL_APIENTRY *PFN_glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length); 983 | extern PFN_glFlushMappedBufferRange _glptr_glFlushMappedBufferRange; 984 | #define glFlushMappedBufferRange _glptr_glFlushMappedBufferRange 985 | 986 | typedef void * (GL_APIENTRY *PFN_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); 987 | extern PFN_glMapBufferRange _glptr_glMapBufferRange; 988 | #define glMapBufferRange _glptr_glMapBufferRange 989 | 990 | typedef void (GL_APIENTRY *PFN_glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params); 991 | extern PFN_glGetActiveUniformsiv _glptr_glGetActiveUniformsiv; 992 | #define glGetActiveUniformsiv _glptr_glGetActiveUniformsiv 993 | 994 | typedef void (GL_APIENTRY *PFN_glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); 995 | extern PFN_glFramebufferTextureLayer _glptr_glFramebufferTextureLayer; 996 | #define glFramebufferTextureLayer _glptr_glFramebufferTextureLayer 997 | 998 | typedef void (GL_APIENTRY *PFN_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params); 999 | extern PFN_glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv; 1000 | #define glGetFramebufferAttachmentParameteriv _glptr_glGetFramebufferAttachmentParameteriv 1001 | 1002 | typedef void (GL_APIENTRY *PFN_glFramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); 1003 | extern PFN_glFramebufferTexture3D _glptr_glFramebufferTexture3D; 1004 | #define glFramebufferTexture3D _glptr_glFramebufferTexture3D 1005 | 1006 | typedef void (GL_APIENTRY *PFN_glFramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); 1007 | extern PFN_glFramebufferTexture1D _glptr_glFramebufferTexture1D; 1008 | #define glFramebufferTexture1D _glptr_glFramebufferTexture1D 1009 | 1010 | typedef void (GL_APIENTRY *PFN_glGenFramebuffers)(GLsizei n, GLuint * framebuffers); 1011 | extern PFN_glGenFramebuffers _glptr_glGenFramebuffers; 1012 | #define glGenFramebuffers _glptr_glGenFramebuffers 1013 | 1014 | typedef void (GL_APIENTRY *PFN_glBindFramebuffer)(GLenum target, GLuint framebuffer); 1015 | extern PFN_glBindFramebuffer _glptr_glBindFramebuffer; 1016 | #define glBindFramebuffer _glptr_glBindFramebuffer 1017 | 1018 | typedef void (GL_APIENTRY *PFN_glGetInteger64v)(GLenum pname, GLint64 * data); 1019 | extern PFN_glGetInteger64v _glptr_glGetInteger64v; 1020 | #define glGetInteger64v _glptr_glGetInteger64v 1021 | 1022 | typedef GLboolean (GL_APIENTRY *PFN_glIsFramebuffer)(GLuint framebuffer); 1023 | extern PFN_glIsFramebuffer _glptr_glIsFramebuffer; 1024 | #define glIsFramebuffer _glptr_glIsFramebuffer 1025 | 1026 | typedef void (GL_APIENTRY *PFN_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params); 1027 | extern PFN_glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv; 1028 | #define glGetRenderbufferParameteriv _glptr_glGetRenderbufferParameteriv 1029 | 1030 | typedef void (GL_APIENTRY *PFN_glBindRenderbuffer)(GLenum target, GLuint renderbuffer); 1031 | extern PFN_glBindRenderbuffer _glptr_glBindRenderbuffer; 1032 | #define glBindRenderbuffer _glptr_glBindRenderbuffer 1033 | 1034 | typedef GLboolean (GL_APIENTRY *PFN_glIsRenderbuffer)(GLuint renderbuffer); 1035 | extern PFN_glIsRenderbuffer _glptr_glIsRenderbuffer; 1036 | #define glIsRenderbuffer _glptr_glIsRenderbuffer 1037 | 1038 | typedef const GLubyte * (GL_APIENTRY *PFN_glGetStringi)(GLenum name, GLuint index); 1039 | extern PFN_glGetStringi _glptr_glGetStringi; 1040 | #define glGetStringi _glptr_glGetStringi 1041 | 1042 | typedef void (GL_APIENTRY *PFN_glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); 1043 | extern PFN_glClearBufferfi _glptr_glClearBufferfi; 1044 | #define glClearBufferfi _glptr_glClearBufferfi 1045 | 1046 | typedef void (GL_APIENTRY *PFN_glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat * value); 1047 | extern PFN_glClearBufferfv _glptr_glClearBufferfv; 1048 | #define glClearBufferfv _glptr_glClearBufferfv 1049 | 1050 | typedef void (GL_APIENTRY *PFN_glGetTexParameterIiv)(GLenum target, GLenum pname, GLint * params); 1051 | extern PFN_glGetTexParameterIiv _glptr_glGetTexParameterIiv; 1052 | #define glGetTexParameterIiv _glptr_glGetTexParameterIiv 1053 | 1054 | typedef void (GL_APIENTRY *PFN_glTexParameterIiv)(GLenum target, GLenum pname, const GLint * params); 1055 | extern PFN_glTexParameterIiv _glptr_glTexParameterIiv; 1056 | #define glTexParameterIiv _glptr_glTexParameterIiv 1057 | 1058 | typedef void (GL_APIENTRY *PFN_glUniform4uiv)(GLint location, GLsizei count, const GLuint * value); 1059 | extern PFN_glUniform4uiv _glptr_glUniform4uiv; 1060 | #define glUniform4uiv _glptr_glUniform4uiv 1061 | 1062 | typedef void (GL_APIENTRY *PFN_glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2); 1063 | extern PFN_glUniform3ui _glptr_glUniform3ui; 1064 | #define glUniform3ui _glptr_glUniform3ui 1065 | 1066 | typedef void (GL_APIENTRY *PFN_glUniform1ui)(GLint location, GLuint v0); 1067 | extern PFN_glUniform1ui _glptr_glUniform1ui; 1068 | #define glUniform1ui _glptr_glUniform1ui 1069 | 1070 | typedef GLint (GL_APIENTRY *PFN_glGetFragDataLocation)(GLuint program, const GLchar * name); 1071 | extern PFN_glGetFragDataLocation _glptr_glGetFragDataLocation; 1072 | #define glGetFragDataLocation _glptr_glGetFragDataLocation 1073 | 1074 | typedef void (GL_APIENTRY *PFN_glBindFragDataLocation)(GLuint program, GLuint color, const GLchar * name); 1075 | extern PFN_glBindFragDataLocation _glptr_glBindFragDataLocation; 1076 | #define glBindFragDataLocation _glptr_glBindFragDataLocation 1077 | 1078 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4iv)(GLuint index, const GLint * v); 1079 | extern PFN_glVertexAttribI4iv _glptr_glVertexAttribI4iv; 1080 | #define glVertexAttribI4iv _glptr_glVertexAttribI4iv 1081 | 1082 | typedef void (GL_APIENTRY *PFN_glVertexAttribI2iv)(GLuint index, const GLint * v); 1083 | extern PFN_glVertexAttribI2iv _glptr_glVertexAttribI2iv; 1084 | #define glVertexAttribI2iv _glptr_glVertexAttribI2iv 1085 | 1086 | typedef void (GL_APIENTRY *PFN_glVertexAttribI1iv)(GLuint index, const GLint * v); 1087 | extern PFN_glVertexAttribI1iv _glptr_glVertexAttribI1iv; 1088 | #define glVertexAttribI1iv _glptr_glVertexAttribI1iv 1089 | 1090 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); 1091 | extern PFN_glVertexAttribI4ui _glptr_glVertexAttribI4ui; 1092 | #define glVertexAttribI4ui _glptr_glVertexAttribI4ui 1093 | 1094 | typedef void (GL_APIENTRY *PFN_glVertexAttribI2ui)(GLuint index, GLuint x, GLuint y); 1095 | extern PFN_glVertexAttribI2ui _glptr_glVertexAttribI2ui; 1096 | #define glVertexAttribI2ui _glptr_glVertexAttribI2ui 1097 | 1098 | typedef void (GL_APIENTRY *PFN_glVertexAttribI1ui)(GLuint index, GLuint x); 1099 | extern PFN_glVertexAttribI1ui _glptr_glVertexAttribI1ui; 1100 | #define glVertexAttribI1ui _glptr_glVertexAttribI1ui 1101 | 1102 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w); 1103 | extern PFN_glVertexAttribI4i _glptr_glVertexAttribI4i; 1104 | #define glVertexAttribI4i _glptr_glVertexAttribI4i 1105 | 1106 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4bv)(GLuint index, const GLbyte * v); 1107 | extern PFN_glVertexAttribI4bv _glptr_glVertexAttribI4bv; 1108 | #define glVertexAttribI4bv _glptr_glVertexAttribI4bv 1109 | 1110 | typedef void (GL_APIENTRY *PFN_glVertexAttribI2i)(GLuint index, GLint x, GLint y); 1111 | extern PFN_glVertexAttribI2i _glptr_glVertexAttribI2i; 1112 | #define glVertexAttribI2i _glptr_glVertexAttribI2i 1113 | 1114 | typedef void (GL_APIENTRY *PFN_glVertexAttribI1i)(GLuint index, GLint x); 1115 | extern PFN_glVertexAttribI1i _glptr_glVertexAttribI1i; 1116 | #define glVertexAttribI1i _glptr_glVertexAttribI1i 1117 | 1118 | typedef void (GL_APIENTRY *PFN_glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint * params); 1119 | extern PFN_glGetVertexAttribIiv _glptr_glGetVertexAttribIiv; 1120 | #define glGetVertexAttribIiv _glptr_glGetVertexAttribIiv 1121 | 1122 | typedef void (GL_APIENTRY *PFN_glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); 1123 | extern PFN_glVertexAttribIPointer _glptr_glVertexAttribIPointer; 1124 | #define glVertexAttribIPointer _glptr_glVertexAttribIPointer 1125 | 1126 | typedef void (GL_APIENTRY *PFN_glBeginConditionalRender)(GLuint id, GLenum mode); 1127 | extern PFN_glBeginConditionalRender _glptr_glBeginConditionalRender; 1128 | #define glBeginConditionalRender _glptr_glBeginConditionalRender 1129 | 1130 | typedef void (GL_APIENTRY *PFN_glClampColor)(GLenum target, GLenum clamp); 1131 | extern PFN_glClampColor _glptr_glClampColor; 1132 | #define glClampColor _glptr_glClampColor 1133 | 1134 | typedef void (GL_APIENTRY *PFN_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer); 1135 | extern PFN_glBindBufferBase _glptr_glBindBufferBase; 1136 | #define glBindBufferBase _glptr_glBindBufferBase 1137 | 1138 | typedef void (GL_APIENTRY *PFN_glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); 1139 | extern PFN_glBindBufferRange _glptr_glBindBufferRange; 1140 | #define glBindBufferRange _glptr_glBindBufferRange 1141 | 1142 | typedef void (GL_APIENTRY *PFN_glBeginTransformFeedback)(GLenum primitiveMode); 1143 | extern PFN_glBeginTransformFeedback _glptr_glBeginTransformFeedback; 1144 | #define glBeginTransformFeedback _glptr_glBeginTransformFeedback 1145 | 1146 | typedef GLboolean (GL_APIENTRY *PFN_glIsEnabledi)(GLenum target, GLuint index); 1147 | extern PFN_glIsEnabledi _glptr_glIsEnabledi; 1148 | #define glIsEnabledi _glptr_glIsEnabledi 1149 | 1150 | typedef void (GL_APIENTRY *PFN_glGetIntegeri_v)(GLenum target, GLuint index, GLint * data); 1151 | extern PFN_glGetIntegeri_v _glptr_glGetIntegeri_v; 1152 | #define glGetIntegeri_v _glptr_glGetIntegeri_v 1153 | 1154 | typedef void (GL_APIENTRY *PFN_glColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); 1155 | extern PFN_glColorMaski _glptr_glColorMaski; 1156 | #define glColorMaski _glptr_glColorMaski 1157 | 1158 | typedef void (GL_APIENTRY *PFN_glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1159 | extern PFN_glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv; 1160 | #define glUniformMatrix4x3fv _glptr_glUniformMatrix4x3fv 1161 | 1162 | typedef void (GL_APIENTRY *PFN_glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1163 | extern PFN_glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv; 1164 | #define glUniformMatrix3x4fv _glptr_glUniformMatrix3x4fv 1165 | 1166 | typedef void (GL_APIENTRY *PFN_glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1167 | extern PFN_glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv; 1168 | #define glUniformMatrix2x4fv _glptr_glUniformMatrix2x4fv 1169 | 1170 | typedef void (GL_APIENTRY *PFN_glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1171 | extern PFN_glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv; 1172 | #define glUniformMatrix3x2fv _glptr_glUniformMatrix3x2fv 1173 | 1174 | typedef void (GL_APIENTRY *PFN_glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1175 | extern PFN_glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv; 1176 | #define glUniformMatrix2x3fv _glptr_glUniformMatrix2x3fv 1177 | 1178 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4ubv)(GLuint index, const GLubyte * v); 1179 | extern PFN_glVertexAttrib4ubv _glptr_glVertexAttrib4ubv; 1180 | #define glVertexAttrib4ubv _glptr_glVertexAttrib4ubv 1181 | 1182 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4sv)(GLuint index, const GLshort * v); 1183 | extern PFN_glVertexAttrib4sv _glptr_glVertexAttrib4sv; 1184 | #define glVertexAttrib4sv _glptr_glVertexAttrib4sv 1185 | 1186 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4fv)(GLuint index, const GLfloat * v); 1187 | extern PFN_glVertexAttrib4fv _glptr_glVertexAttrib4fv; 1188 | #define glVertexAttrib4fv _glptr_glVertexAttrib4fv 1189 | 1190 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Nusv)(GLuint index, const GLushort * v); 1191 | extern PFN_glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv; 1192 | #define glVertexAttrib4Nusv _glptr_glVertexAttrib4Nusv 1193 | 1194 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Nuiv)(GLuint index, const GLuint * v); 1195 | extern PFN_glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv; 1196 | #define glVertexAttrib4Nuiv _glptr_glVertexAttrib4Nuiv 1197 | 1198 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Nubv)(GLuint index, const GLubyte * v); 1199 | extern PFN_glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv; 1200 | #define glVertexAttrib4Nubv _glptr_glVertexAttrib4Nubv 1201 | 1202 | typedef void (GL_APIENTRY *PFN_glProvokingVertex)(GLenum mode); 1203 | extern PFN_glProvokingVertex _glptr_glProvokingVertex; 1204 | #define glProvokingVertex _glptr_glProvokingVertex 1205 | 1206 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Nsv)(GLuint index, const GLshort * v); 1207 | extern PFN_glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv; 1208 | #define glVertexAttrib4Nsv _glptr_glVertexAttrib4Nsv 1209 | 1210 | typedef void (GL_APIENTRY *PFN_glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z); 1211 | extern PFN_glVertexAttrib3f _glptr_glVertexAttrib3f; 1212 | #define glVertexAttrib3f _glptr_glVertexAttrib3f 1213 | 1214 | typedef void (GL_APIENTRY *PFN_glVertexAttribI1uiv)(GLuint index, const GLuint * v); 1215 | extern PFN_glVertexAttribI1uiv _glptr_glVertexAttribI1uiv; 1216 | #define glVertexAttribI1uiv _glptr_glVertexAttribI1uiv 1217 | 1218 | typedef void (GL_APIENTRY *PFN_glVertexAttrib3dv)(GLuint index, const GLdouble * v); 1219 | extern PFN_glVertexAttrib3dv _glptr_glVertexAttrib3dv; 1220 | #define glVertexAttrib3dv _glptr_glVertexAttrib3dv 1221 | 1222 | typedef void (GL_APIENTRY *PFN_glVertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z); 1223 | extern PFN_glVertexAttrib3d _glptr_glVertexAttrib3d; 1224 | #define glVertexAttrib3d _glptr_glVertexAttrib3d 1225 | 1226 | typedef void (GL_APIENTRY *PFN_glVertexAttrib2sv)(GLuint index, const GLshort * v); 1227 | extern PFN_glVertexAttrib2sv _glptr_glVertexAttrib2sv; 1228 | #define glVertexAttrib2sv _glptr_glVertexAttrib2sv 1229 | 1230 | typedef void (GL_APIENTRY *PFN_glVertexAttrib2fv)(GLuint index, const GLfloat * v); 1231 | extern PFN_glVertexAttrib2fv _glptr_glVertexAttrib2fv; 1232 | #define glVertexAttrib2fv _glptr_glVertexAttrib2fv 1233 | 1234 | typedef void (GL_APIENTRY *PFN_glVertexAttrib2dv)(GLuint index, const GLdouble * v); 1235 | extern PFN_glVertexAttrib2dv _glptr_glVertexAttrib2dv; 1236 | #define glVertexAttrib2dv _glptr_glVertexAttrib2dv 1237 | 1238 | typedef void (GL_APIENTRY *PFN_glVertexAttrib2d)(GLuint index, GLdouble x, GLdouble y); 1239 | extern PFN_glVertexAttrib2d _glptr_glVertexAttrib2d; 1240 | #define glVertexAttrib2d _glptr_glVertexAttrib2d 1241 | 1242 | typedef void (GL_APIENTRY *PFN_glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y); 1243 | extern PFN_glVertexAttrib2f _glptr_glVertexAttrib2f; 1244 | #define glVertexAttrib2f _glptr_glVertexAttrib2f 1245 | 1246 | typedef void (GL_APIENTRY *PFN_glVertexAttrib1s)(GLuint index, GLshort x); 1247 | extern PFN_glVertexAttrib1s _glptr_glVertexAttrib1s; 1248 | #define glVertexAttrib1s _glptr_glVertexAttrib1s 1249 | 1250 | typedef void (GL_APIENTRY *PFN_glVertexAttrib1fv)(GLuint index, const GLfloat * v); 1251 | extern PFN_glVertexAttrib1fv _glptr_glVertexAttrib1fv; 1252 | #define glVertexAttrib1fv _glptr_glVertexAttrib1fv 1253 | 1254 | typedef void (GL_APIENTRY *PFN_glVertexAttrib1f)(GLuint index, GLfloat x); 1255 | extern PFN_glVertexAttrib1f _glptr_glVertexAttrib1f; 1256 | #define glVertexAttrib1f _glptr_glVertexAttrib1f 1257 | 1258 | typedef void (GL_APIENTRY *PFN_glVertexAttrib1dv)(GLuint index, const GLdouble * v); 1259 | extern PFN_glVertexAttrib1dv _glptr_glVertexAttrib1dv; 1260 | #define glVertexAttrib1dv _glptr_glVertexAttrib1dv 1261 | 1262 | typedef void (GL_APIENTRY *PFN_glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint * value); 1263 | extern PFN_glClearBufferuiv _glptr_glClearBufferuiv; 1264 | #define glClearBufferuiv _glptr_glClearBufferuiv 1265 | 1266 | typedef void (GL_APIENTRY *PFN_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1267 | extern PFN_glUniformMatrix3fv _glptr_glUniformMatrix3fv; 1268 | #define glUniformMatrix3fv _glptr_glUniformMatrix3fv 1269 | 1270 | typedef void (GL_APIENTRY *PFN_glDeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers); 1271 | extern PFN_glDeleteRenderbuffers _glptr_glDeleteRenderbuffers; 1272 | #define glDeleteRenderbuffers _glptr_glDeleteRenderbuffers 1273 | 1274 | typedef void (GL_APIENTRY *PFN_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1275 | extern PFN_glUniformMatrix2fv _glptr_glUniformMatrix2fv; 1276 | #define glUniformMatrix2fv _glptr_glUniformMatrix2fv 1277 | 1278 | typedef void (GL_APIENTRY *PFN_glUniform4iv)(GLint location, GLsizei count, const GLint * value); 1279 | extern PFN_glUniform4iv _glptr_glUniform4iv; 1280 | #define glUniform4iv _glptr_glUniform4iv 1281 | 1282 | typedef void (GL_APIENTRY *PFN_glUniform1iv)(GLint location, GLsizei count, const GLint * value); 1283 | extern PFN_glUniform1iv _glptr_glUniform1iv; 1284 | #define glUniform1iv _glptr_glUniform1iv 1285 | 1286 | typedef void (GL_APIENTRY *PFN_glUniform4fv)(GLint location, GLsizei count, const GLfloat * value); 1287 | extern PFN_glUniform4fv _glptr_glUniform4fv; 1288 | #define glUniform4fv _glptr_glUniform4fv 1289 | 1290 | typedef void (GL_APIENTRY *PFN_glUniform2fv)(GLint location, GLsizei count, const GLfloat * value); 1291 | extern PFN_glUniform2fv _glptr_glUniform2fv; 1292 | #define glUniform2fv _glptr_glUniform2fv 1293 | 1294 | typedef void (GL_APIENTRY *PFN_glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2); 1295 | extern PFN_glUniform3i _glptr_glUniform3i; 1296 | #define glUniform3i _glptr_glUniform3i 1297 | 1298 | typedef void (GL_APIENTRY *PFN_glUniform2i)(GLint location, GLint v0, GLint v1); 1299 | extern PFN_glUniform2i _glptr_glUniform2i; 1300 | #define glUniform2i _glptr_glUniform2i 1301 | 1302 | typedef void (GL_APIENTRY *PFN_glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); 1303 | extern PFN_glUniform4f _glptr_glUniform4f; 1304 | #define glUniform4f _glptr_glUniform4f 1305 | 1306 | typedef void (GL_APIENTRY *PFN_glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); 1307 | extern PFN_glUniform3f _glptr_glUniform3f; 1308 | #define glUniform3f _glptr_glUniform3f 1309 | 1310 | typedef void (GL_APIENTRY *PFN_glUniform1f)(GLint location, GLfloat v0); 1311 | extern PFN_glUniform1f _glptr_glUniform1f; 1312 | #define glUniform1f _glptr_glUniform1f 1313 | 1314 | typedef void (GL_APIENTRY *PFN_glUseProgram)(GLuint program); 1315 | extern PFN_glUseProgram _glptr_glUseProgram; 1316 | #define glUseProgram _glptr_glUseProgram 1317 | 1318 | typedef void (GL_APIENTRY *PFN_glShaderSource)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length); 1319 | extern PFN_glShaderSource _glptr_glShaderSource; 1320 | #define glShaderSource _glptr_glShaderSource 1321 | 1322 | typedef void (GL_APIENTRY *PFN_glLinkProgram)(GLuint program); 1323 | extern PFN_glLinkProgram _glptr_glLinkProgram; 1324 | #define glLinkProgram _glptr_glLinkProgram 1325 | 1326 | typedef GLboolean (GL_APIENTRY *PFN_glIsShader)(GLuint shader); 1327 | extern PFN_glIsShader _glptr_glIsShader; 1328 | #define glIsShader _glptr_glIsShader 1329 | 1330 | typedef void (GL_APIENTRY *PFN_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void ** pointer); 1331 | extern PFN_glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv; 1332 | #define glGetVertexAttribPointerv _glptr_glGetVertexAttribPointerv 1333 | 1334 | typedef void (GL_APIENTRY *PFN_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint * params); 1335 | extern PFN_glGetVertexAttribiv _glptr_glGetVertexAttribiv; 1336 | #define glGetVertexAttribiv _glptr_glGetVertexAttribiv 1337 | 1338 | typedef void (GL_APIENTRY *PFN_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat * params); 1339 | extern PFN_glGetVertexAttribfv _glptr_glGetVertexAttribfv; 1340 | #define glGetVertexAttribfv _glptr_glGetVertexAttribfv 1341 | 1342 | typedef void (GL_APIENTRY *PFN_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); 1343 | extern PFN_glUniformBlockBinding _glptr_glUniformBlockBinding; 1344 | #define glUniformBlockBinding _glptr_glUniformBlockBinding 1345 | 1346 | typedef GLint (GL_APIENTRY *PFN_glGetUniformLocation)(GLuint program, const GLchar * name); 1347 | extern PFN_glGetUniformLocation _glptr_glGetUniformLocation; 1348 | #define glGetUniformLocation _glptr_glGetUniformLocation 1349 | 1350 | typedef void (GL_APIENTRY *PFN_glGetShaderiv)(GLuint shader, GLenum pname, GLint * params); 1351 | extern PFN_glGetShaderiv _glptr_glGetShaderiv; 1352 | #define glGetShaderiv _glptr_glGetShaderiv 1353 | 1354 | typedef void (GL_APIENTRY *PFN_glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); 1355 | extern PFN_glGetProgramInfoLog _glptr_glGetProgramInfoLog; 1356 | #define glGetProgramInfoLog _glptr_glGetProgramInfoLog 1357 | 1358 | typedef GLint (GL_APIENTRY *PFN_glGetAttribLocation)(GLuint program, const GLchar * name); 1359 | extern PFN_glGetAttribLocation _glptr_glGetAttribLocation; 1360 | #define glGetAttribLocation _glptr_glGetAttribLocation 1361 | 1362 | typedef void (GL_APIENTRY *PFN_glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders); 1363 | extern PFN_glGetAttachedShaders _glptr_glGetAttachedShaders; 1364 | #define glGetAttachedShaders _glptr_glGetAttachedShaders 1365 | 1366 | typedef void (GL_APIENTRY *PFN_glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); 1367 | extern PFN_glGetActiveUniform _glptr_glGetActiveUniform; 1368 | #define glGetActiveUniform _glptr_glGetActiveUniform 1369 | 1370 | typedef void (GL_APIENTRY *PFN_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); 1371 | extern PFN_glGetActiveAttrib _glptr_glGetActiveAttrib; 1372 | #define glGetActiveAttrib _glptr_glGetActiveAttrib 1373 | 1374 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4iv)(GLuint index, const GLint * v); 1375 | extern PFN_glVertexAttrib4iv _glptr_glVertexAttrib4iv; 1376 | #define glVertexAttrib4iv _glptr_glVertexAttrib4iv 1377 | 1378 | typedef void (GL_APIENTRY *PFN_glDisableVertexAttribArray)(GLuint index); 1379 | extern PFN_glDisableVertexAttribArray _glptr_glDisableVertexAttribArray; 1380 | #define glDisableVertexAttribArray _glptr_glDisableVertexAttribArray 1381 | 1382 | typedef void (GL_APIENTRY *PFN_glDeleteShader)(GLuint shader); 1383 | extern PFN_glDeleteShader _glptr_glDeleteShader; 1384 | #define glDeleteShader _glptr_glDeleteShader 1385 | 1386 | typedef void (GL_APIENTRY *PFN_glDeleteProgram)(GLuint program); 1387 | extern PFN_glDeleteProgram _glptr_glDeleteProgram; 1388 | #define glDeleteProgram _glptr_glDeleteProgram 1389 | 1390 | typedef void (GL_APIENTRY *PFN_glGetBooleani_v)(GLenum target, GLuint index, GLboolean * data); 1391 | extern PFN_glGetBooleani_v _glptr_glGetBooleani_v; 1392 | #define glGetBooleani_v _glptr_glGetBooleani_v 1393 | 1394 | typedef void (GL_APIENTRY *PFN_glCompileShader)(GLuint shader); 1395 | extern PFN_glCompileShader _glptr_glCompileShader; 1396 | #define glCompileShader _glptr_glCompileShader 1397 | 1398 | typedef void (GL_APIENTRY *PFN_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); 1399 | extern PFN_glStencilFuncSeparate _glptr_glStencilFuncSeparate; 1400 | #define glStencilFuncSeparate _glptr_glStencilFuncSeparate 1401 | 1402 | typedef void (GL_APIENTRY *PFN_glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); 1403 | extern PFN_glStencilOpSeparate _glptr_glStencilOpSeparate; 1404 | #define glStencilOpSeparate _glptr_glStencilOpSeparate 1405 | 1406 | typedef void (GL_APIENTRY *PFN_glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); 1407 | extern PFN_glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample; 1408 | #define glRenderbufferStorageMultisample _glptr_glRenderbufferStorageMultisample 1409 | 1410 | typedef void (GL_APIENTRY *PFN_glDrawBuffers)(GLsizei n, const GLenum * bufs); 1411 | extern PFN_glDrawBuffers _glptr_glDrawBuffers; 1412 | #define glDrawBuffers _glptr_glDrawBuffers 1413 | 1414 | typedef void (GL_APIENTRY *PFN_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint * params); 1415 | extern PFN_glGetBufferParameteriv _glptr_glGetBufferParameteriv; 1416 | #define glGetBufferParameteriv _glptr_glGetBufferParameteriv 1417 | 1418 | typedef GLboolean (GL_APIENTRY *PFN_glUnmapBuffer)(GLenum target); 1419 | extern PFN_glUnmapBuffer _glptr_glUnmapBuffer; 1420 | #define glUnmapBuffer _glptr_glUnmapBuffer 1421 | 1422 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4dv)(GLuint index, const GLdouble * v); 1423 | extern PFN_glVertexAttrib4dv _glptr_glVertexAttrib4dv; 1424 | #define glVertexAttrib4dv _glptr_glVertexAttrib4dv 1425 | 1426 | typedef void * (GL_APIENTRY *PFN_glMapBuffer)(GLenum target, GLenum access); 1427 | extern PFN_glMapBuffer _glptr_glMapBuffer; 1428 | #define glMapBuffer _glptr_glMapBuffer 1429 | 1430 | typedef void (GL_APIENTRY *PFN_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data); 1431 | extern PFN_glBufferSubData _glptr_glBufferSubData; 1432 | #define glBufferSubData _glptr_glBufferSubData 1433 | 1434 | typedef void (GL_APIENTRY *PFN_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params); 1435 | extern PFN_glGetQueryObjectuiv _glptr_glGetQueryObjectuiv; 1436 | #define glGetQueryObjectuiv _glptr_glGetQueryObjectuiv 1437 | 1438 | typedef void (GL_APIENTRY *PFN_glGetQueryObjectiv)(GLuint id, GLenum pname, GLint * params); 1439 | extern PFN_glGetQueryObjectiv _glptr_glGetQueryObjectiv; 1440 | #define glGetQueryObjectiv _glptr_glGetQueryObjectiv 1441 | 1442 | typedef GLboolean (GL_APIENTRY *PFN_glIsQuery)(GLuint id); 1443 | extern PFN_glIsQuery _glptr_glIsQuery; 1444 | #define glIsQuery _glptr_glIsQuery 1445 | 1446 | typedef void (GL_APIENTRY *PFN_glDeleteQueries)(GLsizei n, const GLuint * ids); 1447 | extern PFN_glDeleteQueries _glptr_glDeleteQueries; 1448 | #define glDeleteQueries _glptr_glDeleteQueries 1449 | 1450 | typedef void (GL_APIENTRY *PFN_glGenQueries)(GLsizei n, GLuint * ids); 1451 | extern PFN_glGenQueries _glptr_glGenQueries; 1452 | #define glGenQueries _glptr_glGenQueries 1453 | 1454 | typedef void (GL_APIENTRY *PFN_glBlendEquation)(GLenum mode); 1455 | extern PFN_glBlendEquation _glptr_glBlendEquation; 1456 | #define glBlendEquation _glptr_glBlendEquation 1457 | 1458 | typedef void (GL_APIENTRY *PFN_glVertexAttrib3sv)(GLuint index, const GLshort * v); 1459 | extern PFN_glVertexAttrib3sv _glptr_glVertexAttrib3sv; 1460 | #define glVertexAttrib3sv _glptr_glVertexAttrib3sv 1461 | 1462 | typedef void (GL_APIENTRY *PFN_glVertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z); 1463 | extern PFN_glVertexAttribI3ui _glptr_glVertexAttribI3ui; 1464 | #define glVertexAttribI3ui _glptr_glVertexAttribI3ui 1465 | 1466 | typedef void (GL_APIENTRY *PFN_glGenBuffers)(GLsizei n, GLuint * buffers); 1467 | extern PFN_glGenBuffers _glptr_glGenBuffers; 1468 | #define glGenBuffers _glptr_glGenBuffers 1469 | 1470 | typedef GLenum (GL_APIENTRY *PFN_glCheckFramebufferStatus)(GLenum target); 1471 | extern PFN_glCheckFramebufferStatus _glptr_glCheckFramebufferStatus; 1472 | #define glCheckFramebufferStatus _glptr_glCheckFramebufferStatus 1473 | 1474 | typedef void (GL_APIENTRY *PFN_glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); 1475 | extern PFN_glUniform4i _glptr_glUniform4i; 1476 | #define glUniform4i _glptr_glUniform4i 1477 | 1478 | typedef void (GL_APIENTRY *PFN_glPointParameteriv)(GLenum pname, const GLint * params); 1479 | extern PFN_glPointParameteriv _glptr_glPointParameteriv; 1480 | #define glPointParameteriv _glptr_glPointParameteriv 1481 | 1482 | typedef void (GL_APIENTRY *PFN_glVertexAttrib2s)(GLuint index, GLshort x, GLshort y); 1483 | extern PFN_glVertexAttrib2s _glptr_glVertexAttrib2s; 1484 | #define glVertexAttrib2s _glptr_glVertexAttrib2s 1485 | 1486 | typedef void (GL_APIENTRY *PFN_glFinish)(); 1487 | extern PFN_glFinish _glptr_glFinish; 1488 | #define glFinish _glptr_glFinish 1489 | 1490 | typedef void (GL_APIENTRY *PFN_glPointParameteri)(GLenum pname, GLint param); 1491 | extern PFN_glPointParameteri _glptr_glPointParameteri; 1492 | #define glPointParameteri _glptr_glPointParameteri 1493 | 1494 | typedef void (GL_APIENTRY *PFN_glMultiDrawArrays)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount); 1495 | extern PFN_glMultiDrawArrays _glptr_glMultiDrawArrays; 1496 | #define glMultiDrawArrays _glptr_glMultiDrawArrays 1497 | 1498 | typedef void (GL_APIENTRY *PFN_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); 1499 | extern PFN_glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer; 1500 | #define glFramebufferRenderbuffer _glptr_glFramebufferRenderbuffer 1501 | 1502 | typedef void (GL_APIENTRY *PFN_glGetQueryiv)(GLenum target, GLenum pname, GLint * params); 1503 | extern PFN_glGetQueryiv _glptr_glGetQueryiv; 1504 | #define glGetQueryiv _glptr_glGetQueryiv 1505 | 1506 | typedef void (GL_APIENTRY *PFN_glGetUniformfv)(GLuint program, GLint location, GLfloat * params); 1507 | extern PFN_glGetUniformfv _glptr_glGetUniformfv; 1508 | #define glGetUniformfv _glptr_glGetUniformfv 1509 | 1510 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4usv)(GLuint index, const GLushort * v); 1511 | extern PFN_glVertexAttrib4usv _glptr_glVertexAttrib4usv; 1512 | #define glVertexAttrib4usv _glptr_glVertexAttrib4usv 1513 | 1514 | typedef void (GL_APIENTRY *PFN_glDeleteSync)(GLsync sync); 1515 | extern PFN_glDeleteSync _glptr_glDeleteSync; 1516 | #define glDeleteSync _glptr_glDeleteSync 1517 | 1518 | typedef void (GL_APIENTRY *PFN_glGetCompressedTexImage)(GLenum target, GLint level, void * img); 1519 | extern PFN_glGetCompressedTexImage _glptr_glGetCompressedTexImage; 1520 | #define glGetCompressedTexImage _glptr_glGetCompressedTexImage 1521 | 1522 | typedef void (GL_APIENTRY *PFN_glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); 1523 | extern PFN_glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D; 1524 | #define glCompressedTexSubImage2D _glptr_glCompressedTexSubImage2D 1525 | 1526 | typedef void (GL_APIENTRY *PFN_glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); 1527 | extern PFN_glUniform4ui _glptr_glUniform4ui; 1528 | #define glUniform4ui _glptr_glUniform4ui 1529 | 1530 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4usv)(GLuint index, const GLushort * v); 1531 | extern PFN_glVertexAttribI4usv _glptr_glVertexAttribI4usv; 1532 | #define glVertexAttribI4usv _glptr_glVertexAttribI4usv 1533 | 1534 | typedef void (GL_APIENTRY *PFN_glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); 1535 | extern PFN_glCompressedTexImage2D _glptr_glCompressedTexImage2D; 1536 | #define glCompressedTexImage2D _glptr_glCompressedTexImage2D 1537 | 1538 | typedef void (GL_APIENTRY *PFN_glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); 1539 | extern PFN_glCompressedTexImage3D _glptr_glCompressedTexImage3D; 1540 | #define glCompressedTexImage3D _glptr_glCompressedTexImage3D 1541 | 1542 | typedef void (GL_APIENTRY *PFN_glSampleCoverage)(GLfloat value, GLboolean invert); 1543 | extern PFN_glSampleCoverage _glptr_glSampleCoverage; 1544 | #define glSampleCoverage _glptr_glSampleCoverage 1545 | 1546 | typedef void (GL_APIENTRY *PFN_glActiveTexture)(GLenum texture); 1547 | extern PFN_glActiveTexture _glptr_glActiveTexture; 1548 | #define glActiveTexture _glptr_glActiveTexture 1549 | 1550 | typedef void (GL_APIENTRY *PFN_glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); 1551 | extern PFN_glCopyTexSubImage3D _glptr_glCopyTexSubImage3D; 1552 | #define glCopyTexSubImage3D _glptr_glCopyTexSubImage3D 1553 | 1554 | typedef void (GL_APIENTRY *PFN_glCompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); 1555 | extern PFN_glCompressedTexImage1D _glptr_glCompressedTexImage1D; 1556 | #define glCompressedTexImage1D _glptr_glCompressedTexImage1D 1557 | 1558 | typedef void (GL_APIENTRY *PFN_glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); 1559 | extern PFN_glTexSubImage3D _glptr_glTexSubImage3D; 1560 | #define glTexSubImage3D _glptr_glTexSubImage3D 1561 | 1562 | typedef void (GL_APIENTRY *PFN_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1563 | extern PFN_glUniformMatrix4fv _glptr_glUniformMatrix4fv; 1564 | #define glUniformMatrix4fv _glptr_glUniformMatrix4fv 1565 | 1566 | typedef const GLubyte * (GL_APIENTRY *PFN_glGetString)(GLenum name); 1567 | extern PFN_glGetString _glptr_glGetString; 1568 | #define glGetString _glptr_glGetString 1569 | 1570 | typedef void (GL_APIENTRY *PFN_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); 1571 | extern PFN_glRenderbufferStorage _glptr_glRenderbufferStorage; 1572 | #define glRenderbufferStorage _glptr_glRenderbufferStorage 1573 | 1574 | typedef GLboolean (GL_APIENTRY *PFN_glIsTexture)(GLuint texture); 1575 | extern PFN_glIsTexture _glptr_glIsTexture; 1576 | #define glIsTexture _glptr_glIsTexture 1577 | 1578 | typedef void (GL_APIENTRY *PFN_glGenTextures)(GLsizei n, GLuint * textures); 1579 | extern PFN_glGenTextures _glptr_glGenTextures; 1580 | #define glGenTextures _glptr_glGenTextures 1581 | 1582 | typedef void (GL_APIENTRY *PFN_glTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); 1583 | extern PFN_glTexSubImage1D _glptr_glTexSubImage1D; 1584 | #define glTexSubImage1D _glptr_glTexSubImage1D 1585 | 1586 | typedef GLenum (GL_APIENTRY *PFN_glClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout); 1587 | extern PFN_glClientWaitSync _glptr_glClientWaitSync; 1588 | #define glClientWaitSync _glptr_glClientWaitSync 1589 | 1590 | typedef void (GL_APIENTRY *PFN_glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); 1591 | extern PFN_glCopyTexSubImage2D _glptr_glCopyTexSubImage2D; 1592 | #define glCopyTexSubImage2D _glptr_glCopyTexSubImage2D 1593 | 1594 | typedef void (GL_APIENTRY *PFN_glCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); 1595 | extern PFN_glCopyTexSubImage1D _glptr_glCopyTexSubImage1D; 1596 | #define glCopyTexSubImage1D _glptr_glCopyTexSubImage1D 1597 | 1598 | typedef void (GL_APIENTRY *PFN_glCopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); 1599 | extern PFN_glCopyTexImage1D _glptr_glCopyTexImage1D; 1600 | #define glCopyTexImage1D _glptr_glCopyTexImage1D 1601 | 1602 | typedef void (GL_APIENTRY *PFN_glPolygonOffset)(GLfloat factor, GLfloat units); 1603 | extern PFN_glPolygonOffset _glptr_glPolygonOffset; 1604 | #define glPolygonOffset _glptr_glPolygonOffset 1605 | 1606 | typedef void (GL_APIENTRY *PFN_glTexImage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); 1607 | extern PFN_glTexImage2DMultisample _glptr_glTexImage2DMultisample; 1608 | #define glTexImage2DMultisample _glptr_glTexImage2DMultisample 1609 | 1610 | typedef void (GL_APIENTRY *PFN_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void * indices); 1611 | extern PFN_glDrawElements _glptr_glDrawElements; 1612 | #define glDrawElements _glptr_glDrawElements 1613 | 1614 | typedef void (GL_APIENTRY *PFN_glEndConditionalRender)(); 1615 | extern PFN_glEndConditionalRender _glptr_glEndConditionalRender; 1616 | #define glEndConditionalRender _glptr_glEndConditionalRender 1617 | 1618 | typedef void (GL_APIENTRY *PFN_glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); 1619 | extern PFN_glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying; 1620 | #define glGetTransformFeedbackVarying _glptr_glGetTransformFeedbackVarying 1621 | 1622 | typedef void (GL_APIENTRY *PFN_glTexParameteriv)(GLenum target, GLenum pname, const GLint * params); 1623 | extern PFN_glTexParameteriv _glptr_glTexParameteriv; 1624 | #define glTexParameteriv _glptr_glTexParameteriv 1625 | 1626 | typedef void (GL_APIENTRY *PFN_glDeleteFramebuffers)(GLsizei n, const GLuint * framebuffers); 1627 | extern PFN_glDeleteFramebuffers _glptr_glDeleteFramebuffers; 1628 | #define glDeleteFramebuffers _glptr_glDeleteFramebuffers 1629 | 1630 | typedef void (GL_APIENTRY *PFN_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha); 1631 | extern PFN_glBlendEquationSeparate _glptr_glBlendEquationSeparate; 1632 | #define glBlendEquationSeparate _glptr_glBlendEquationSeparate 1633 | 1634 | typedef void (GL_APIENTRY *PFN_glDeleteTextures)(GLsizei n, const GLuint * textures); 1635 | extern PFN_glDeleteTextures _glptr_glDeleteTextures; 1636 | #define glDeleteTextures _glptr_glDeleteTextures 1637 | 1638 | typedef void (GL_APIENTRY *PFN_glGetProgramiv)(GLuint program, GLenum pname, GLint * params); 1639 | extern PFN_glGetProgramiv _glptr_glGetProgramiv; 1640 | #define glGetProgramiv _glptr_glGetProgramiv 1641 | 1642 | typedef void (GL_APIENTRY *PFN_glUniform1uiv)(GLint location, GLsizei count, const GLuint * value); 1643 | extern PFN_glUniform1uiv _glptr_glUniform1uiv; 1644 | #define glUniform1uiv _glptr_glUniform1uiv 1645 | 1646 | typedef void (GL_APIENTRY *PFN_glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); 1647 | extern PFN_glCopyTexImage2D _glptr_glCopyTexImage2D; 1648 | #define glCopyTexImage2D _glptr_glCopyTexImage2D 1649 | 1650 | typedef void (GL_APIENTRY *PFN_glGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params); 1651 | extern PFN_glGetTexLevelParameterfv _glptr_glGetTexLevelParameterfv; 1652 | #define glGetTexLevelParameterfv _glptr_glGetTexLevelParameterfv 1653 | 1654 | typedef void (GL_APIENTRY *PFN_glSampleMaski)(GLuint maskNumber, GLbitfield mask); 1655 | extern PFN_glSampleMaski _glptr_glSampleMaski; 1656 | #define glSampleMaski _glptr_glSampleMaski 1657 | 1658 | typedef void (GL_APIENTRY *PFN_glBindTexture)(GLenum target, GLuint texture); 1659 | extern PFN_glBindTexture _glptr_glBindTexture; 1660 | #define glBindTexture _glptr_glBindTexture 1661 | 1662 | typedef void (GL_APIENTRY *PFN_glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params); 1663 | extern PFN_glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv; 1664 | #define glGetActiveUniformBlockiv _glptr_glGetActiveUniformBlockiv 1665 | 1666 | typedef void (GL_APIENTRY *PFN_glGetUniformuiv)(GLuint program, GLint location, GLuint * params); 1667 | extern PFN_glGetUniformuiv _glptr_glGetUniformuiv; 1668 | #define glGetUniformuiv _glptr_glGetUniformuiv 1669 | 1670 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Nbv)(GLuint index, const GLbyte * v); 1671 | extern PFN_glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv; 1672 | #define glVertexAttrib4Nbv _glptr_glVertexAttrib4Nbv 1673 | 1674 | typedef void (GL_APIENTRY *PFN_glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); 1675 | extern PFN_glTexImage3D _glptr_glTexImage3D; 1676 | #define glTexImage3D _glptr_glTexImage3D 1677 | 1678 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); 1679 | extern PFN_glVertexAttrib4f _glptr_glVertexAttrib4f; 1680 | #define glVertexAttrib4f _glptr_glVertexAttrib4f 1681 | 1682 | typedef void (GL_APIENTRY *PFN_glUniform2ui)(GLint location, GLuint v0, GLuint v1); 1683 | extern PFN_glUniform2ui _glptr_glUniform2ui; 1684 | #define glUniform2ui _glptr_glUniform2ui 1685 | 1686 | typedef void (GL_APIENTRY *PFN_glGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels); 1687 | extern PFN_glGetTexImage _glptr_glGetTexImage; 1688 | #define glGetTexImage _glptr_glGetTexImage 1689 | 1690 | typedef void (GL_APIENTRY *PFN_glGetTexParameterIuiv)(GLenum target, GLenum pname, GLuint * params); 1691 | extern PFN_glGetTexParameterIuiv _glptr_glGetTexParameterIuiv; 1692 | #define glGetTexParameterIuiv _glptr_glGetTexParameterIuiv 1693 | 1694 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4bv)(GLuint index, const GLbyte * v); 1695 | extern PFN_glVertexAttrib4bv _glptr_glVertexAttrib4bv; 1696 | #define glVertexAttrib4bv _glptr_glVertexAttrib4bv 1697 | 1698 | typedef void (GL_APIENTRY *PFN_glUniform2uiv)(GLint location, GLsizei count, const GLuint * value); 1699 | extern PFN_glUniform2uiv _glptr_glUniform2uiv; 1700 | #define glUniform2uiv _glptr_glUniform2uiv 1701 | 1702 | typedef void (GL_APIENTRY *PFN_glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); 1703 | extern PFN_glGetShaderSource _glptr_glGetShaderSource; 1704 | #define glGetShaderSource _glptr_glGetShaderSource 1705 | 1706 | typedef GLboolean (GL_APIENTRY *PFN_glIsBuffer)(GLuint buffer); 1707 | extern PFN_glIsBuffer _glptr_glIsBuffer; 1708 | #define glIsBuffer _glptr_glIsBuffer 1709 | 1710 | typedef void (GL_APIENTRY *PFN_glGetBufferPointerv)(GLenum target, GLenum pname, void ** params); 1711 | extern PFN_glGetBufferPointerv _glptr_glGetBufferPointerv; 1712 | #define glGetBufferPointerv _glptr_glGetBufferPointerv 1713 | 1714 | typedef void (GL_APIENTRY *PFN_glPolygonMode)(GLenum face, GLenum mode); 1715 | extern PFN_glPolygonMode _glptr_glPolygonMode; 1716 | #define glPolygonMode _glptr_glPolygonMode 1717 | 1718 | typedef void (GL_APIENTRY *PFN_glBindAttribLocation)(GLuint program, GLuint index, const GLchar * name); 1719 | extern PFN_glBindAttribLocation _glptr_glBindAttribLocation; 1720 | #define glBindAttribLocation _glptr_glBindAttribLocation 1721 | 1722 | typedef void (GL_APIENTRY *PFN_glUniform2f)(GLint location, GLfloat v0, GLfloat v1); 1723 | extern PFN_glUniform2f _glptr_glUniform2f; 1724 | #define glUniform2f _glptr_glUniform2f 1725 | 1726 | typedef void (GL_APIENTRY *PFN_glPixelStoref)(GLenum pname, GLfloat param); 1727 | extern PFN_glPixelStoref _glptr_glPixelStoref; 1728 | #define glPixelStoref _glptr_glPixelStoref 1729 | 1730 | typedef void (GL_APIENTRY *PFN_glLogicOp)(GLenum opcode); 1731 | extern PFN_glLogicOp _glptr_glLogicOp; 1732 | #define glLogicOp _glptr_glLogicOp 1733 | 1734 | typedef GLuint (GL_APIENTRY *PFN_glCreateShader)(GLenum type); 1735 | extern PFN_glCreateShader _glptr_glCreateShader; 1736 | #define glCreateShader _glptr_glCreateShader 1737 | 1738 | typedef void (GL_APIENTRY *PFN_glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); 1739 | extern PFN_glTexSubImage2D _glptr_glTexSubImage2D; 1740 | #define glTexSubImage2D _glptr_glTexSubImage2D 1741 | 1742 | typedef void (GL_APIENTRY *PFN_glClearDepth)(GLdouble depth); 1743 | extern PFN_glClearDepth _glptr_glClearDepth; 1744 | #define glClearDepth _glptr_glClearDepth 1745 | 1746 | typedef void (GL_APIENTRY *PFN_glGetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, void * data); 1747 | extern PFN_glGetBufferSubData _glptr_glGetBufferSubData; 1748 | #define glGetBufferSubData _glptr_glGetBufferSubData 1749 | 1750 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4uiv)(GLuint index, const GLuint * v); 1751 | extern PFN_glVertexAttrib4uiv _glptr_glVertexAttrib4uiv; 1752 | #define glVertexAttrib4uiv _glptr_glVertexAttrib4uiv 1753 | 1754 | typedef void (GL_APIENTRY *PFN_glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); 1755 | extern PFN_glCopyBufferSubData _glptr_glCopyBufferSubData; 1756 | #define glCopyBufferSubData _glptr_glCopyBufferSubData 1757 | 1758 | typedef void (GL_APIENTRY *PFN_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); 1759 | extern PFN_glFramebufferTexture2D _glptr_glFramebufferTexture2D; 1760 | #define glFramebufferTexture2D _glptr_glFramebufferTexture2D 1761 | 1762 | typedef void (GL_APIENTRY *PFN_glPointParameterf)(GLenum pname, GLfloat param); 1763 | extern PFN_glPointParameterf _glptr_glPointParameterf; 1764 | #define glPointParameterf _glptr_glPointParameterf 1765 | 1766 | typedef void (GL_APIENTRY *PFN_glDisablei)(GLenum target, GLuint index); 1767 | extern PFN_glDisablei _glptr_glDisablei; 1768 | #define glDisablei _glptr_glDisablei 1769 | 1770 | typedef void (GL_APIENTRY *PFN_glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); 1771 | extern PFN_glUniformMatrix4x2fv _glptr_glUniformMatrix4x2fv; 1772 | #define glUniformMatrix4x2fv _glptr_glUniformMatrix4x2fv 1773 | 1774 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); 1775 | extern PFN_glVertexAttrib4d _glptr_glVertexAttrib4d; 1776 | #define glVertexAttrib4d _glptr_glVertexAttrib4d 1777 | 1778 | typedef void (GL_APIENTRY *PFN_glTexParameterIuiv)(GLenum target, GLenum pname, const GLuint * params); 1779 | extern PFN_glTexParameterIuiv _glptr_glTexParameterIuiv; 1780 | #define glTexParameterIuiv _glptr_glTexParameterIuiv 1781 | 1782 | typedef void (GL_APIENTRY *PFN_glGetFloatv)(GLenum pname, GLfloat * data); 1783 | extern PFN_glGetFloatv _glptr_glGetFloatv; 1784 | #define glGetFloatv _glptr_glGetFloatv 1785 | 1786 | typedef GLuint (GL_APIENTRY *PFN_glCreateProgram)(); 1787 | extern PFN_glCreateProgram _glptr_glCreateProgram; 1788 | #define glCreateProgram _glptr_glCreateProgram 1789 | 1790 | typedef void (GL_APIENTRY *PFN_glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode); 1791 | extern PFN_glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings; 1792 | #define glTransformFeedbackVaryings _glptr_glTransformFeedbackVaryings 1793 | 1794 | typedef void (GL_APIENTRY *PFN_glVertexAttrib1d)(GLuint index, GLdouble x); 1795 | extern PFN_glVertexAttrib1d _glptr_glVertexAttrib1d; 1796 | #define glVertexAttrib1d _glptr_glVertexAttrib1d 1797 | 1798 | typedef void (GL_APIENTRY *PFN_glViewport)(GLint x, GLint y, GLsizei width, GLsizei height); 1799 | extern PFN_glViewport _glptr_glViewport; 1800 | #define glViewport _glptr_glViewport 1801 | 1802 | typedef void (GL_APIENTRY *PFN_glDeleteBuffers)(GLsizei n, const GLuint * buffers); 1803 | extern PFN_glDeleteBuffers _glptr_glDeleteBuffers; 1804 | #define glDeleteBuffers _glptr_glDeleteBuffers 1805 | 1806 | typedef void (GL_APIENTRY *PFN_glFlush)(); 1807 | extern PFN_glFlush _glptr_glFlush; 1808 | #define glFlush _glptr_glFlush 1809 | 1810 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4sv)(GLuint index, const GLshort * v); 1811 | extern PFN_glVertexAttribI4sv _glptr_glVertexAttribI4sv; 1812 | #define glVertexAttribI4sv _glptr_glVertexAttribI4sv 1813 | 1814 | typedef void (GL_APIENTRY *PFN_glDrawArrays)(GLenum mode, GLint first, GLsizei count); 1815 | extern PFN_glDrawArrays _glptr_glDrawArrays; 1816 | #define glDrawArrays _glptr_glDrawArrays 1817 | 1818 | typedef void (GL_APIENTRY *PFN_glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount); 1819 | extern PFN_glDrawElementsInstanced _glptr_glDrawElementsInstanced; 1820 | #define glDrawElementsInstanced _glptr_glDrawElementsInstanced 1821 | 1822 | typedef void (GL_APIENTRY *PFN_glUniform3iv)(GLint location, GLsizei count, const GLint * value); 1823 | extern PFN_glUniform3iv _glptr_glUniform3iv; 1824 | #define glUniform3iv _glptr_glUniform3iv 1825 | 1826 | typedef void (GL_APIENTRY *PFN_glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); 1827 | extern PFN_glVertexAttribPointer _glptr_glVertexAttribPointer; 1828 | #define glVertexAttribPointer _glptr_glVertexAttribPointer 1829 | 1830 | typedef void (GL_APIENTRY *PFN_glGetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values); 1831 | extern PFN_glGetSynciv _glptr_glGetSynciv; 1832 | #define glGetSynciv _glptr_glGetSynciv 1833 | 1834 | typedef void (GL_APIENTRY *PFN_glPrimitiveRestartIndex)(GLuint index); 1835 | extern PFN_glPrimitiveRestartIndex _glptr_glPrimitiveRestartIndex; 1836 | #define glPrimitiveRestartIndex _glptr_glPrimitiveRestartIndex 1837 | 1838 | typedef void (GL_APIENTRY *PFN_glUniform1i)(GLint location, GLint v0); 1839 | extern PFN_glUniform1i _glptr_glUniform1i; 1840 | #define glUniform1i _glptr_glUniform1i 1841 | 1842 | typedef void (GL_APIENTRY *PFN_glVertexAttrib1sv)(GLuint index, const GLshort * v); 1843 | extern PFN_glVertexAttrib1sv _glptr_glVertexAttrib1sv; 1844 | #define glVertexAttrib1sv _glptr_glVertexAttrib1sv 1845 | 1846 | typedef void (GL_APIENTRY *PFN_glDisable)(GLenum cap); 1847 | extern PFN_glDisable _glptr_glDisable; 1848 | #define glDisable _glptr_glDisable 1849 | 1850 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4uiv)(GLuint index, const GLuint * v); 1851 | extern PFN_glVertexAttribI4uiv _glptr_glVertexAttribI4uiv; 1852 | #define glVertexAttribI4uiv _glptr_glVertexAttribI4uiv 1853 | 1854 | typedef void (GL_APIENTRY *PFN_glEndQuery)(GLenum target); 1855 | extern PFN_glEndQuery _glptr_glEndQuery; 1856 | #define glEndQuery _glptr_glEndQuery 1857 | 1858 | typedef void (GL_APIENTRY *PFN_glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); 1859 | extern PFN_glColorMask _glptr_glColorMask; 1860 | #define glColorMask _glptr_glColorMask 1861 | 1862 | typedef void (GL_APIENTRY *PFN_glEnablei)(GLenum target, GLuint index); 1863 | extern PFN_glEnablei _glptr_glEnablei; 1864 | #define glEnablei _glptr_glEnablei 1865 | 1866 | typedef void (GL_APIENTRY *PFN_glBindBuffer)(GLenum target, GLuint buffer); 1867 | extern PFN_glBindBuffer _glptr_glBindBuffer; 1868 | #define glBindBuffer _glptr_glBindBuffer 1869 | 1870 | typedef void (GL_APIENTRY *PFN_glGetDoublev)(GLenum pname, GLdouble * data); 1871 | extern PFN_glGetDoublev _glptr_glGetDoublev; 1872 | #define glGetDoublev _glptr_glGetDoublev 1873 | 1874 | typedef void (GL_APIENTRY *PFN_glGetTexParameteriv)(GLenum target, GLenum pname, GLint * params); 1875 | extern PFN_glGetTexParameteriv _glptr_glGetTexParameteriv; 1876 | #define glGetTexParameteriv _glptr_glGetTexParameteriv 1877 | 1878 | typedef void (GL_APIENTRY *PFN_glDeleteVertexArrays)(GLsizei n, const GLuint * arrays); 1879 | extern PFN_glDeleteVertexArrays _glptr_glDeleteVertexArrays; 1880 | #define glDeleteVertexArrays _glptr_glDeleteVertexArrays 1881 | 1882 | typedef void (GL_APIENTRY *PFN_glVertexAttribI2uiv)(GLuint index, const GLuint * v); 1883 | extern PFN_glVertexAttribI2uiv _glptr_glVertexAttribI2uiv; 1884 | #define glVertexAttribI2uiv _glptr_glVertexAttribI2uiv 1885 | 1886 | typedef void (GL_APIENTRY *PFN_glDepthMask)(GLboolean flag); 1887 | extern PFN_glDepthMask _glptr_glDepthMask; 1888 | #define glDepthMask _glptr_glDepthMask 1889 | 1890 | typedef void (GL_APIENTRY *PFN_glGetVertexAttribdv)(GLuint index, GLenum pname, GLdouble * params); 1891 | extern PFN_glGetVertexAttribdv _glptr_glGetVertexAttribdv; 1892 | #define glGetVertexAttribdv _glptr_glGetVertexAttribdv 1893 | 1894 | typedef void (GL_APIENTRY *PFN_glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); 1895 | extern PFN_glDrawRangeElements _glptr_glDrawRangeElements; 1896 | #define glDrawRangeElements _glptr_glDrawRangeElements 1897 | 1898 | typedef void (GL_APIENTRY *PFN_glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); 1899 | extern PFN_glDrawArraysInstanced _glptr_glDrawArraysInstanced; 1900 | #define glDrawArraysInstanced _glptr_glDrawArraysInstanced 1901 | 1902 | typedef void (GL_APIENTRY *PFN_glClearStencil)(GLint s); 1903 | extern PFN_glClearStencil _glptr_glClearStencil; 1904 | #define glClearStencil _glptr_glClearStencil 1905 | 1906 | typedef void (GL_APIENTRY *PFN_glVertexAttribI3iv)(GLuint index, const GLint * v); 1907 | extern PFN_glVertexAttribI3iv _glptr_glVertexAttribI3iv; 1908 | #define glVertexAttribI3iv _glptr_glVertexAttribI3iv 1909 | 1910 | typedef void (GL_APIENTRY *PFN_glDrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex); 1911 | extern PFN_glDrawRangeElementsBaseVertex _glptr_glDrawRangeElementsBaseVertex; 1912 | #define glDrawRangeElementsBaseVertex _glptr_glDrawRangeElementsBaseVertex 1913 | 1914 | typedef void (GL_APIENTRY *PFN_glScissor)(GLint x, GLint y, GLsizei width, GLsizei height); 1915 | extern PFN_glScissor _glptr_glScissor; 1916 | #define glScissor _glptr_glScissor 1917 | 1918 | typedef void (GL_APIENTRY *PFN_glGenerateMipmap)(GLenum target); 1919 | extern PFN_glGenerateMipmap _glptr_glGenerateMipmap; 1920 | #define glGenerateMipmap _glptr_glGenerateMipmap 1921 | 1922 | typedef void (GL_APIENTRY *PFN_glUniform3fv)(GLint location, GLsizei count, const GLfloat * value); 1923 | extern PFN_glUniform3fv _glptr_glUniform3fv; 1924 | #define glUniform3fv _glptr_glUniform3fv 1925 | 1926 | typedef void (GL_APIENTRY *PFN_glUniform3uiv)(GLint location, GLsizei count, const GLuint * value); 1927 | extern PFN_glUniform3uiv _glptr_glUniform3uiv; 1928 | #define glUniform3uiv _glptr_glUniform3uiv 1929 | 1930 | typedef void (GL_APIENTRY *PFN_glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint * value); 1931 | extern PFN_glClearBufferiv _glptr_glClearBufferiv; 1932 | #define glClearBufferiv _glptr_glClearBufferiv 1933 | 1934 | typedef void (GL_APIENTRY *PFN_glVertexAttribI4ubv)(GLuint index, const GLubyte * v); 1935 | extern PFN_glVertexAttribI4ubv _glptr_glVertexAttribI4ubv; 1936 | #define glVertexAttribI4ubv _glptr_glVertexAttribI4ubv 1937 | 1938 | typedef void (GL_APIENTRY *PFN_glGetBooleanv)(GLenum pname, GLboolean * data); 1939 | extern PFN_glGetBooleanv _glptr_glGetBooleanv; 1940 | #define glGetBooleanv _glptr_glGetBooleanv 1941 | 1942 | typedef void (GL_APIENTRY *PFN_glValidateProgram)(GLuint program); 1943 | extern PFN_glValidateProgram _glptr_glValidateProgram; 1944 | #define glValidateProgram _glptr_glValidateProgram 1945 | 1946 | typedef void (GL_APIENTRY *PFN_glGenRenderbuffers)(GLsizei n, GLuint * renderbuffers); 1947 | extern PFN_glGenRenderbuffers _glptr_glGenRenderbuffers; 1948 | #define glGenRenderbuffers _glptr_glGenRenderbuffers 1949 | 1950 | typedef void (GL_APIENTRY *PFN_glUniform2iv)(GLint location, GLsizei count, const GLint * value); 1951 | extern PFN_glUniform2iv _glptr_glUniform2iv; 1952 | #define glUniform2iv _glptr_glUniform2iv 1953 | 1954 | typedef void (GL_APIENTRY *PFN_glBufferData)(GLenum target, GLsizeiptr size, const void * data, GLenum usage); 1955 | extern PFN_glBufferData _glptr_glBufferData; 1956 | #define glBufferData _glptr_glBufferData 1957 | 1958 | typedef void (GL_APIENTRY *PFN_glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); 1959 | extern PFN_glBlendFuncSeparate _glptr_glBlendFuncSeparate; 1960 | #define glBlendFuncSeparate _glptr_glBlendFuncSeparate 1961 | 1962 | typedef void (GL_APIENTRY *PFN_glTexParameteri)(GLenum target, GLenum pname, GLint param); 1963 | extern PFN_glTexParameteri _glptr_glTexParameteri; 1964 | #define glTexParameteri _glptr_glTexParameteri 1965 | 1966 | typedef void (GL_APIENTRY *PFN_glHint)(GLenum target, GLenum mode); 1967 | extern PFN_glHint _glptr_glHint; 1968 | #define glHint _glptr_glHint 1969 | 1970 | typedef void (GL_APIENTRY *PFN_glVertexAttrib3fv)(GLuint index, const GLfloat * v); 1971 | extern PFN_glVertexAttrib3fv _glptr_glVertexAttrib3fv; 1972 | #define glVertexAttrib3fv _glptr_glVertexAttrib3fv 1973 | 1974 | typedef void (GL_APIENTRY *PFN_glDrawBuffer)(GLenum buf); 1975 | extern PFN_glDrawBuffer _glptr_glDrawBuffer; 1976 | #define glDrawBuffer _glptr_glDrawBuffer 1977 | 1978 | typedef GLboolean (GL_APIENTRY *PFN_glIsProgram)(GLuint program); 1979 | extern PFN_glIsProgram _glptr_glIsProgram; 1980 | #define glIsProgram _glptr_glIsProgram 1981 | 1982 | typedef void (GL_APIENTRY *PFN_glGetIntegerv)(GLenum pname, GLint * data); 1983 | extern PFN_glGetIntegerv _glptr_glGetIntegerv; 1984 | #define glGetIntegerv _glptr_glGetIntegerv 1985 | 1986 | typedef void (GL_APIENTRY *PFN_glDrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex); 1987 | extern PFN_glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex; 1988 | #define glDrawElementsBaseVertex _glptr_glDrawElementsBaseVertex 1989 | 1990 | typedef void (GL_APIENTRY *PFN_glEnable)(GLenum cap); 1991 | extern PFN_glEnable _glptr_glEnable; 1992 | #define glEnable _glptr_glEnable 1993 | 1994 | typedef void (GL_APIENTRY *PFN_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); 1995 | extern PFN_glBlitFramebuffer _glptr_glBlitFramebuffer; 1996 | #define glBlitFramebuffer _glptr_glBlitFramebuffer 1997 | 1998 | typedef void (GL_APIENTRY *PFN_glBeginQuery)(GLenum target, GLuint id); 1999 | extern PFN_glBeginQuery _glptr_glBeginQuery; 2000 | #define glBeginQuery _glptr_glBeginQuery 2001 | 2002 | typedef void (GL_APIENTRY *PFN_glStencilMask)(GLuint mask); 2003 | extern PFN_glStencilMask _glptr_glStencilMask; 2004 | #define glStencilMask _glptr_glStencilMask 2005 | 2006 | typedef void (GL_APIENTRY *PFN_glAttachShader)(GLuint program, GLuint shader); 2007 | extern PFN_glAttachShader _glptr_glAttachShader; 2008 | #define glAttachShader _glptr_glAttachShader 2009 | 2010 | typedef void (GL_APIENTRY *PFN_glPointSize)(GLfloat size); 2011 | extern PFN_glPointSize _glptr_glPointSize; 2012 | #define glPointSize _glptr_glPointSize 2013 | 2014 | typedef void (GL_APIENTRY *PFN_glMultiDrawElements)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount); 2015 | extern PFN_glMultiDrawElements _glptr_glMultiDrawElements; 2016 | #define glMultiDrawElements _glptr_glMultiDrawElements 2017 | 2018 | typedef void (GL_APIENTRY *PFN_glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params); 2019 | extern PFN_glGetTexParameterfv _glptr_glGetTexParameterfv; 2020 | #define glGetTexParameterfv _glptr_glGetTexParameterfv 2021 | 2022 | typedef GLboolean (GL_APIENTRY *PFN_glIsEnabled)(GLenum cap); 2023 | extern PFN_glIsEnabled _glptr_glIsEnabled; 2024 | #define glIsEnabled _glptr_glIsEnabled 2025 | 2026 | typedef void (GL_APIENTRY *PFN_glGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params); 2027 | extern PFN_glGetTexLevelParameteriv _glptr_glGetTexLevelParameteriv; 2028 | #define glGetTexLevelParameteriv _glptr_glGetTexLevelParameteriv 2029 | 2030 | typedef GLenum (GL_APIENTRY *PFN_glGetError)(); 2031 | extern PFN_glGetError _glptr_glGetError; 2032 | #define glGetError _glptr_glGetError 2033 | 2034 | typedef void (GL_APIENTRY *PFN_glEndTransformFeedback)(); 2035 | extern PFN_glEndTransformFeedback _glptr_glEndTransformFeedback; 2036 | #define glEndTransformFeedback _glptr_glEndTransformFeedback 2037 | 2038 | typedef void (GL_APIENTRY *PFN_glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); 2039 | extern PFN_glClearColor _glptr_glClearColor; 2040 | #define glClearColor _glptr_glClearColor 2041 | 2042 | typedef void (GL_APIENTRY *PFN_glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); 2043 | extern PFN_glBlendColor _glptr_glBlendColor; 2044 | #define glBlendColor _glptr_glBlendColor 2045 | 2046 | typedef void (GL_APIENTRY *PFN_glVertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z); 2047 | extern PFN_glVertexAttribI3i _glptr_glVertexAttribI3i; 2048 | #define glVertexAttribI3i _glptr_glVertexAttribI3i 2049 | 2050 | typedef void (GL_APIENTRY *PFN_glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); 2051 | extern PFN_glCompressedTexSubImage3D _glptr_glCompressedTexSubImage3D; 2052 | #define glCompressedTexSubImage3D _glptr_glCompressedTexSubImage3D 2053 | 2054 | typedef void (GL_APIENTRY *PFN_glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels); 2055 | extern PFN_glReadPixels _glptr_glReadPixels; 2056 | #define glReadPixels _glptr_glReadPixels 2057 | 2058 | typedef void (GL_APIENTRY *PFN_glTexParameterf)(GLenum target, GLenum pname, GLfloat param); 2059 | extern PFN_glTexParameterf _glptr_glTexParameterf; 2060 | #define glTexParameterf _glptr_glTexParameterf 2061 | 2062 | typedef void (GL_APIENTRY *PFN_glPointParameterfv)(GLenum pname, const GLfloat * params); 2063 | extern PFN_glPointParameterfv _glptr_glPointParameterfv; 2064 | #define glPointParameterfv _glptr_glPointParameterfv 2065 | 2066 | typedef void (GL_APIENTRY *PFN_glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); 2067 | extern PFN_glGetShaderInfoLog _glptr_glGetShaderInfoLog; 2068 | #define glGetShaderInfoLog _glptr_glGetShaderInfoLog 2069 | 2070 | typedef void (GL_APIENTRY *PFN_glDepthFunc)(GLenum func); 2071 | extern PFN_glDepthFunc _glptr_glDepthFunc; 2072 | #define glDepthFunc _glptr_glDepthFunc 2073 | 2074 | typedef void (GL_APIENTRY *PFN_glVertexAttribI3uiv)(GLuint index, const GLuint * v); 2075 | extern PFN_glVertexAttribI3uiv _glptr_glVertexAttribI3uiv; 2076 | #define glVertexAttribI3uiv _glptr_glVertexAttribI3uiv 2077 | 2078 | typedef void (GL_APIENTRY *PFN_glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass); 2079 | extern PFN_glStencilOp _glptr_glStencilOp; 2080 | #define glStencilOp _glptr_glStencilOp 2081 | 2082 | typedef void (GL_APIENTRY *PFN_glStencilFunc)(GLenum func, GLint ref, GLuint mask); 2083 | extern PFN_glStencilFunc _glptr_glStencilFunc; 2084 | #define glStencilFunc _glptr_glStencilFunc 2085 | 2086 | typedef void (GL_APIENTRY *PFN_glEnableVertexAttribArray)(GLuint index); 2087 | extern PFN_glEnableVertexAttribArray _glptr_glEnableVertexAttribArray; 2088 | #define glEnableVertexAttribArray _glptr_glEnableVertexAttribArray 2089 | 2090 | typedef void (GL_APIENTRY *PFN_glBlendFunc)(GLenum sfactor, GLenum dfactor); 2091 | extern PFN_glBlendFunc _glptr_glBlendFunc; 2092 | #define glBlendFunc _glptr_glBlendFunc 2093 | 2094 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); 2095 | extern PFN_glVertexAttrib4Nub _glptr_glVertexAttrib4Nub; 2096 | #define glVertexAttrib4Nub _glptr_glVertexAttrib4Nub 2097 | 2098 | typedef void (GL_APIENTRY *PFN_glUniform1fv)(GLint location, GLsizei count, const GLfloat * value); 2099 | extern PFN_glUniform1fv _glptr_glUniform1fv; 2100 | #define glUniform1fv _glptr_glUniform1fv 2101 | 2102 | typedef void (GL_APIENTRY *PFN_glPixelStorei)(GLenum pname, GLint param); 2103 | extern PFN_glPixelStorei _glptr_glPixelStorei; 2104 | #define glPixelStorei _glptr_glPixelStorei 2105 | 2106 | typedef void (GL_APIENTRY *PFN_glLineWidth)(GLfloat width); 2107 | extern PFN_glLineWidth _glptr_glLineWidth; 2108 | #define glLineWidth _glptr_glLineWidth 2109 | 2110 | typedef void (GL_APIENTRY *PFN_glGetUniformiv)(GLuint program, GLint location, GLint * params); 2111 | extern PFN_glGetUniformiv _glptr_glGetUniformiv; 2112 | #define glGetUniformiv _glptr_glGetUniformiv 2113 | 2114 | typedef void (GL_APIENTRY *PFN_glReadBuffer)(GLenum src); 2115 | extern PFN_glReadBuffer _glptr_glReadBuffer; 2116 | #define glReadBuffer _glptr_glReadBuffer 2117 | 2118 | typedef void (GL_APIENTRY *PFN_glTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); 2119 | extern PFN_glTexImage1D _glptr_glTexImage1D; 2120 | #define glTexImage1D _glptr_glTexImage1D 2121 | 2122 | typedef void (GL_APIENTRY *PFN_glTexParameterfv)(GLenum target, GLenum pname, const GLfloat * params); 2123 | extern PFN_glTexParameterfv _glptr_glTexParameterfv; 2124 | #define glTexParameterfv _glptr_glTexParameterfv 2125 | 2126 | typedef void (GL_APIENTRY *PFN_glVertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z); 2127 | extern PFN_glVertexAttrib3s _glptr_glVertexAttrib3s; 2128 | #define glVertexAttrib3s _glptr_glVertexAttrib3s 2129 | 2130 | typedef void (GL_APIENTRY *PFN_glCompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); 2131 | extern PFN_glCompressedTexSubImage1D _glptr_glCompressedTexSubImage1D; 2132 | #define glCompressedTexSubImage1D _glptr_glCompressedTexSubImage1D 2133 | 2134 | typedef void (GL_APIENTRY *PFN_glClear)(GLbitfield mask); 2135 | extern PFN_glClear _glptr_glClear; 2136 | #define glClear _glptr_glClear 2137 | 2138 | typedef void (GL_APIENTRY *PFN_glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); 2139 | extern PFN_glTexImage2D _glptr_glTexImage2D; 2140 | #define glTexImage2D _glptr_glTexImage2D 2141 | 2142 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4Niv)(GLuint index, const GLint * v); 2143 | extern PFN_glVertexAttrib4Niv _glptr_glVertexAttrib4Niv; 2144 | #define glVertexAttrib4Niv _glptr_glVertexAttrib4Niv 2145 | 2146 | typedef void (GL_APIENTRY *PFN_glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint * params); 2147 | extern PFN_glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv; 2148 | #define glGetVertexAttribIuiv _glptr_glGetVertexAttribIuiv 2149 | 2150 | typedef void (GL_APIENTRY *PFN_glStencilMaskSeparate)(GLenum face, GLuint mask); 2151 | extern PFN_glStencilMaskSeparate _glptr_glStencilMaskSeparate; 2152 | #define glStencilMaskSeparate _glptr_glStencilMaskSeparate 2153 | 2154 | typedef void (GL_APIENTRY *PFN_glGenVertexArrays)(GLsizei n, GLuint * arrays); 2155 | extern PFN_glGenVertexArrays _glptr_glGenVertexArrays; 2156 | #define glGenVertexArrays _glptr_glGenVertexArrays 2157 | 2158 | typedef void (GL_APIENTRY *PFN_glFrontFace)(GLenum mode); 2159 | extern PFN_glFrontFace _glptr_glFrontFace; 2160 | #define glFrontFace _glptr_glFrontFace 2161 | 2162 | typedef void (GL_APIENTRY *PFN_glDepthRange)(GLdouble n, GLdouble f); 2163 | extern PFN_glDepthRange _glptr_glDepthRange; 2164 | #define glDepthRange _glptr_glDepthRange 2165 | 2166 | typedef void (GL_APIENTRY *PFN_glVertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); 2167 | extern PFN_glVertexAttrib4s _glptr_glVertexAttrib4s; 2168 | #define glVertexAttrib4s _glptr_glVertexAttrib4s 2169 | 2170 | typedef void (GL_APIENTRY *PFN_glDetachShader)(GLuint program, GLuint shader); 2171 | extern PFN_glDetachShader _glptr_glDetachShader; 2172 | #define glDetachShader _glptr_glDetachShader 2173 | 2174 | typedef void (GL_APIENTRY *PFN_glCullFace)(GLenum mode); 2175 | extern PFN_glCullFace _glptr_glCullFace; 2176 | #define glCullFace _glptr_glCullFace 2177 | #if defined(__cplusplus) 2178 | } 2179 | #endif 2180 | #endif 2181 | -------------------------------------------------------------------------------- /helper.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int 4 | main(int argc, char *argv[]) 5 | { 6 | static void *funcs[] = { dlopen, dlsym, dlclose, dlerror }; 7 | int (*p)(void **, int, char **) = (int (*)())argv[argc]; 8 | return p(funcs, argc, argv); 9 | } 10 | -------------------------------------------------------------------------------- /helper/fbsd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/helper/fbsd -------------------------------------------------------------------------------- /helper/nbsd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/helper/nbsd -------------------------------------------------------------------------------- /helper/obsd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jacereda/cosmogfx/3a2e2be868e914970d8509dde20f4d6c2a499c83/helper/obsd -------------------------------------------------------------------------------- /mk: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | set -e 3 | install -d b 4 | gcc -s -ffunction-sections -fdata-sections -Wl,-gc-sections -fomit-frame-pointer -Os -pie -fPIC helper.c -o helper/linux -ldl 5 | zipobj.com -b0x400000 -o b/helper.linux.zip.o helper/linux 6 | zipobj.com -b0x400000 -o b/helper.obsd.zip.o helper/obsd 7 | zipobj.com -b0x400000 -o b/helper.fbsd.zip.o helper/fbsd 8 | zipobj.com -b0x400000 -o b/helper.nbsd.zip.o helper/nbsd 9 | cosmoc -DDLOPEN=z_dlopen \ 10 | -DDLSYM=z_dlsym \ 11 | -DZ_SMALL \ 12 | -DSTDLIB=1 \ 13 | -DELFCLASS=ELFCLASS64 \ 14 | -DCV_NO_MAIN \ 15 | -DCV_DYN \ 16 | -include cosmopolitan.h \ 17 | -I. \ 18 | -Imicroui/demo \ 19 | -Imicroui/src \ 20 | -Ifake \ 21 | -Iglcv/src \ 22 | -fno-stack-protector \ 23 | -ffunction-sections \ 24 | -fdata-sections \ 25 | -Wl,-gc-sections \ 26 | cosmogfx.c \ 27 | dtrampoline.c \ 28 | gl.c \ 29 | demo.c \ 30 | microui/src/microui.c \ 31 | renderer.c \ 32 | elf_loader.c \ 33 | b/helper.linux.zip.o \ 34 | b/helper.obsd.zip.o \ 35 | b/helper.fbsd.zip.o \ 36 | b/helper.nbsd.zip.o \ 37 | -o b/demo.com.dbg 38 | objcopy --strip-all -Obinary b/demo.com.dbg b/demo.com 39 | -------------------------------------------------------------------------------- /renderer.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "microui.h" 3 | #include "renderer.h" 4 | #include "atlas.inl" 5 | #include "gl.h" 6 | void 7 | r_init(renderer *r) 8 | { 9 | memset(r, 0, sizeof(*r)); 10 | glEnable(GL_BLEND); 11 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 12 | glDisable(GL_CULL_FACE); 13 | glDisable(GL_DEPTH_TEST); 14 | glEnable(GL_SCISSOR_TEST); 15 | 16 | GLuint t; 17 | glGenTextures(1, &t); 18 | glActiveTexture(GL_TEXTURE0); 19 | glBindTexture(GL_TEXTURE_2D, t); 20 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 21 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 22 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 23 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 24 | glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, ATLAS_WIDTH, ATLAS_HEIGHT, 0, 25 | GL_RED, GL_UNSIGNED_BYTE, atlas_texture); 26 | 27 | GLint st; 28 | const GLchar *const vss = 29 | "#version 100\n" 30 | "precision mediump float;\n" 31 | "uniform mat4 trans;\n" 32 | "uniform vec2 sca;\n" 33 | "attribute vec2 axy;\n" 34 | "attribute vec2 auv;\n" 35 | "attribute vec4 argba;\n" 36 | "varying vec2 vuv;\n" 37 | "varying vec4 vrgba;\n" 38 | "void main()\n" 39 | "{\n" 40 | " gl_Position = trans * vec4(axy.x, axy.y, 0.0, 1.0);\n" 41 | " vuv = auv*sca;\n" 42 | " vrgba = argba;\n" 43 | "}\n"; 44 | GLuint vs = glCreateShader(GL_VERTEX_SHADER); 45 | glShaderSource(vs, 1, &vss, 0); 46 | glCompileShader(vs); 47 | glGetShaderiv(vs, GL_COMPILE_STATUS, &st); 48 | if (!st) { 49 | char err[1024]; 50 | glGetShaderInfoLog(vs, sizeof(err), 0, err); 51 | printf("verr %s\n", err); 52 | } 53 | const GLchar *const fss = 54 | "#version 100\n" 55 | "precision mediump float;\n" 56 | "uniform sampler2D stex;\n" 57 | "varying vec2 vuv;\n" 58 | "varying vec4 vrgba;\n" 59 | "void main()\n" 60 | "{\n" 61 | " gl_FragColor = vrgba * texture2D(stex,vuv).r;\n" 62 | "}\n"; 63 | GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); 64 | glShaderSource(fs, 1, &fss, 0); 65 | glCompileShader(fs); 66 | glGetShaderiv(fs, GL_COMPILE_STATUS, &st); 67 | if (!st) { 68 | char err[1024]; 69 | glGetShaderInfoLog(fs, sizeof(err), 0, err); 70 | printf("ferr %s\n", err); 71 | } 72 | GLuint sh = glCreateProgram(); 73 | glAttachShader(sh, vs); 74 | glAttachShader(sh, fs); 75 | glLinkProgram(sh); 76 | glGetProgramiv(sh, GL_LINK_STATUS, &st); 77 | if (!st) { 78 | char err[1024]; 79 | glGetProgramInfoLog(sh, sizeof(err), 0, err); 80 | printf("perr %s\n", err); 81 | } 82 | glUseProgram(sh); 83 | GLuint stex = glGetUniformLocation(sh, "stex"); 84 | glUniform1i(stex, 0); 85 | r->sca = glGetUniformLocation(sh, "sca"); 86 | GLuint vao; 87 | glGenVertexArrays(1, &vao); 88 | glBindVertexArray(vao); 89 | GLint xy = glGetAttribLocation(sh, "axy"); 90 | assert(xy >= 0); 91 | GLint uv = glGetAttribLocation(sh, "auv"); 92 | assert(uv >= 0); 93 | GLint rgba = glGetAttribLocation(sh, "argba"); 94 | assert(rgba >= 0); 95 | glGenBuffers(1, &r->vertbo); 96 | glBindBuffer(GL_ARRAY_BUFFER, r->vertbo); 97 | glVertexAttribPointer(xy, 2, GL_FLOAT, GL_FALSE, 0, 0); 98 | glEnableVertexAttribArray(xy); 99 | glGenBuffers(1, &r->texbo); 100 | glBindBuffer(GL_ARRAY_BUFFER, r->texbo); 101 | glVertexAttribPointer(uv, 2, GL_FLOAT, GL_FALSE, 0, 0); 102 | glEnableVertexAttribArray(uv); 103 | glGenBuffers(1, &r->colbo); 104 | glBindBuffer(GL_ARRAY_BUFFER, r->colbo); 105 | glVertexAttribPointer(rgba, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); 106 | glEnableVertexAttribArray(rgba); 107 | glGenBuffers(1, &r->indbo); 108 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, r->indbo); 109 | r->trans = glGetUniformLocation(sh, "trans"); 110 | assert(r->trans >= 0); 111 | glUniform2f(r->sca, 1.f / ATLAS_WIDTH, 1.f / ATLAS_HEIGHT); 112 | /* XXX Workaround, the previous call sets a bad value for the second */ 113 | /* component */ 114 | float sca[] = { 1.f / ATLAS_WIDTH, 1.f / ATLAS_HEIGHT }; 115 | glUniform2fv(r->sca, 1, sca); 116 | assert(glGetError() == 0); 117 | } 118 | 119 | static void 120 | flush(renderer *r, storage *s) 121 | { 122 | if (s->bi == 0) { 123 | return; 124 | } 125 | 126 | // clang-format off 127 | GLfloat t[] = { 128 | 2. / s->w, 0, 0, 0, 129 | 0, -2. / s->h, 0, 0, 130 | 0, 0, -1, 0, 131 | -1, 1, 1, 1, 132 | }; 133 | // clang-format on 134 | 135 | unsigned bi = s->bi; 136 | s->bi = 0; 137 | glUniformMatrix4fv(r->trans, 1, GL_FALSE, t); 138 | glBindBuffer(GL_ARRAY_BUFFER, r->vertbo); 139 | glBufferData( 140 | GL_ARRAY_BUFFER, bi * 8 * sizeof(s->xy[0]), s->xy, GL_DYNAMIC_DRAW); 141 | glBindBuffer(GL_ARRAY_BUFFER, r->texbo); 142 | glBufferData( 143 | GL_ARRAY_BUFFER, bi * 8 * sizeof(s->uv[0]), s->uv, GL_DYNAMIC_DRAW); 144 | glBindBuffer(GL_ARRAY_BUFFER, r->colbo); 145 | glBufferData(GL_ARRAY_BUFFER, bi * 16 * sizeof(s->rgba[0]), s->rgba, 146 | GL_DYNAMIC_DRAW); 147 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, r->indbo); 148 | glBufferData(GL_ELEMENT_ARRAY_BUFFER, bi * 6 * sizeof(s->ind[0]), 149 | s->ind, GL_DYNAMIC_DRAW); 150 | glDrawElements(GL_TRIANGLES, bi * 6, GL_UNSIGNED_INT, 0); 151 | // assert(glGetError() == 0); 152 | } 153 | 154 | static void 155 | push_quad(renderer *r, storage *s, mu_Rect dst, mu_Rect src, mu_Color color) 156 | { 157 | if (s->bi == BUFFER_SIZE) { 158 | flush(r, s); 159 | } 160 | 161 | float sx = src.x; 162 | float sy = src.y; 163 | float sw = src.w; 164 | float sh = src.h; 165 | float dx = dst.x; 166 | float dy = dst.y; 167 | float dw = dst.w; 168 | float dh = dst.h; 169 | 170 | unsigned bi = s->bi++; 171 | unsigned vi = bi * 8; 172 | unsigned ci = bi * 16; 173 | unsigned ei = bi * 4; 174 | unsigned ii = bi * 6; 175 | s->ind[ii + 0] = ei + 0; 176 | s->ind[ii + 1] = ei + 1; 177 | s->ind[ii + 2] = ei + 2; 178 | s->ind[ii + 3] = ei + 2; 179 | s->ind[ii + 4] = ei + 3; 180 | s->ind[ii + 5] = ei + 1; 181 | s->uv[vi + 0] = sx; 182 | s->uv[vi + 1] = sy; 183 | s->uv[vi + 2] = sx + sw; 184 | s->uv[vi + 3] = sy; 185 | s->uv[vi + 4] = sx; 186 | s->uv[vi + 5] = sy + sh; 187 | s->uv[vi + 6] = sx + sw; 188 | s->uv[vi + 7] = sy + sh; 189 | s->xy[vi + 0] = dx; 190 | s->xy[vi + 1] = dy; 191 | s->xy[vi + 2] = dx + dw; 192 | s->xy[vi + 3] = dy; 193 | s->xy[vi + 4] = dx; 194 | s->xy[vi + 5] = dy + dh; 195 | s->xy[vi + 6] = dx + dw; 196 | s->xy[vi + 7] = dy + dh; 197 | for (unsigned i = 0; i < 4; i++) { 198 | s->rgba[ci + 4 * i + 0] = color.r; 199 | s->rgba[ci + 4 * i + 1] = color.g; 200 | s->rgba[ci + 4 * i + 2] = color.b; 201 | s->rgba[ci + 4 * i + 3] = color.a; 202 | } 203 | } 204 | 205 | void 206 | r_draw_rect(renderer *r, storage *s, mu_Rect rect, mu_Color color) 207 | { 208 | push_quad(r, s, rect, atlas[ATLAS_WHITE], color); 209 | } 210 | 211 | void 212 | r_draw_text( 213 | renderer *r, storage *s, const char *text, mu_Vec2 pos, mu_Color color) 214 | { 215 | mu_Rect dst = { pos.x, pos.y, 0, 0 }; 216 | for (const char *p = text; *p; p++) { 217 | if ((*p & 0xc0) == 0x80) { 218 | continue; 219 | } 220 | int chr = mu_min((unsigned char)*p, 127); 221 | mu_Rect src = atlas[ATLAS_FONT + chr]; 222 | dst.w = src.w; 223 | dst.h = src.h; 224 | push_quad(r, s, dst, src, color); 225 | dst.x += dst.w; 226 | } 227 | } 228 | 229 | void 230 | r_draw_icon(renderer *r, storage *s, int id, mu_Rect rect, mu_Color color) 231 | { 232 | mu_Rect src = atlas[id]; 233 | int x = rect.x + (rect.w - src.w) / 2; 234 | int y = rect.y + (rect.h - src.h) / 2; 235 | push_quad(r, s, mu_rect(x, y, src.w, src.h), src, color); 236 | } 237 | 238 | int 239 | r_get_text_width(const char *text, int len) 240 | { 241 | int res = 0; 242 | if (len == -1) { 243 | len = strlen(text); 244 | } 245 | for (const char *p = text; *p && len--; p++) { 246 | if ((*p & 0xc0) == 0x80) { 247 | continue; 248 | } 249 | int chr = mu_min((unsigned char)*p, 127); 250 | res += atlas[ATLAS_FONT + chr].w; 251 | } 252 | return res; 253 | } 254 | 255 | int 256 | r_get_text_height(void) 257 | { 258 | return 18; 259 | } 260 | 261 | void 262 | r_set_clip_rect(renderer *r, storage *s, mu_Rect rect) 263 | { 264 | flush(r, s); 265 | glScissor(rect.x, s->h - (rect.y + rect.h), rect.w, rect.h); 266 | } 267 | 268 | void 269 | r_clear(renderer *r, storage *s, mu_Color clr) 270 | { 271 | flush(r, s); 272 | glClearColor(clr.r / 255., clr.g / 255., clr.b / 255., clr.a / 255.); 273 | glClear(GL_COLOR_BUFFER_BIT); 274 | } 275 | 276 | void 277 | r_present(renderer *r, storage *s) 278 | { 279 | flush(r, s); 280 | } 281 | 282 | void 283 | r_begin(renderer *r, storage *s, unsigned w, unsigned h) 284 | { 285 | s->bi = 0; 286 | s->w = w; 287 | s->h = h; 288 | glViewport(0, 0, w, h); 289 | glScissor(0, 0, w, h); 290 | } 291 | -------------------------------------------------------------------------------- /renderer.h: -------------------------------------------------------------------------------- 1 | #define BUFFER_SIZE 16384 2 | 3 | typedef struct renderer { 4 | unsigned texbo; 5 | unsigned vertbo; 6 | unsigned colbo; 7 | unsigned indbo; 8 | unsigned trans; 9 | unsigned sca; 10 | } renderer; 11 | 12 | typedef struct storage { 13 | unsigned w; 14 | unsigned h; 15 | unsigned bi; 16 | unsigned ind[BUFFER_SIZE * 6]; 17 | float uv[BUFFER_SIZE * 8]; 18 | float xy[BUFFER_SIZE * 8]; 19 | unsigned char rgba[BUFFER_SIZE * 16]; 20 | } storage; 21 | 22 | void r_init(renderer *); 23 | void r_begin(renderer *, storage *, unsigned, unsigned); 24 | void r_draw_rect(renderer *, storage *, mu_Rect, mu_Color); 25 | void r_draw_text(renderer *, storage *, const char *, mu_Vec2, mu_Color); 26 | void r_draw_icon(renderer *, storage *, int, mu_Rect, mu_Color); 27 | void r_set_clip_rect(renderer *, storage *, mu_Rect); 28 | void r_clear(renderer *, storage *, mu_Color); 29 | void r_present(renderer *, storage *); 30 | int r_get_text_width(const char *, int); 31 | int r_get_text_height(void); 32 | --------------------------------------------------------------------------------