inline assembly for msvc and watcom (untested)
[miniglut] / miniglut.c
1 /*
2 MiniGLUT - minimal GLUT subset without dependencies
3 Copyright (C) 2020  John Tsiombikas <nuclear@member.fsf.org>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  */
18 /*#define MINIGLUT_GCC_NO_BUILTIN*/
19
20 #ifdef MINIGLUT_USE_LIBC
21 #define _GNU_SOURCE
22 #include <stdlib.h>
23 #include <math.h>
24 #else
25
26 #if defined(__GNUC__) && !defined(MINIGLUT_GCC_NO_BUILTIN)
27 #define mglut_sincosf(a, s, c)  __builtin_sincosf(a, s, c)
28 #define mglut_atan(x)                   __builtin_atan(x)
29 #else
30 static void mglut_sincosf(float angle, float *sptr, float *cptr);
31 static float mglut_atan(float x);
32 #endif
33
34 #endif
35
36 #define PI      3.1415926536f
37
38 #if defined(__unix__)
39
40 #include <X11/Xlib.h>
41 #include <X11/cursorfont.h>
42 #include <GL/glx.h>
43 #define BUILD_X11
44
45 #ifndef GLX_SAMPLE_BUFFERS_ARB
46 #define GLX_SAMPLE_BUFFERS_ARB  100000
47 #define GLX_SAMPLES_ARB                 100001
48 #endif
49 #ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB
50 #define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB        0x20b2
51 #endif
52
53 static Display *dpy;
54 static Window win, root;
55 static int scr;
56 static GLXContext ctx;
57 static Atom xa_wm_proto, xa_wm_del_win;
58 static unsigned int evmask;
59
60 #elif defined(_WIN32)
61
62 #include <windows.h>
63 #define BUILD_WIN32
64
65 static HWND win;
66 static HDC dc;
67 static HGLRC ctx;
68
69 #else
70 #error unsupported platform
71 #endif
72
73 #include <GL/gl.h>
74 #include "miniglut.h"
75
76 struct ctx_info {
77         int rsize, gsize, bsize, asize;
78         int zsize, ssize;
79         int dblbuf;
80         int samples;
81         int stereo;
82         int srgb;
83 };
84
85 static void create_window(const char *title);
86 static void get_window_pos(Window win, int *x, int *y);
87 static void get_window_size(Window win, int *w, int *h);
88 static void get_screen_size(Window win, int *scrw, int *scrh);
89
90 static long get_msec(void);
91 static void panic(const char *msg);
92 static void sys_exit(int status);
93 static int sys_write(int fd, const void *buf, int count);
94
95
96 static int init_x, init_y, init_width = 256, init_height = 256;
97 static unsigned int init_mode;
98
99 static struct ctx_info ctx_info;
100 static int cur_cursor = GLUT_CURSOR_INHERIT;
101
102 static glut_cb cb_display;
103 static glut_cb cb_idle;
104 static glut_cb_reshape cb_reshape;
105 static glut_cb_state cb_vis, cb_entry;
106 static glut_cb_keyb cb_keydown, cb_keyup;
107 static glut_cb_special cb_skeydown, cb_skeyup;
108 static glut_cb_mouse cb_mouse;
109 static glut_cb_motion cb_motion, cb_passive;
110 static glut_cb_sbmotion cb_sball_motion, cb_sball_rotate;
111 static glut_cb_sbbutton cb_sball_button;
112
113 static int win_width, win_height;
114 static int mapped;
115 static int quit;
116 static int upd_pending, reshape_pending;
117 static int modstate;
118
119
120 void glutInit(int *argc, char **argv)
121 {
122 #ifdef BUILD_X11
123         if(!(dpy = XOpenDisplay(0))) {
124                 panic("Failed to connect to the X server\n");
125         }
126         scr = DefaultScreen(dpy);
127         root = RootWindow(dpy, scr);
128         xa_wm_proto = XInternAtom(dpy, "WM_PROTOCOLS", False);
129         xa_wm_del_win = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
130
131         evmask = ExposureMask | StructureNotifyMask;
132 #endif
133 }
134
135 void glutInitWindowPosition(int x, int y)
136 {
137         init_x = x;
138         init_y = y;
139 }
140
141 void glutInitWindowSize(int xsz, int ysz)
142 {
143         init_width = xsz;
144         init_height = ysz;
145 }
146
147 void glutInitDisplayMode(unsigned int mode)
148 {
149         init_mode = mode;
150 }
151
152 void glutCreateWindow(const char *title)
153 {
154         create_window(title);
155 }
156
157 void glutExit(void)
158 {
159         quit = 1;
160 }
161
162 void glutMainLoop(void)
163 {
164         while(!quit) {
165                 glutMainLoopEvent();
166         }
167 }
168
169 void glutPostRedisplay(void)
170 {
171         upd_pending = 1;
172 }
173
174 #define UPD_EVMASK(x) \
175         do { \
176                 if(func) { \
177                         evmask |= x; \
178                 } else { \
179                         evmask &= ~(x); \
180                 } \
181                 if(win) XSelectInput(dpy, win, evmask); \
182         } while(0)
183
184
185 void glutIdleFunc(glut_cb func)
186 {
187         cb_idle = func;
188 }
189
190 void glutDisplayFunc(glut_cb func)
191 {
192         cb_display = func;
193 }
194
195 void glutReshapeFunc(glut_cb_reshape func)
196 {
197         cb_reshape = func;
198 }
199
200 void glutVisibilityFunc(glut_cb_state func)
201 {
202         cb_vis = func;
203 #ifdef BUILD_X11
204         UPD_EVMASK(VisibilityChangeMask);
205 #endif
206 }
207
208 void glutEntryFunc(glut_cb_state func)
209 {
210         cb_entry = func;
211 #ifdef BUILD_X11
212         UPD_EVMASK(EnterWindowMask | LeaveWindowMask);
213 #endif
214 }
215
216 void glutKeyboardFunc(glut_cb_keyb func)
217 {
218         cb_keydown = func;
219 #ifdef BUILD_X11
220         UPD_EVMASK(KeyPressMask);
221 #endif
222 }
223
224 void glutKeyboardUpFunc(glut_cb_keyb func)
225 {
226         cb_keyup = func;
227 #ifdef BUILD_X11
228         UPD_EVMASK(KeyReleaseMask);
229 #endif
230 }
231
232 void glutSpecialFunc(glut_cb_special func)
233 {
234         cb_skeydown = func;
235 #ifdef BUILD_X11
236         UPD_EVMASK(KeyPressMask);
237 #endif
238 }
239
240 void glutSpecialUpFunc(glut_cb_special func)
241 {
242         cb_skeyup = func;
243 #ifdef BUILD_X11
244         UPD_EVMASK(KeyReleaseMask);
245 #endif
246 }
247
248 void glutMouseFunc(glut_cb_mouse func)
249 {
250         cb_mouse = func;
251 #ifdef BUILD_X11
252         UPD_EVMASK(ButtonPressMask | ButtonReleaseMask);
253 #endif
254 }
255
256 void glutMotionFunc(glut_cb_motion func)
257 {
258         cb_motion = func;
259 #ifdef BUILD_X11
260         UPD_EVMASK(ButtonMotionMask);
261 #endif
262 }
263
264 void glutPassiveMotionFunc(glut_cb_motion func)
265 {
266         cb_passive = func;
267 #ifdef BUILD_X11
268         UPD_EVMASK(PointerMotionMask);
269 #endif
270 }
271
272 void glutSpaceballMotionFunc(glut_cb_sbmotion func)
273 {
274         cb_sball_motion = func;
275 }
276
277 void glutSpaceballRotateFunc(glut_cb_sbmotion func)
278 {
279         cb_sball_rotate = func;
280 }
281
282 void glutSpaceballBittonFunc(glut_cb_sbbutton func)
283 {
284         cb_sball_button = func;
285 }
286
287 int glutGet(unsigned int s)
288 {
289         int x, y;
290         switch(s) {
291         case GLUT_WINDOW_X:
292                 get_window_pos(win, &x, &y);
293                 return x;
294         case GLUT_WINDOW_Y:
295                 get_window_pos(win, &x, &y);
296                 return y;
297         case GLUT_WINDOW_WIDTH:
298                 get_window_size(win, &x, &y);
299                 return x;
300         case GLUT_WINDOW_HEIGHT:
301                 get_window_size(win, &x, &y);
302                 return y;
303         case GLUT_WINDOW_BUFFER_SIZE:
304                 return ctx_info.rsize + ctx_info.gsize + ctx_info.bsize + ctx_info.asize;
305         case GLUT_WINDOW_STENCIL_SIZE:
306                 return ctx_info.ssize;
307         case GLUT_WINDOW_DEPTH_SIZE:
308                 return ctx_info.zsize;
309         case GLUT_WINDOW_RED_SIZE:
310                 return ctx_info.rsize;
311         case GLUT_WINDOW_GREEN_SIZE:
312                 return ctx_info.gsize;
313         case GLUT_WINDOW_BLUE_SIZE:
314                 return ctx_info.bsize;
315         case GLUT_WINDOW_ALPHA_SIZE:
316                 return ctx_info.asize;
317         case GLUT_WINDOW_DOUBLEBUFFER:
318                 return ctx_info.dblbuf;
319         case GLUT_WINDOW_RGBA:
320                 return 1;
321         case GLUT_WINDOW_NUM_SAMPLES:
322                 return ctx_info.samples;
323         case GLUT_WINDOW_STEREO:
324                 return ctx_info.stereo;
325         case GLUT_WINDOW_SRGB:
326                 return ctx_info.srgb;
327         case GLUT_WINDOW_CURSOR:
328                 return cur_cursor;
329         case GLUT_SCREEN_WIDTH:
330                 get_screen_size(win, &x, &y);
331                 return x;
332         case GLUT_SCREEN_HEIGHT:
333                 get_screen_size(win, &x, &y);
334                 return y;
335         case GLUT_INIT_DISPLAY_MODE:
336                 return init_mode;
337         case GLUT_INIT_WINDOW_X:
338                 return init_x;
339         case GLUT_INIT_WINDOW_Y:
340                 return init_y;
341         case GLUT_INIT_WINDOW_WIDTH:
342                 return init_width;
343         case GLUT_INIT_WINDOW_HEIGHT:
344                 return init_height;
345         case GLUT_ELAPSED_TIME:
346                 return get_msec();
347         default:
348                 break;
349         }
350         return 0;
351 }
352
353 int glutGetModifiers(void)
354 {
355         return modstate;
356 }
357
358 static int is_space(int c)
359 {
360         return c == ' ' || c == '\t' || c == '\v' || c == '\n' || c == '\r';
361 }
362
363 static const char *skip_space(const char *s)
364 {
365         while(*s && is_space(*s)) s++;
366         return s;
367 }
368
369 int glutExtensionSupported(char *ext)
370 {
371         const char *str, *eptr;
372
373         if(!(str = (const char*)glGetString(GL_EXTENSIONS))) {
374                 return 0;
375         }
376
377         while(*str) {
378                 str = skip_space(str);
379                 eptr = skip_space(ext);
380                 while(*str && !is_space(*str) && *eptr && *str == *eptr) {
381                         str++;
382                         eptr++;
383                 }
384                 if((!*str || is_space(*str)) && !*eptr) {
385                         return 1;
386                 }
387                 while(*str && !is_space(*str)) str++;
388         }
389
390         return 0;
391 }
392
393 /* TODO */
394 void glutSolidSphere(float rad, int slices, int stacks)
395 {
396         int i, j, k, gray;
397         float x, y, z, s, t, u, v, phi, theta, sintheta, costheta, sinphi, cosphi;
398         float du = 1.0f / (float)slices;
399         float dv = 1.0f / (float)stacks;
400
401         glBegin(GL_QUADS);
402         for(i=0; i<stacks; i++) {
403                 v = i * dv;
404                 for(j=0; j<slices; j++) {
405                         u = j * du;
406                         for(k=0; k<4; k++) {
407                                 gray = k ^ (k >> 1);
408                                 s = gray & 1 ? u + du : u;
409                                 t = gray & 2 ? v + dv : v;
410                                 theta = s * PI * 2.0f;
411                                 phi = t * PI;
412                                 mglut_sincosf(theta, &sintheta, &costheta);
413                                 mglut_sincosf(phi, &sinphi, &cosphi);
414                                 x = sintheta * sinphi;
415                                 y = costheta * sinphi;
416                                 z = cosphi;
417
418                                 glColor3f(s, t, 1);
419                                 glTexCoord2f(s, t);
420                                 glNormal3f(x, y, z);
421                                 glVertex3f(x * rad, y * rad, z * rad);
422                         }
423                 }
424         }
425         glEnd();
426 }
427
428 void glutWireSphere(float rad, int slices, int stacks)
429 {
430         glPushAttrib(GL_POLYGON_BIT);
431         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
432         glutSolidSphere(rad, slices, stacks);
433         glPopAttrib();
434 }
435
436 void glutSolidCube(float sz)
437 {
438         int i, j, idx, gray, flip, rotx;
439         float vpos[3], norm[3];
440         float rad = sz * 0.5f;
441
442         glBegin(GL_QUADS);
443         for(i=0; i<6; i++) {
444                 flip = i & 1;
445                 rotx = i >> 2;
446                 idx = (~i & 2) - rotx;
447                 norm[0] = norm[1] = norm[2] = 0.0f;
448                 norm[idx] = flip ^ ((i >> 1) & 1) ? -1 : 1;
449                 glNormal3fv(norm);
450                 vpos[idx] = norm[idx] * rad;
451                 for(j=0; j<4; j++) {
452                         gray = j ^ (j >> 1);
453                         vpos[i & 2] = (gray ^ flip) & 1 ? rad : -rad;
454                         vpos[rotx + 1] = (gray ^ (rotx << 1)) & 2 ? rad : -rad;
455                         glTexCoord2f(gray & 1, gray >> 1);
456                         glVertex3fv(vpos);
457                 }
458         }
459         glEnd();
460 }
461
462 void glutWireCube(float sz)
463 {
464         glPushAttrib(GL_POLYGON_BIT);
465         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
466         glutSolidCube(sz);
467         glPopAttrib();
468 }
469
470 static void draw_cylinder(float rbot, float rtop, float height, int slices, int stacks)
471 {
472         int i, j, k, gray;
473         float x, y, z, s, t, u, v, theta, phi, sintheta, costheta, sinphi, cosphi, rad;
474         float du = 1.0f / (float)slices;
475         float dv = 1.0f / (float)stacks;
476
477         rad = rbot - rtop;
478         phi = mglut_atan((rad < 0 ? -rad : rad) / height);
479         mglut_sincosf(phi, &sinphi, &cosphi);
480
481         glBegin(GL_QUADS);
482         for(i=0; i<stacks; i++) {
483                 v = i * dv;
484                 for(j=0; j<slices; j++) {
485                         u = j * du;
486                         for(k=0; k<4; k++) {
487                                 gray = k ^ (k >> 1);
488                                 s = gray & 2 ? u + du : u;
489                                 t = gray & 1 ? v + dv : v;
490                                 rad = rbot + (rtop - rbot) * t;
491                                 theta = s * PI * 2.0f;
492                                 mglut_sincosf(theta, &sintheta, &costheta);
493
494                                 x = sintheta * cosphi;
495                                 y = costheta * cosphi;
496                                 z = sinphi;
497
498                                 glColor3f(s, t, 1);
499                                 glTexCoord2f(s, t);
500                                 glNormal3f(x, y, z);
501                                 glVertex3f(sintheta * rad, costheta * rad, t * height);
502                         }
503                 }
504         }
505         glEnd();
506 }
507
508 void glutSolidCone(float base, float height, int slices, int stacks)
509 {
510         draw_cylinder(base, 0, height, slices, stacks);
511 }
512
513 void glutWireCone(float base, float height, int slices, int stacks)
514 {
515         glPushAttrib(GL_POLYGON_BIT);
516         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
517         glutSolidCone(base, height, slices, stacks);
518         glPopAttrib();
519 }
520
521 void glutSolidCylinder(float rad, float height, int slices, int stacks)
522 {
523         draw_cylinder(rad, rad, height, slices, stacks);
524 }
525
526 void glutWireCylinder(float rad, float height, int slices, int stacks)
527 {
528         glPushAttrib(GL_POLYGON_BIT);
529         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
530         glutSolidCylinder(rad, height, slices, stacks);
531         glPopAttrib();
532 }
533
534 void glutSolidTorus(float inner_rad, float outer_rad, int sides, int rings)
535 {
536         int i, j, k, gray;
537         float x, y, z, s, t, u, v, phi, theta, sintheta, costheta, sinphi, cosphi;
538         float du = 1.0f / (float)rings;
539         float dv = 1.0f / (float)sides;
540
541         glBegin(GL_QUADS);
542         for(i=0; i<rings; i++) {
543                 u = i * du;
544                 for(j=0; j<sides; j++) {
545                         v = j * dv;
546                         for(k=0; k<4; k++) {
547                                 gray = k ^ (k >> 1);
548                                 s = gray & 1 ? u + du : u;
549                                 t = gray & 2 ? v + dv : v;
550                                 theta = s * PI * 2.0f;
551                                 phi = t * PI * 2.0f;
552                                 mglut_sincosf(theta, &sintheta, &costheta);
553                                 mglut_sincosf(phi, &sinphi, &cosphi);
554                                 x = sintheta * sinphi;
555                                 y = costheta * sinphi;
556                                 z = cosphi;
557
558                                 glColor3f(s, t, 1);
559                                 glTexCoord2f(s, t);
560                                 glNormal3f(x, y, z);
561
562                                 x = x * inner_rad + sintheta * outer_rad;
563                                 y = y * inner_rad + costheta * outer_rad;
564                                 z *= inner_rad;
565                                 glVertex3f(x, y, z);
566                         }
567                 }
568         }
569         glEnd();
570 }
571
572 void glutWireTorus(float inner_rad, float outer_rad, int sides, int rings)
573 {
574         glPushAttrib(GL_POLYGON_BIT);
575         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
576         glutSolidTorus(inner_rad, outer_rad, sides, rings);
577         glPopAttrib();
578 }
579
580 void glutSolidTeapot(float size)
581 {
582 }
583
584 void glutWireTeapot(float size)
585 {
586 }
587
588
589 #ifdef BUILD_X11
590 static void handle_event(XEvent *ev);
591
592 void glutMainLoopEvent(void)
593 {
594         XEvent ev;
595
596         if(!cb_display) {
597                 panic("display callback not set");
598         }
599
600         for(;;) {
601                 if(!upd_pending && !cb_idle) {
602                         XNextEvent(dpy, &ev);
603                         handle_event(&ev);
604                         if(quit) return;
605                 }
606                 while(XPending(dpy)) {
607                         XNextEvent(dpy, &ev);
608                         handle_event(&ev);
609                         if(quit) return;
610                 }
611
612                 if(cb_idle) {
613                         cb_idle();
614                 }
615
616                 if(upd_pending && mapped) {
617                         upd_pending = 0;
618                         cb_display();
619                 }
620         }
621 }
622
623 static KeySym translate_keysym(KeySym sym)
624 {
625         switch(sym) {
626         case XK_Escape:
627                 return 27;
628         case XK_BackSpace:
629                 return '\b';
630         case XK_Linefeed:
631                 return '\r';
632         case XK_Return:
633                 return '\n';
634         case XK_Delete:
635                 return 127;
636         case XK_Tab:
637                 return '\t';
638         default:
639                 break;
640         }
641         return sym;
642 }
643
644 static void handle_event(XEvent *ev)
645 {
646         KeySym sym;
647
648         switch(ev->type) {
649         case MapNotify:
650                 mapped = 1;
651                 break;
652         case UnmapNotify:
653                 mapped = 0;
654                 break;
655         case ConfigureNotify:
656                 if(cb_reshape && (ev->xconfigure.width != win_width || ev->xconfigure.height != win_height)) {
657                         win_width = ev->xconfigure.width;
658                         win_height = ev->xconfigure.height;
659                         cb_reshape(ev->xconfigure.width, ev->xconfigure.height);
660                 }
661                 break;
662
663         case ClientMessage:
664                 if(ev->xclient.message_type == xa_wm_proto) {
665                         if(ev->xclient.data.l[0] == xa_wm_del_win) {
666                                 quit = 1;
667                         }
668                 }
669                 break;
670
671         case Expose:
672                 upd_pending = 1;
673                 break;
674
675         case KeyPress:
676         case KeyRelease:
677                 modstate = ev->xkey.state & (ShiftMask | ControlMask | Mod1Mask);
678                 if(!(sym = XLookupKeysym(&ev->xkey, 0))) {
679                         break;
680                 }
681                 sym = translate_keysym(sym);
682                 if(sym < 256) {
683                         if(ev->type == KeyPress) {
684                                 if(cb_keydown) cb_keydown((unsigned char)sym, ev->xkey.x, ev->xkey.y);
685                         } else {
686                                 if(cb_keyup) cb_keyup((unsigned char)sym, ev->xkey.x, ev->xkey.y);
687                         }
688                 } else {
689                         if(ev->type == KeyPress) {
690                                 if(cb_skeydown) cb_skeydown(sym, ev->xkey.x, ev->xkey.y);
691                         } else {
692                                 if(cb_skeyup) cb_skeyup(sym, ev->xkey.x, ev->xkey.y);
693                         }
694                 }
695                 break;
696
697         case ButtonPress:
698         case ButtonRelease:
699                 modstate = ev->xbutton.state & (ShiftMask | ControlMask | Mod1Mask);
700                 if(cb_mouse) {
701                         int bn = ev->xbutton.button - Button1;
702                         cb_mouse(bn, ev->type == ButtonPress ? GLUT_DOWN : GLUT_UP,
703                                         ev->xbutton.x, ev->xbutton.y);
704                 }
705                 break;
706
707         case MotionNotify:
708                 if(ev->xmotion.state & (Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask)) {
709                         if(cb_motion) cb_motion(ev->xmotion.x, ev->xmotion.y);
710                 } else {
711                         if(cb_passive) cb_passive(ev->xmotion.x, ev->xmotion.y);
712                 }
713                 break;
714
715         case VisibilityNotify:
716                 if(cb_vis) {
717                         cb_vis(ev->xvisibility.state == VisibilityFullyObscured ? GLUT_NOT_VISIBLE : GLUT_VISIBLE);
718                 }
719                 break;
720         case EnterNotify:
721                 if(cb_entry) cb_entry(GLUT_ENTERED);
722                 break;
723         case LeaveNotify:
724                 if(cb_entry) cb_entry(GLUT_LEFT);
725                 break;
726         }
727 }
728
729 void glutSwapBuffers(void)
730 {
731         glXSwapBuffers(dpy, win);
732 }
733
734 void glutPositionWindow(int x, int y)
735 {
736         XMoveWindow(dpy, win, x, y);
737 }
738
739 void glutReshapeWindow(int xsz, int ysz)
740 {
741         XResizeWindow(dpy, win, xsz, ysz);
742 }
743
744 void glutFullScreen(void)
745 {
746         /* TODO */
747 }
748
749 void glutSetWindowTitle(const char *title)
750 {
751         XTextProperty tprop;
752         if(!XStringListToTextProperty((char**)&title, 1, &tprop)) {
753                 return;
754         }
755         XSetWMName(dpy, win, &tprop);
756         XFree(tprop.value);
757 }
758
759 void glutSetIconTitle(const char *title)
760 {
761         XTextProperty tprop;
762         if(!XStringListToTextProperty((char**)&title, 1, &tprop)) {
763                 return;
764         }
765         XSetWMIconName(dpy, win, &tprop);
766         XFree(tprop.value);
767 }
768
769 void glutSetCursor(int cidx)
770 {
771         Cursor cur = None;
772
773         switch(cidx) {
774         case GLUT_CURSOR_LEFT_ARROW:
775                 cur = XCreateFontCursor(dpy, XC_left_ptr);
776                 break;
777         case GLUT_CURSOR_INHERIT:
778                 break;
779         case GLUT_CURSOR_NONE:
780                 /* TODO */
781         default:
782                 return;
783         }
784
785         XDefineCursor(dpy, win, cur);
786         cur_cursor = cidx;
787 }
788
789 static XVisualInfo *choose_visual(unsigned int mode)
790 {
791         XVisualInfo *vi;
792         int attr[32] = {
793                 GLX_RGBA,
794                 GLX_DOUBLEBUFFER,
795                 GLX_RED_SIZE, 4,
796                 GLX_GREEN_SIZE, 4,
797                 GLX_BLUE_SIZE, 4
798         };
799         int *aptr = attr + 8;
800         int *samples = 0;
801
802         if(mode & GLUT_ALPHA) {
803                 *aptr++ = GLX_ALPHA_SIZE;
804                 *aptr++ = 4;
805         }
806         if(mode & GLUT_DEPTH) {
807                 *aptr++ = GLX_DEPTH_SIZE;
808                 *aptr++ = 16;
809         }
810         if(mode & GLUT_STENCIL) {
811                 *aptr++ = GLX_STENCIL_SIZE;
812                 *aptr++ = 1;
813         }
814         if(mode & GLUT_ACCUM) {
815                 *aptr++ = GLX_ACCUM_RED_SIZE; *aptr++ = 1;
816                 *aptr++ = GLX_ACCUM_GREEN_SIZE; *aptr++ = 1;
817                 *aptr++ = GLX_ACCUM_BLUE_SIZE; *aptr++ = 1;
818         }
819         if(mode & GLUT_STEREO) {
820                 *aptr++ = GLX_STEREO;
821         }
822         if(mode & GLUT_SRGB) {
823                 *aptr++ = GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB;
824         }
825         if(mode & GLUT_MULTISAMPLE) {
826                 *aptr++ = GLX_SAMPLE_BUFFERS_ARB;
827                 *aptr++ = 1;
828                 *aptr++ = GLX_SAMPLES_ARB;
829                 samples = aptr;
830                 *aptr++ = 32;
831         }
832         *aptr++ = None;
833
834         if(!samples) {
835                 return glXChooseVisual(dpy, scr, attr);
836         }
837         while(!(vi = glXChooseVisual(dpy, scr, attr)) && *samples) {
838                 *samples >>= 1;
839                 if(!*samples) {
840                         aptr[-3] = None;
841                 }
842         }
843         return vi;
844 }
845
846 static void create_window(const char *title)
847 {
848         XSetWindowAttributes xattr;
849         XVisualInfo *vi;
850         unsigned int xattr_mask;
851         unsigned int mode = init_mode;
852
853         if(!(vi = choose_visual(mode))) {
854                 mode &= ~GLUT_SRGB;
855                 if(!(vi = choose_visual(mode))) {
856                         panic("Failed to find compatible visual\n");
857                 }
858         }
859
860         if(!(ctx = glXCreateContext(dpy, vi, 0, True))) {
861                 XFree(vi);
862                 panic("Failed to create OpenGL context\n");
863         }
864
865         glXGetConfig(dpy, vi, GLX_RED_SIZE, &ctx_info.rsize);
866         glXGetConfig(dpy, vi, GLX_GREEN_SIZE, &ctx_info.gsize);
867         glXGetConfig(dpy, vi, GLX_BLUE_SIZE, &ctx_info.bsize);
868         glXGetConfig(dpy, vi, GLX_ALPHA_SIZE, &ctx_info.asize);
869         glXGetConfig(dpy, vi, GLX_DEPTH_SIZE, &ctx_info.zsize);
870         glXGetConfig(dpy, vi, GLX_STENCIL_SIZE, &ctx_info.ssize);
871         glXGetConfig(dpy, vi, GLX_DOUBLEBUFFER, &ctx_info.dblbuf);
872         glXGetConfig(dpy, vi, GLX_STEREO, &ctx_info.stereo);
873         glXGetConfig(dpy, vi, GLX_SAMPLES_ARB, &ctx_info.samples);
874         glXGetConfig(dpy, vi, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &ctx_info.srgb);
875
876         xattr.background_pixel = BlackPixel(dpy, scr);
877         xattr.colormap = XCreateColormap(dpy, root, vi->visual, AllocNone);
878         xattr_mask = CWBackPixel | CWColormap;
879         if(!(win = XCreateWindow(dpy, root, init_x, init_y, init_width, init_height, 0,
880                         vi->depth, InputOutput, vi->visual, xattr_mask, &xattr))) {
881                 XFree(vi);
882                 glXDestroyContext(dpy, ctx);
883                 panic("Failed to create window\n");
884         }
885         XFree(vi);
886
887         XSelectInput(dpy, win, evmask);
888
889         glutSetWindowTitle(title);
890         glutSetIconTitle(title);
891         XSetWMProtocols(dpy, win, &xa_wm_del_win, 1);
892         XMapWindow(dpy, win);
893
894         glXMakeCurrent(dpy, win, ctx);
895 }
896
897 static void get_window_pos(Window win, int *x, int *y)
898 {
899         XWindowAttributes wattr;
900         XGetWindowAttributes(dpy, win, &wattr);
901         *x = wattr.x;
902         *y = wattr.y;
903 }
904
905 static void get_window_size(Window win, int *w, int *h)
906 {
907         XWindowAttributes wattr;
908         XGetWindowAttributes(dpy, win, &wattr);
909         *w = wattr.width;
910         *h = wattr.height;
911 }
912
913 static void get_screen_size(Window win, int *scrw, int *scrh)
914 {
915         XWindowAttributes wattr;
916         XGetWindowAttributes(dpy, root, &wattr);
917         *scrw = wattr.width;
918         *scrh = wattr.height;
919 }
920 #endif
921
922 #if defined(__unix__) || defined(__APPLE__)
923 #include <sys/time.h>
924
925 static long get_msec(void)
926 {
927         static struct timeval tv0;
928         struct timeval tv;
929
930         gettimeofday(&tv, 0);
931         if(tv0.tv_sec == 0 && tv0.tv_usec == 0) {
932                 tv0 = tv;
933                 return 0;
934         }
935         return (tv.tv_sec - tv0.tv_sec) * 1000 + (tv.tv_usec - tv0.tv_usec) / 1000;
936 }
937 #endif
938 #ifdef _WIN32
939 static long get_msec(void)
940 {
941         static long t0;
942
943         if(!t0) {
944                 t0 = timeGetTime();
945                 return 0;
946         }
947         return timeGetTime() - t0;
948 }
949 #endif
950
951 static void panic(const char *msg)
952 {
953         const char *end = msg;
954         while(*end) end++;
955         sys_write(2, msg, end - msg);
956         sys_exit(1);
957 }
958
959
960 #ifdef MINIGLUT_USE_LIBC
961 static void sys_exit(int status)
962 {
963         exit(status);
964 }
965
966 static int sys_write(int fd, const void *buf, int count)
967 {
968         return write(fd, buf, count);
969 }
970
971 #else   /* !MINIGLUT_USE_LIBC */
972
973 #if defined(__GNUC__) && defined(MINIGLUT_GCC_NO_BUILTIN)
974 static void mglut_sincosf(float angle, float *sptr, float *cptr)
975 {
976         asm volatile(
977                 "flds %2\n\t"
978                 "fsincos\n\t"
979                 "fstps %1\n\t"
980                 "fstps %0\n\t"
981                 : "=m"(*sptr), "=m"(*cptr)
982                 : "m"(angle)
983         );
984 }
985
986 static float mglut_atan(float x)
987 {
988         float res;
989         asm volatile(
990                 "flds %1\n\t"
991                 "fld1\n\t"
992                 "fpatan\n\t"
993                 "fstps %0\n\t"
994                 : "=m"(res)
995                 : "m"(x)
996         );
997         return res;
998 }
999 #endif
1000
1001 #ifdef _MSC_VER
1002 static void mglut_sincosf(float angle, float *sptr, float *cptr)
1003 {
1004         float s, c;
1005         __asm {
1006                 fld angle
1007                 fsincos
1008                 fstp c
1009                 fstp s
1010         }
1011         *sptr = s;
1012         *cptr = c;
1013 }
1014
1015 static float mglut_atan(float x)
1016 {
1017         float res;
1018         __asm {
1019                 fld x
1020                 fld1
1021                 fpatan
1022                 fstp res
1023         }
1024         return res;
1025 }
1026 #endif
1027
1028 #ifdef __WATCOMC__
1029 #pragma aux mglut_sincosf = \
1030         "fsincos" \
1031         "fstp dword ptr [edx]" \
1032         "fstp dword ptr [eax]" \
1033         parm[8087][eax][edx]    \
1034         modify[8087];
1035
1036 #pragma aux mglut_atan = \
1037         "fld1" \
1038         "fpatan" \
1039         parm[8087] \
1040         value[8087] \
1041         modify [8087];
1042 #endif
1043
1044 #ifdef __linux__
1045
1046 #ifdef __x86_64__
1047 static void sys_exit(int status)
1048 {
1049         asm volatile(
1050                 "syscall\n\t"
1051                 :: "a"(60), "D"(status)
1052         );
1053 }
1054 static int sys_write(int fd, const void *buf, int count)
1055 {
1056         long res;
1057         asm volatile(
1058                 "syscall\n\t"
1059                 : "=a"(res)
1060                 : "a"(1), "D"(fd), "S"(buf), "d"(count)
1061         );
1062         return res;
1063 }
1064 #endif
1065 #ifdef __i386__
1066 static void sys_exit(int status)
1067 {
1068         asm volatile(
1069                 "mov $1, %%eax\n\t"
1070                 "int $0x80\n\t"
1071                 :: "b"(status)
1072                 : "eax"
1073         );
1074 }
1075 static int sys_write(int fd, const void *buf, int count)
1076 {
1077         int res;
1078         asm volatile(
1079                 "mov $4, %%eax\n\t"
1080                 "int $0x80\n\t"
1081                 :: "b"(fd), "c"(buf), "d"(count));
1082         return res;
1083 }
1084 #endif
1085
1086 #endif  /* __linux__ */
1087
1088 #ifdef _WIN32
1089 static int sys_exit(int status)
1090 {
1091         ExitProcess(status);
1092 }
1093 static int sys_write(int fd, const void *buf, int count)
1094 {
1095         int wrsz;
1096
1097         HANDLE out = GetStdHandle(fd == 1 ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE);
1098         if(!WriteFile(out, buf, count, &wrsz, 0)) {
1099                 return -1;
1100         }
1101         return wrsz;
1102 }
1103 #endif  /* _WIN32 */
1104
1105 #endif  /* !MINIGLUT_USE_LIBC */