/*

MiniGLUT - minimal GLUT subset without dependencies

Copyright (C) 2020-2026 John Tsiombikas <[email protected]>

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <https://www.gnu.org/licenses/>.

*/

#if defined(unix) || defined(__unix__)

#include <X11/Xlib.h>

#include <X11/keysym.h>

#include <X11/cursorfont.h>

#include <GL/glx.h>

#define BUILD_X11

#ifndef GLX_SAMPLE_BUFFERS_ARB

#define GLX_SAMPLE_BUFFERS_ARB 100000

#define GLX_SAMPLES_ARB 100001

#endif

#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB

#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20b2

#endif

Display *miniglut_dpy;

Window miniglut_win;

#define dpy miniglut_dpy

#define win miniglut_win

static Window root;

static Colormap cmap;

static int cmap_size;

static int scr;

static GLXContext ctx;

static Atom xa_wm_proto, xa_wm_del_win;

static Atom xa_net_wm_state, xa_net_wm_state_fullscr;

static Atom xa_motif_wm_hints;

static Atom xa_motion_event, xa_button_press_event, xa_button_release_event, xa_command_event;

static unsigned int evmask;

static Cursor blank_cursor;

static int have_netwm_fullscr(void);

#elif defined(_WIN32)

#include <windows.h>

#define BUILD_WIN32

static LRESULT CALLBACK handle_message(HWND win, unsigned int msg, WPARAM wparam, LPARAM lparam);

static HINSTANCE hinst;

static HWND win;

static HDC dc;

static HGLRC ctx;

static HPALETTE cmap;

static int cmap_size;

#else

#error unsupported platform

#endif

#include <GL/gl.h>

#include "miniglut.h"

#ifdef _MSC_VER

#pragma warning (disable: 4244 4305)

#endif

struct ctx_info {

int rsize, gsize, bsize, asize;

int zsize, ssize;

int dblbuf;

int samples;

int stereo;

int srgb;

};

#define NUM_GLYPHS 96

struct font {

int listbase;

int height, width[NUM_GLYPHS];

};

static void cleanup(void);

static void create_window(const char *title);

static void get_window_pos(int *x, int *y);

static void get_window_size(int *w, int *h);

static void get_screen_size(int *scrw, int *scrh);

static int wsys_extension_supported(const char *ext);

static long get_msec(void);

static void print(const char *msg);

static void panic(const char *msg);

static void sys_exit(int status);

static int sys_write(int fd, const void *buf, int count);

static int init_x = -1, init_y, init_width = 256, init_height = 256;

static unsigned int init_mode;

static struct ctx_info ctx_info;

static int cur_cursor = GLUT_CURSOR_INHERIT;

static int ignore_key_repeat;

static glut_cb cb_display;

static glut_cb cb_idle;

static glut_cb_reshape cb_reshape;

static glut_cb_state cb_vis, cb_entry;

static glut_cb_keyb cb_keydown, cb_keyup;

static glut_cb_special cb_skeydown, cb_skeyup;

static glut_cb_mouse cb_mouse;

static glut_cb_motion cb_motion, cb_passive;

static glut_cb_sbmotion cb_sball_motion, cb_sball_rotate;

static glut_cb_sbbutton cb_sball_button;

static int fullscreen;

static int prev_win_x, prev_win_y, prev_win_width, prev_win_height;

static int win_width, win_height;

static int mapped;

static int quit;

static int upd_pending;

static int modstate;

static int has_sball, sball_nbuttons;

#define NUM_FONTS 9 /* must match GLUT_STROKE_*|GLUT_BITMAP_* enum size */

static struct font fonts[NUM_FONTS];

static int have_swap_control_tear;

void glutInit(int *argc, char **argv)

{

int i;

#ifdef BUILD_X11

Pixmap blankpix = 0;

XColor xcol;

if(!(dpy = XOpenDisplay(0))) {

panic("Failed to connect to the X server\n");

}

scr = DefaultScreen(dpy);

root = RootWindow(dpy, scr);

xa_wm_proto = XInternAtom(dpy, "WM_PROTOCOLS", False);

xa_wm_del_win = XInternAtom(dpy, "WM_DELETE_WINDOW", False);

xa_motif_wm_hints = XInternAtom(dpy, "_MOTIF_WM_HINTS", False);

xa_net_wm_state_fullscr = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);

if(have_netwm_fullscr()) {

xa_net_wm_state = XInternAtom(dpy, "_NET_WM_STATE", False);

}

xa_motion_event = XInternAtom(dpy, "MotionEvent", True);

xa_button_press_event = XInternAtom(dpy, "ButtonPressEvent", True);

xa_button_release_event = XInternAtom(dpy, "ButtonReleaseEvent", True);

xa_command_event = XInternAtom(dpy, "CommandEvent", True);

evmask = ExposureMask | StructureNotifyMask;

if((blankpix = XCreateBitmapFromData(dpy, root, (char*)&blankpix, 1, 1))) {

blank_cursor = XCreatePixmapCursor(dpy, blankpix, blankpix, &xcol, &xcol, 0, 0);

XFreePixmap(dpy, blankpix);

}

#endif

#ifdef BUILD_WIN32

WNDCLASSEX wc = {0};

hinst = GetModuleHandle(0);

wc.cbSize = sizeof wc;

wc.hbrBackground = GetStockObject(BLACK_BRUSH);

wc.hCursor = LoadCursor(0, IDC_ARROW);

wc.hIcon = wc.hIconSm = LoadIcon(0, IDI_APPLICATION);

wc.hInstance = hinst;

wc.lpfnWndProc = handle_message;

wc.lpszClassName = "MiniGLUT";

wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

if(!RegisterClassEx(&wc)) {

panic("Failed to register \"MiniGLUT\" window class\n");

}

if(init_x == -1) {

get_screen_size(&init_x, &init_y);

init_x >>= 3;

init_y >>= 3;

}

#endif

for(i=0; i<NUM_FONTS; i++) {

fonts[i].listbase = -1; /* mark un-initialized */

}

}

void glutInitWindowPosition(int x, int y)

{

init_x = x;

init_y = y;

}

void glutInitWindowSize(int xsz, int ysz)

{

init_width = xsz;

init_height = ysz;

}

void glutInitDisplayMode(unsigned int mode)

{

init_mode = mode;

}

void glutCreateWindow(const char *title)

{

create_window(title);

}

void glutExit(void)

{

quit = 1;

}

void glutMainLoop(void)

{

while(!quit) {

glutMainLoopEvent();

}

}

void glutPostRedisplay(void)

{

upd_pending = 1;

}

void glutIgnoreKeyRepeat(int ignore)

{

ignore_key_repeat = ignore;

}

#define UPD_EVMASK(x) \

do { \

if(func) { \

evmask |= x; \

} else { \

evmask &= ~(x); \

} \

if(win) XSelectInput(dpy, win, evmask); \

} while(0)

void glutIdleFunc(glut_cb func)

{

cb_idle = func;

}

void glutDisplayFunc(glut_cb func)

{

cb_display = func;

}

void glutReshapeFunc(glut_cb_reshape func)

{

cb_reshape = func;

}

void glutVisibilityFunc(glut_cb_state func)

{

cb_vis = func;

#ifdef BUILD_X11

UPD_EVMASK(VisibilityChangeMask);

#endif

}

void glutEntryFunc(glut_cb_state func)

{

cb_entry = func;

#ifdef BUILD_X11

UPD_EVMASK(EnterWindowMask | LeaveWindowMask);

#endif

}

void glutKeyboardFunc(glut_cb_keyb func)

{

cb_keydown = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyPressMask);

#endif

}

void glutKeyboardUpFunc(glut_cb_keyb func)

{

cb_keyup = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyReleaseMask);

#endif

}

void glutSpecialFunc(glut_cb_special func)

{

cb_skeydown = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyPressMask);

#endif

}

void glutSpecialUpFunc(glut_cb_special func)

{

cb_skeyup = func;

#ifdef BUILD_X11

UPD_EVMASK(KeyReleaseMask);

#endif

}

void glutMouseFunc(glut_cb_mouse func)

{

cb_mouse = func;

#ifdef BUILD_X11

UPD_EVMASK(ButtonPressMask | ButtonReleaseMask);

#endif

}

void glutMotionFunc(glut_cb_motion func)

{

cb_motion = func;

#ifdef BUILD_X11

UPD_EVMASK(ButtonMotionMask);

#endif

}

void glutPassiveMotionFunc(glut_cb_motion func)

{

cb_passive = func;

#ifdef BUILD_X11

UPD_EVMASK(PointerMotionMask);

#endif

}

void glutSpaceballMotionFunc(glut_cb_sbmotion func)

{

cb_sball_motion = func;

}

void glutSpaceballRotateFunc(glut_cb_sbmotion func)

{

cb_sball_rotate = func;

}

void glutSpaceballButtonFunc(glut_cb_sbbutton func)

{

cb_sball_button = func;

}

int glutGet(unsigned int s)

{

int x, y;

switch(s) {

case GLUT_WINDOW_X:

get_window_pos(&x, &y);

return x;

case GLUT_WINDOW_Y:

get_window_pos(&x, &y);

return y;

case GLUT_WINDOW_WIDTH:

get_window_size(&x, &y);

return x;

case GLUT_WINDOW_HEIGHT:

get_window_size(&x, &y);

return y;

case GLUT_WINDOW_BUFFER_SIZE:

return ctx_info.rsize + ctx_info.gsize + ctx_info.bsize + ctx_info.asize;

case GLUT_WINDOW_STENCIL_SIZE:

return ctx_info.ssize;

case GLUT_WINDOW_DEPTH_SIZE:

return ctx_info.zsize;

case GLUT_WINDOW_RED_SIZE:

return ctx_info.rsize;

case GLUT_WINDOW_GREEN_SIZE:

return ctx_info.gsize;

case GLUT_WINDOW_BLUE_SIZE:

return ctx_info.bsize;

case GLUT_WINDOW_ALPHA_SIZE:

return ctx_info.asize;

case GLUT_WINDOW_DOUBLEBUFFER:

return ctx_info.dblbuf;

case GLUT_WINDOW_RGBA:

return 1;

case GLUT_WINDOW_NUM_SAMPLES:

return ctx_info.samples;

case GLUT_WINDOW_STEREO:

return ctx_info.stereo;

case GLUT_WINDOW_SRGB:

return ctx_info.srgb;

case GLUT_WINDOW_CURSOR:

return cur_cursor;

case GLUT_WINDOW_COLORMAP_SIZE:

return cmap_size;

case GLUT_SCREEN_WIDTH:

get_screen_size(&x, &y);

return x;

case GLUT_SCREEN_HEIGHT:

get_screen_size(&x, &y);

return y;

case GLUT_INIT_DISPLAY_MODE:

return init_mode;

case GLUT_INIT_WINDOW_X:

return init_x;

case GLUT_INIT_WINDOW_Y:

return init_y;

case GLUT_INIT_WINDOW_WIDTH:

return init_width;

case GLUT_INIT_WINDOW_HEIGHT:

return init_height;

case GLUT_ELAPSED_TIME:

return get_msec();

default:

break;

}

return 0;

}

int glutDeviceGet(unsigned int x)

{

switch(x) {

case GLUT_HAS_KEYBOARD:

case GLUT_HAS_MOUSE:

return 1;

case GLUT_NUM_MOUSE_BUTTONS:

return 3;

case GLUT_HAS_SPACEBALL:

return has_sball;

case GLUT_NUM_SPACEBALL_BUTTONS:

return sball_nbuttons;

case GLUT_HAS_DIAL_AND_BUTTON_BOX:

case GLUT_HAS_TABLET:

case GLUT_NUM_BUTTON_BOX_BUTTONS:

case GLUT_NUM_DIALS:

case GLUT_NUM_TABLET_BUTTONS:

return 0;

default:

break;

}

return -1;

}

int glutGetModifiers(void)

{

return modstate;

}

static int is_space(int c)

{

return c == ' ' || c == '\t' || c == '\v' || c == '\n' || c == '\r';

}

static const char *skip_space(const char *s)

{

while(*s && is_space(*s)) s++;

return s;

}

static int match_ext(const char *extlist, const char *name)

{

const char *eptr;

while(*extlist) {

extlist = skip_space(extlist);

eptr = skip_space(name);

while(*extlist && !is_space(*extlist) && *eptr && *extlist == *eptr) {

extlist++;

eptr++;

}

if((!*extlist || is_space(*extlist)) && !*eptr) {

return 1;

}

while(*extlist && !is_space(*extlist)) extlist++;

}

return 0;

}

int glutExtensionSupported(const char *ext)

{

const char *str;

if((str = (const char*)glGetString(GL_EXTENSIONS)) && match_ext(str, ext)) {

return 1;

}

return wsys_extension_supported(ext);

}

/* --------------- UNIX/X11 implementation ----------------- */

#ifdef BUILD_X11

enum {

SPNAV_EVENT_ANY, /* used by spnav_remove_events() */

SPNAV_EVENT_MOTION,

SPNAV_EVENT_BUTTON /* includes both press and release */

};

struct spnav_event_motion {

int type;

int x, y, z;

int rx, ry, rz;

unsigned int period;

int *data;

};

struct spnav_event_button {

int type;

int press;

int bnum;

};

union spnav_event {

int type;

struct spnav_event_motion motion;

struct spnav_event_button button;

};

static void handle_event(XEvent *ev);

static int spnav_window(Window win);

static int spnav_event(const XEvent *xev, union spnav_event *event);

static int spnav_remove_events(int type);

typedef void (*glx_swap_interval_ext_func)(Display*, GLXDrawable, int);

typedef int (*glx_swap_interval_mesa_func)(unsigned int);

typedef int (*glx_swap_interval_sgi_func)(int);

static glx_swap_interval_ext_func glx_swap_interval_ext;

static glx_swap_interval_mesa_func glx_swap_interval_mesa;

static glx_swap_interval_sgi_func glx_swap_interval_sgi;

void glutMainLoopEvent(void)

{

XEvent ev;

if(!cb_display) {

panic("display callback not set");

}

if(!upd_pending && !cb_idle) {

XNextEvent(dpy, &ev);

handle_event(&ev);

if(quit) goto end;

}

while(XPending(dpy)) {

XNextEvent(dpy, &ev);

handle_event(&ev);

if(quit) goto end;

}

if(cb_idle) {

cb_idle();

}

if(upd_pending && mapped) {

upd_pending = 0;

cb_display();

}

end:

if(quit) {

cleanup();

}

}

static void cleanup(void)

{

if(win) {

spnav_window(root);

glXMakeCurrent(dpy, 0, 0);

XDestroyWindow(dpy, win);

}

}

static KeySym translate_keysym(KeySym sym)

{

switch(sym) {

case XK_Escape:

return 27;

case XK_BackSpace:

return '\b';

case XK_Linefeed:

return '\r';

case XK_Return:

return '\r';

case XK_Delete:

return 127;

case XK_Tab:

return '\t';

default:

break;

}

return sym;

}

static void handle_event(XEvent *ev)

{

KeySym sym;

union spnav_event sev;

switch(ev->type) {

case MapNotify:

mapped = 1;

break;

case UnmapNotify:

mapped = 0;

break;

case ConfigureNotify:

if(cb_reshape && (ev->xconfigure.width != win_width || ev->xconfigure.height != win_height)) {

win_width = ev->xconfigure.width;

win_height = ev->xconfigure.height;

cb_reshape(ev->xconfigure.width, ev->xconfigure.height);

}

break;

case ClientMessage:

if(ev->xclient.message_type == xa_wm_proto) {

if(ev->xclient.data.l[0] == xa_wm_del_win) {

quit = 1;

}

}

if(spnav_event(ev, &sev)) {

switch(sev.type) {

case SPNAV_EVENT_MOTION:

if(cb_sball_motion) {

cb_sball_motion(sev.motion.x, sev.motion.y, sev.motion.z);

}

if(cb_sball_rotate) {

cb_sball_rotate(sev.motion.rx, sev.motion.ry, sev.motion.rz);

}

spnav_remove_events(SPNAV_EVENT_MOTION);

break;

case SPNAV_EVENT_BUTTON:

if(cb_sball_button) {

cb_sball_button(sev.button.bnum + 1, sev.button.press ? GLUT_DOWN : GLUT_UP);

}

break;

default:

break;

}

}

break;

case Expose:

upd_pending = 1;

break;

case KeyPress:

if(0) {

case KeyRelease:

if(ignore_key_repeat && XEventsQueued(dpy, QueuedAfterReading)) {

XEvent next;

XPeekEvent(dpy, &next);

if(next.type == KeyPress && next.xkey.keycode == ev->xkey.keycode &&

next.xkey.time == ev->xkey.time) {

/* this is a key-repeat event, ignore the release and consume

* the following press

*/

XNextEvent(dpy, &next);

break;

}

}

}

modstate = ev->xkey.state & (ShiftMask | ControlMask | Mod1Mask);

if(!(sym = XLookupKeysym(&ev->xkey, 0))) {

break;

}

sym = translate_keysym(sym);

if(sym < 256) {

if(ev->type == KeyPress) {

if(cb_keydown) cb_keydown((unsigned char)sym, ev->xkey.x, ev->xkey.y);

} else {

if(cb_keyup) cb_keyup((unsigned char)sym, ev->xkey.x, ev->xkey.y);

}

} else {

if(ev->type == KeyPress) {

if(cb_skeydown) cb_skeydown(sym, ev->xkey.x, ev->xkey.y);

} else {

if(cb_skeyup) cb_skeyup(sym, ev->xkey.x, ev->xkey.y);

}

}

break;

case ButtonPress:

case ButtonRelease:

modstate = ev->xbutton.state & (ShiftMask | ControlMask | Mod1Mask);

if(cb_mouse) {

int bn = ev->xbutton.button - Button1;

cb_mouse(bn, ev->type == ButtonPress ? GLUT_DOWN : GLUT_UP,

ev->xbutton.x, ev->xbutton.y);

}

break;

case MotionNotify:

if(ev->xmotion.state & (Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask)) {

if(cb_motion) cb_motion(ev->xmotion.x, ev->xmotion.y);

} else {

if(cb_passive) cb_passive(ev->xmotion.x, ev->xmotion.y);

}

break;

case VisibilityNotify:

if(cb_vis) {

cb_vis(ev->xvisibility.state == VisibilityFullyObscured ? GLUT_NOT_VISIBLE : GLUT_VISIBLE);

}

break;

case EnterNotify:

if(cb_entry) cb_entry(GLUT_ENTERED);

break;

case LeaveNotify:

if(cb_entry) cb_entry(GLUT_LEFT);

break;

}

}

void glutSwapBuffers(void)

{

glXSwapBuffers(dpy, win);

}

/* BUG:

* set_fullscreen_mwm removes the decorations with MotifWM hints, and then it

* needs to resize the window to make it fullscreen. The way it does this is by

* querying the size of the root window (see get_screen_size), which in the

* case of multi-monitor setups will be the combined size of all monitors.

* This is problematic; the way to solve it is to use the XRandR extension, or

* the Xinerama extension, to figure out the dimensions of the correct video

* output, which would add potentially two extension support libraries to our

* dependencies list.

* Moreover, any X installation modern enough to support XR&R will almost

* certainly be running a window manager supporting the EHWM

* _NET_WM_STATE_FULLSCREEN method (set_fullscreen_ewmh), which does not rely

* on manual resizing, and is used in preference if available, making this

* whole endeavor pointless.

* So I'll just leave it with set_fullscreen_mwm covering the entire

* multi-monitor area for now.

*/

struct mwm_hints {

unsigned long flags;

unsigned long functions;

unsigned long decorations;

long input_mode;

unsigned long status;

};

#define MWM_HINTS_DECORATIONS 2

#define MWM_DECOR_ALL 1

static void set_fullscreen_mwm(int fs)

{

struct mwm_hints hints;

int scr_width, scr_height;

if(fs) {

get_window_pos(&prev_win_x, &prev_win_y);

get_window_size(&prev_win_width, &prev_win_height);

get_screen_size(&scr_width, &scr_height);

hints.decorations = 0;

hints.flags = MWM_HINTS_DECORATIONS;

XChangeProperty(dpy, win, xa_motif_wm_hints, xa_motif_wm_hints, 32,

PropModeReplace, (unsigned char*)&hints, 5);

XMoveResizeWindow(dpy, win, 0, 0, scr_width, scr_height);

} else {

XDeleteProperty(dpy, win, xa_motif_wm_hints);

XMoveResizeWindow(dpy, win, prev_win_x, prev_win_y, prev_win_width, prev_win_height);

}

}

static int have_netwm_fullscr(void)

{

int fmt;

long offs = 0;

unsigned long i, count, rem;

Atom *prop, type;

Atom xa_net_supported = XInternAtom(dpy, "_NET_SUPPORTED", False);

do {

XGetWindowProperty(dpy, root, xa_net_supported, offs, 8, False, AnyPropertyType,

&type, &fmt, &count, &rem, (unsigned char**)&prop);

for(i=0; i<count; i++) {

if(prop[i] == xa_net_wm_state_fullscr) {

XFree(prop);

return 1;

}

}

XFree(prop);

offs += count;

} while(rem > 0);

return 0;

}

static void set_fullscreen_ewmh(int fs)

{

XClientMessageEvent msg = {0};

msg.type = ClientMessage;

msg.window = win;

msg.message_type = xa_net_wm_state; /* _NET_WM_STATE */

msg.format = 32;

msg.data.l[0] = fs ? 1 : 0;

msg.data.l[1] = xa_net_wm_state_fullscr; /* _NET_WM_STATE_FULLSCREEN */

msg.data.l[2] = 0;

msg.data.l[3] = 1; /* source regular application */

XSendEvent(dpy, root, False, SubstructureNotifyMask | SubstructureRedirectMask, (XEvent*)&msg);

}

static void set_fullscreen(int fs)

{

if(fullscreen == fs) return;

if(xa_net_wm_state && xa_net_wm_state_fullscr) {

set_fullscreen_ewmh(fs);

fullscreen = fs;

} else if(xa_motif_wm_hints) {

set_fullscreen_mwm(fs);

fullscreen = fs;

}

}

void glutPositionWindow(int x, int y)

{

set_fullscreen(0);

XMoveWindow(dpy, win, x, y);

}

void glutReshapeWindow(int xsz, int ysz)

{

set_fullscreen(0);

XResizeWindow(dpy, win, xsz, ysz);

}

void glutFullScreen(void)

{

set_fullscreen(1);

}

void glutSetWindowTitle(const char *title)

{

XTextProperty tprop;

if(!XStringListToTextProperty((char**)&title, 1, &tprop)) {

return;

}

XSetWMName(dpy, win, &tprop);

XFree(tprop.value);

}

void glutSetIconTitle(const char *title)

{

XTextProperty tprop;

if(!XStringListToTextProperty((char**)&title, 1, &tprop)) {

return;

}

XSetWMIconName(dpy, win, &tprop);

XFree(tprop.value);

}

void glutSetCursor(int cidx)

{

Cursor cur = None;

switch(cidx) {

case GLUT_CURSOR_LEFT_ARROW:

cur = XCreateFontCursor(dpy, XC_left_ptr);

break;

case GLUT_CURSOR_INHERIT:

break;

case GLUT_CURSOR_NONE:

cur = blank_cursor;

break;

default:

return;

}

XDefineCursor(dpy, win, cur);

cur_cursor = cidx;

}

void glutWarpPointer(int x, int y)

{

XWarpPointer(dpy, None, win, 0, 0, 0, 0, x, y);

}

void glutSetColor(int idx, float r, float g, float b)

{

XColor color;

if(idx >= 0 && idx < cmap_size) {

color.pixel = idx;

color.red = (unsigned short)(r * 65535.0f);

color.green = (unsigned short)(g * 65535.0f);

color.blue = (unsigned short)(b * 65535.0f);

color.flags = DoRed | DoGreen | DoBlue;

XStoreColor(dpy, cmap, &color);

}

}

float glutGetColor(int idx, int comp)

{

XColor color;

if(idx < 0 || idx >= cmap_size) {

return -1.0f;

}

color.pixel = idx;

XQueryColor(dpy, cmap, &color);

switch(comp) {

case GLUT_RED:

return color.red / 65535.0f;

case GLUT_GREEN:

return color.green / 65535.0f;

case GLUT_BLUE:

return color.blue / 65535.0f;

default:

break;

}

return -1.0f;

}

void glutSetKeyRepeat(int repmode)

{

if(repmode) {

XAutoRepeatOn(dpy);

} else {

XAutoRepeatOff(dpy);

}

}

void glutSwapInterval(int n)

{

if(n < 0 && !have_swap_control_tear) {

n = -n;

}

if(glx_swap_interval_ext) {

glx_swap_interval_ext(dpy, win, n);

} else if(glx_swap_interval_mesa) {

glx_swap_interval_mesa(n);

} else if(glx_swap_interval_sgi) {

glx_swap_interval_sgi(n < 1 ? 1 : n);

}

}

static XVisualInfo *choose_visual(unsigned int mode)

{

XVisualInfo *vi;

int attr[32];

int *aptr = attr;

int *samples = 0;

if(mode & GLUT_DOUBLE) {

*aptr++ = GLX_DOUBLEBUFFER;

}

if(mode & GLUT_INDEX) {

*aptr++ = GLX_BUFFER_SIZE;

*aptr++ = 1;

} else {

*aptr++ = GLX_RGBA;

*aptr++ = GLX_RED_SIZE; *aptr++ = 1;

*aptr++ = GLX_GREEN_SIZE; *aptr++ = 1;

*aptr++ = GLX_BLUE_SIZE; *aptr++ = 1;

}

if(mode & GLUT_ALPHA) {

*aptr++ = GLX_ALPHA_SIZE;

*aptr++ = 4;

}

if(mode & GLUT_DEPTH) {

*aptr++ = GLX_DEPTH_SIZE;

*aptr++ = 8;

}

if(mode & GLUT_STENCIL) {

*aptr++ = GLX_STENCIL_SIZE;

*aptr++ = 1;

}

if(mode & GLUT_ACCUM) {

*aptr++ = GLX_ACCUM_RED_SIZE; *aptr++ = 1;

*aptr++ = GLX_ACCUM_GREEN_SIZE; *aptr++ = 1;

*aptr++ = GLX_ACCUM_BLUE_SIZE; *aptr++ = 1;

}