[DRE-commits] r4123 - in branches/upstream: . libopengl-ruby libopengl-ruby/current
Paul van Tilburg
paulvt at alioth.debian.org
Sat Sep 12 08:53:19 UTC 2009
Author: paulvt
Date: 2009-09-12 08:53:18 +0000 (Sat, 12 Sep 2009)
New Revision: 4123
Added:
branches/upstream/libopengl-ruby/
branches/upstream/libopengl-ruby/current/
branches/upstream/libopengl-ruby/current/glut.c
Log:
[svn-inject] Installing original source of libopengl-ruby
Added: branches/upstream/libopengl-ruby/current/glut.c
===================================================================
--- branches/upstream/libopengl-ruby/current/glut.c (rev 0)
+++ branches/upstream/libopengl-ruby/current/glut.c 2009-09-12 08:53:18 UTC (rev 4123)
@@ -0,0 +1,1545 @@
+/*
+ * $Date: 2004/03/02 01:13:06 $
+ * $Author: yoshi $
+ */
+#if defined(WIN32)
+# include "windows.h"
+#endif
+#include "GL/glut.h"
+#include "ruby.h"
+
+static int callId; /* 'call' method id */
+
+/* callback define macro */
+#define WINDOW_CALLBACK_SETUP(_funcname) \
+static VALUE _funcname = Qnil; \
+static void glut_ ## _funcname ## Callback(); \
+static VALUE \
+glut_ ## _funcname(obj,arg1) \
+VALUE obj,arg1; \
+{ \
+ int win; \
+ if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1)) \
+ rb_raise(rb_eTypeError, "GLUT.%s:%s",#_funcname, rb_class2name(CLASS_OF(arg1))); \
+ win = glutGetWindow(); \
+ if (win == 0) \
+ rb_raise(rb_eRuntimeError, "GLUT.%s needs current window", #_funcname); \
+ rb_ary_store(_funcname, win, arg1); \
+ glut ## _funcname(glut_ ## _funcname ## Callback); \
+ return Qnil; \
+}
+
+#define WINDOW_CALLBACK_DEFINE(_funcname) \
+ rb_define_module_function(mGLUT, # _funcname, glut_ ## _funcname , 1); \
+ rb_global_variable(&_funcname); \
+ _funcname = rb_ary_new()
+
+/*
+ * GLUT Implementation
+ */
+/* GLUT initialization sub-API. */
+static VALUE g_arg_array;
+
+static VALUE
+glut_Init(argc, argv, obj)
+int argc;
+VALUE* argv;
+VALUE obj;
+{
+#if 0
+ int argcp = 1;
+ if (TYPE(arg1) != T_STRING)
+ rb_raise(rb_eTypeError, "GLUT.Init:%s", rb_class2name(CLASS_OF(arg1)));
+ glutInit(&argcp, (char**)&(RSTRING(arg1)->ptr));
+#endif
+ int largc;
+ char** largv;
+ int i, j;
+ int find;
+ VALUE new_argv;
+ VALUE arg1;
+ VALUE ptr;
+ if (rb_scan_args(argc, argv, "01", &arg1) == 0) {
+ arg1 = rb_eval_string("ARGV");
+ }
+ Check_Type(arg1, T_ARRAY);
+ largc = RARRAY(arg1)->len+1;
+ largv = ALLOCA_N(char*, largc+2);
+ largv[0] = STR2CSTR(rb_eval_string("$0"));
+ for (i = 1; i < largc; i++) {
+ largv[i] = STR2CSTR(RARRAY(arg1)->ptr[i-1]);
+ }
+ largv[i] = NULL;
+ glutInit(&largc, largv);
+ new_argv = rb_ary_new2(largc-1);
+ g_arg_array = rb_ary_new();
+ for (i = 0; i < RARRAY(arg1)->len; i++) {
+ ptr = RARRAY(arg1)->ptr[i];
+ find = 0;
+ for (j = 1; largv[j]; j++) {
+ if (STR2CSTR(ptr) == largv[j]) {
+ rb_ary_push(new_argv, ptr);
+ find = 1;
+ break;
+ }
+ }
+ if (!find) {
+ rb_ary_push(g_arg_array, ptr);
+ }
+ }
+ return new_argv;
+}
+
+static VALUE
+glut_InitDisplayMode(obj,arg1)
+VALUE obj,arg1;
+{
+ unsigned int mode;
+ mode = (unsigned int)NUM2INT(arg1);
+ glutInitDisplayMode(mode);
+ return Qnil;
+}
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+static VALUE
+glut_InitDisplayString(obj,arg1)
+VALUE obj,arg1;
+{
+ if (TYPE(arg1) != T_STRING)
+ rb_raise(rb_eTypeError, "GLUT.InitDisplay:%s",rb_class2name(CLASS_OF(arg1)));
+ glutInitDisplayString(RSTRING(arg1)->ptr);
+ return Qnil;
+}
+#endif
+
+static VALUE
+glut_InitWindowPosition(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int x,y;
+ x = NUM2INT(arg1);
+ y = NUM2INT(arg2);
+ glutInitWindowPosition(x,y);
+ return Qnil;
+}
+
+static VALUE
+glut_InitWindowSize(obj, arg1, arg2)
+VALUE obj,arg1,arg2;
+{
+ int width,height;
+ width = NUM2INT(arg1);
+ height = NUM2INT(arg2);
+ glutInitWindowSize(width,height);
+ return Qnil;
+}
+
+static VALUE
+glut_MainLoop(obj)
+VALUE obj;
+{
+ glutMainLoop();
+ return Qnil;
+}
+
+WINDOW_CALLBACK_SETUP(DisplayFunc);
+WINDOW_CALLBACK_SETUP(ReshapeFunc);
+WINDOW_CALLBACK_SETUP(KeyboardFunc);
+WINDOW_CALLBACK_SETUP(MouseFunc);
+WINDOW_CALLBACK_SETUP(MotionFunc);
+WINDOW_CALLBACK_SETUP(PassiveMotionFunc);
+WINDOW_CALLBACK_SETUP(EntryFunc);
+WINDOW_CALLBACK_SETUP(VisibilityFunc);
+/*
+CALLBACK_DEFINE(IdleFunc);
+CALLBACK_DEFINE(TimerFunc);
+MENU_CALLBACK_DEFINE(MenuStateFunc);
+*/
+WINDOW_CALLBACK_SETUP(SpecialFunc);
+WINDOW_CALLBACK_SETUP(SpaceballMotionFunc);
+WINDOW_CALLBACK_SETUP(SpaceballRotateFunc);
+WINDOW_CALLBACK_SETUP(SpaceballButtonFunc);
+WINDOW_CALLBACK_SETUP(ButtonBoxFunc);
+WINDOW_CALLBACK_SETUP(DialsFunc);
+WINDOW_CALLBACK_SETUP(TabletMotionFunc);
+WINDOW_CALLBACK_SETUP(TabletButtonFunc);
+/*
+MENU_CALLBACK_DEFINE(MenuStatusFunc);
+*/
+WINDOW_CALLBACK_SETUP(OverlayDisplayFunc);
+WINDOW_CALLBACK_SETUP(WindowStatusFunc);
+
+/* GLUT window sub-API. */
+static VALUE
+glut_CreateWindow(argc, argv, obj)
+int argc;
+VALUE* argv;
+VALUE obj;
+{
+ int ret;
+ VALUE title;
+ rb_scan_args(argc, argv, "01", &title);
+ if (argc == 0)
+ title = rb_eval_string("$0");
+ if (TYPE(title) != T_STRING)
+ rb_raise(rb_eTypeError, "GLUT.CreateWindow:%s", rb_class2name(CLASS_OF(title)));
+ ret = glutCreateWindow(RSTRING(title)->ptr);
+
+ /* setup callback */
+/*
+ glutDisplayFunc(glut_DisplayFuncCallback);
+ glutReshapeFunc(glut_ReshapeFuncCallback);
+ glutKeyboardFunc(glut_KeyboardFuncCallback);
+ glutMouseFunc(glut_MouseFuncCallback);
+ glutMotionFunc(glut_MotionFuncCallback);
+ glutPassiveMotionFunc(glut_PassiveMotionFuncCallback);
+ glutEntryFunc(glut_EntryFuncCallback);
+ glutVisibilityFunc(glut_VisibilityFuncCallback);
+ glutSpecialFunc(glut_SpecialFuncCallback);
+ glutSpaceballMotionFunc(glut_SpaceballMotionFuncCallback);
+ glutSpaceballRotateFunc(glut_SpaceballRotateFuncCallback);
+ glutSpaceballButtonFunc(glut_SpaceballButtonFuncCallback);
+ glutButtonBoxFunc(glut_ButtonBoxFuncCallback);
+ glutDialsFunc(glut_DialsFuncCallback);
+ glutTabletMotionFunc(glut_TabletMotionFuncCallback);
+ glutTabletButtonFunc(glut_TabletButtonFuncCallback);
+ glutOverlayDisplayFunc(glut_OverlayDisplayFuncCallback);
+ glutWindowStatusFunc(glut_WindowStatusFuncCallback);
+*/
+ return INT2NUM(ret);
+}
+
+static VALUE
+glut_CreateSubWindow(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+ int win, x, y, width, height;
+ int ret;
+ win = NUM2INT(arg1);
+ x = NUM2INT(arg2);
+ y = NUM2INT(arg3);
+ width = NUM2INT(arg4);
+ height = NUM2INT(arg5);
+ ret = glutCreateSubWindow(win, x, y, width, height);
+ return INT2NUM(ret);
+}
+
+static VALUE
+glut_DestroyWindow(obj,arg1)
+VALUE obj,arg1;
+{
+ int win;
+ win = NUM2INT(arg1);
+ glutDestroyWindow(win);
+ return Qnil;
+}
+
+static VALUE
+glut_PostRedisplay(obj)
+VALUE obj;
+{
+ glutPostRedisplay();
+ return Qnil;
+}
+
+static VALUE
+glut_SwapBuffers(obj)
+VALUE obj;
+{
+ glutSwapBuffers();
+ return Qnil;
+}
+
+static VALUE
+glut_GetWindow(obj)
+VALUE obj;
+{
+ int ret;
+ ret = glutGetWindow();
+ return INT2NUM(ret);
+}
+
+static VALUE
+glut_SetWindow(obj,arg1)
+VALUE obj,arg1;
+{
+ int win;
+ win = NUM2INT(arg1);
+ glutSetWindow(win);
+ return Qnil;
+}
+
+static VALUE
+glut_SetWindowTitle(obj,arg1)
+VALUE obj,arg1;
+{
+ if (TYPE(arg1) != T_STRING)
+ rb_raise(rb_eTypeError, "GLUT.SetWindowTitle:%s", rb_class2name(CLASS_OF(arg1)));
+ glutSetWindowTitle(RSTRING(arg1)->ptr);
+ return Qnil;
+}
+
+static VALUE
+glut_SetIconTitle(obj, arg1)
+VALUE obj,arg1;
+{
+ if (TYPE(arg1) != T_STRING)
+ rb_raise(rb_eTypeError, "GLUT.IconTitle:%s", rb_class2name(CLASS_OF(arg1)));
+ glutSetIconTitle(RSTRING(arg1)->ptr);
+ return Qnil;
+}
+
+static VALUE
+glut_PositionWindow(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int x,y;
+ x = NUM2INT(arg1);
+ y = NUM2INT(arg2);
+ glutPositionWindow(x,y);
+ return Qnil;
+}
+
+static VALUE
+glut_ReshapeWindow(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int width,height;
+ width = NUM2INT(arg1);
+ height = NUM2INT(arg2);
+ glutReshapeWindow(width, height);
+ return Qnil;
+}
+
+static VALUE
+glut_PopWindow(obj)
+VALUE obj;
+{
+ glutPopWindow();
+ return Qnil;
+}
+
+static VALUE
+glut_PushWidow(obj)
+VALUE obj;
+{
+ glutPushWindow();
+ return Qnil;
+}
+
+static VALUE
+glut_IconifyWindow(obj)
+VALUE obj;
+{
+ glutIconifyWindow();
+ return Qnil;
+}
+
+static VALUE
+glut_ShowWindow(obj)
+VALUE obj;
+{
+ glutShowWindow();
+ return Qnil;
+}
+
+static VALUE
+glut_HideWindow(obj)
+VALUE obj;
+{
+ glutHideWindow();
+ return Qnil;
+}
+
+#if (GLUT_API_VERSION >= 3)
+static VALUE
+glut_FullScreen(obj)
+VALUE obj;
+{
+ glutFullScreen();
+ return Qnil;
+}
+
+static VALUE
+glut_SetCurcor(obj,arg1)
+VALUE obj,arg1;
+{
+ int cursor;
+ cursor = NUM2INT(arg1);
+ glutSetCursor(cursor);
+ return Qnil;
+}
+
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+static VALUE
+glut_WarpPointer(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int x,y;
+ x = NUM2INT(arg1);
+ y = NUM2INT(arg2);
+ glutWarpPointer(x,y);
+ return Qnil;
+}
+#endif
+
+/* GLUT overlay sub-API. */
+static VALUE
+glut_EstablishOverlay(obj)
+VALUE obj;
+{
+ glutEstablishOverlay();
+ return Qnil;
+}
+
+static VALUE
+glut_RemoveOverlay(obj)
+VALUE obj;
+{
+ glutRemoveOverlay();
+ return Qnil;
+}
+
+static VALUE
+glut_UseLayer(obj,arg1)
+{
+ GLenum layer;
+ layer = (GLenum)NUM2INT(arg1);
+ glutUseLayer(layer);
+ return Qnil;
+}
+
+static VALUE
+glut_PostOverlayRedisplay(obj)
+VALUE obj;
+{
+ glutPostOverlayRedisplay();
+ return Qnil;
+}
+
+static VALUE
+glut_ShowOverlay(obj)
+VALUE obj;
+{
+ glutShowOverlay();
+ return Qnil;
+}
+
+static VALUE
+glut_HideOverlay(obj)
+VALUE obj;
+{
+ glutHideOverlay();
+ return Qnil;
+}
+#endif
+
+/* GLUT menu sub-API. */
+static VALUE g_menucallback = Qnil;
+static VALUE g_menuargs = Qnil;
+static void
+glut_CreateMenuCallback(value)
+int value;
+{
+ VALUE arg_pair;
+ VALUE func;
+ arg_pair = (VALUE)value;
+ func = rb_hash_aref(g_menucallback, rb_ary_entry(arg_pair, 0));
+ rb_funcall(func, callId, 1, rb_ary_entry(arg_pair, 1));
+}
+
+static VALUE
+glut_CreateMenu(obj,arg1)
+VALUE obj,arg1;
+{
+ int menu;
+ VALUE ret;
+ if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1))
+ rb_raise(rb_eTypeError, "GLUT.CreateMenu:%s", rb_class2name(CLASS_OF(arg1)));
+ menu = glutCreateMenu(glut_CreateMenuCallback);
+ ret = INT2FIX(menu);
+ rb_hash_aset(g_menucallback, ret, arg1);
+ rb_hash_aset(g_menuargs, ret, rb_ary_new());
+ return ret;
+}
+
+static VALUE
+glut_DestroyMenu(obj,arg1)
+VALUE obj,arg1;
+{
+ int menu;
+ menu = INT2FIX(arg1);
+ glutDestroyMenu(menu);
+ rb_hash_aset(g_menucallback, menu, Qnil);
+ rb_hash_aset(g_menuargs, menu, Qnil);
+ return Qnil;
+}
+
+static VALUE
+glut_GetMenu(obj)
+VALUE obj;
+{
+ int ret;
+ ret = glutGetMenu();
+ return INT2NUM(ret);
+}
+
+static VALUE
+glut_SetMenu(obj,arg1)
+VALUE obj,arg1;
+{
+ int menu;
+ menu = NUM2INT(arg1);
+ glutSetMenu(menu);
+ return Qnil;
+}
+
+static VALUE
+glut_AddMenuEntry(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int value;
+ int curmenuid;
+ VALUE arg_ary;
+ VALUE arg_pair;
+ if (TYPE(arg1) != T_STRING) rb_raise(rb_eTypeError, "GLUT.AddMenuEntry:%s",
+ rb_class2name(CLASS_OF(arg1)));
+ curmenuid = glutGetMenu();
+ if (curmenuid == 0) {
+ rb_raise(rb_eRuntimeError, "GLUT.AddMenuEntry needs current menu");
+ }
+ arg_ary = rb_hash_aref(g_menuargs, INT2FIX(curmenuid));
+ arg_pair = rb_ary_new2(2);
+ rb_ary_store(arg_pair, 0, INT2FIX(curmenuid));
+ rb_ary_store(arg_pair, 1, arg2);
+ rb_ary_push(arg_ary, arg_pair);
+ glutAddMenuEntry(RSTRING(arg1)->ptr, arg_pair);
+ return Qnil;
+}
+
+static VALUE
+glut_AddSubMenu(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int value;
+ if (TYPE(arg1) != T_STRING) rb_raise(rb_eTypeError, "GLUT.AddSubMenu:%s",
+ rb_class2name(CLASS_OF(arg1)));
+ value = NUM2INT(arg2);
+ glutAddSubMenu(RSTRING(arg1)->ptr, value);
+ return Qnil;
+}
+
+static VALUE
+glut_ChangeToMenuEntry(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+ VALUE arg_ary;
+ VALUE arg_pair;
+ int item,value;
+ int curmenuid;
+ item = NUM2INT(arg1);
+ if (TYPE(arg2) != T_STRING) rb_raise(rb_eTypeError, "GLUT.ChangeToMenuEntry:%s",
+ rb_class2name(CLASS_OF(arg1)));
+ curmenuid = glutGetMenu();
+ if (curmenuid == 0) {
+ rb_raise(rb_eRuntimeError, "GLUT.ChangeToMenuEntry needs current menu");
+ }
+ arg_ary = rb_hash_aref(g_menuargs, INT2FIX(curmenuid));
+ arg_pair = rb_ary_new2(2);
+ rb_ary_store(arg_pair, 0, INT2FIX(curmenuid));
+ rb_ary_store(arg_pair, 1, arg2);
+ rb_ary_store(arg_ary, item, arg_pair);
+ glutChangeToMenuEntry(item, RSTRING(arg2)->ptr, arg_pair);
+ return Qnil;
+}
+
+static VALUE
+glut_ChangeToSubMenu(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+ int item,submenu;
+ item = NUM2INT(arg1);
+ submenu = NUM2INT(arg3);
+ if (TYPE(arg2) != T_STRING) rb_raise(rb_eTypeError, "GLUT.ChangeToSubMenu:%s",
+ rb_class2name(CLASS_OF(arg1)));
+ glutChangeToSubMenu(item, RSTRING(arg2)->ptr, submenu);
+ return Qnil;
+}
+
+static VALUE
+glut_RemoveMenuItem(obj,arg1)
+VALUE obj,arg1;
+{
+ int item;
+ int curmenuid;
+ VALUE arg_ary;
+ item = NUM2INT(arg1);
+ glutRemoveMenuItem(item);
+ curmenuid = glutGetMenu();
+ if (curmenuid == 0) {
+ rb_raise(rb_eRuntimeError, "GLUT.RemoveMenuItem needs current menu");
+ }
+ arg_ary = rb_hash_aref(g_menuargs, INT2FIX(curmenuid));
+ rb_ary_delete(arg_ary, item);
+ return Qnil;
+}
+
+static VALUE
+glut_AttachMenu(obj,arg1)
+VALUE obj, arg1;
+{
+ int button;
+ button = NUM2INT(arg1);
+ glutAttachMenu(button);
+ return Qnil;
+}
+
+static VALUE
+glut_DetachMenu(obj,arg1)
+VALUE obj, arg1;
+{
+ int button;
+ button = NUM2INT(arg1);
+ glutDetachMenu(button);
+ return Qnil;
+}
+
+/* GLUT sub-API. */
+static void
+glut_DisplayFuncCallback(void)
+{
+ VALUE func;
+ func = rb_ary_entry(DisplayFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 0);
+}
+
+static void
+glut_ReshapeFuncCallback(width, height)
+int width, height;
+{
+ VALUE func;
+ func = rb_ary_entry(ReshapeFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2, INT2FIX(width), INT2FIX(height));
+}
+
+static void
+glut_KeyboardFuncCallback(key, x, y)
+unsigned char key;
+int x,y;
+{
+ VALUE func;
+ func = rb_ary_entry(KeyboardFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 3, INT2FIX(key), INT2FIX(x), INT2FIX(y));
+}
+
+static void
+glut_MouseFuncCallback(button, state, x, y)
+int button, state, x, y;
+{
+ VALUE func;
+ func = rb_ary_entry(MouseFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 4, INT2FIX(button), INT2FIX(state), INT2FIX(x), INT2FIX(y));
+}
+
+static void
+glut_MotionFuncCallback(x, y)
+int x, y;
+{
+ VALUE func;
+ func = rb_ary_entry(MotionFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2,INT2FIX(x), INT2FIX(y));
+}
+
+static void
+glut_PassiveMotionFuncCallback(x, y)
+int x, y;
+{
+ VALUE func;
+ func = rb_ary_entry(PassiveMotionFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2,INT2FIX(x), INT2FIX(y));
+}
+
+static void
+glut_EntryFuncCallback(state)
+int state;
+{
+ VALUE func;
+ func = rb_ary_entry(EntryFunc,glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 1, INT2NUM(state));
+}
+
+static void
+glut_VisibilityFuncCallback(state)
+int state;
+{
+ VALUE func;
+ func = rb_ary_entry(VisibilityFunc,glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 1, INT2NUM(state));
+}
+
+static VALUE idle_func = Qnil;
+static void
+glut_IdleFuncCallback()
+{
+ if (!NIL_P(idle_func))
+ rb_funcall(idle_func, callId, 0);
+}
+static VALUE
+glut_IdleFunc(obj, arg1)
+VALUE obj,arg1;
+{
+ if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1))
+ rb_raise(rb_eTypeError, "glutIdleFunc:%s", rb_class2name(CLASS_OF(arg1)));
+ idle_func = arg1;
+ glutIdleFunc(glut_IdleFuncCallback);
+ return Qnil;
+}
+
+static VALUE timer_func = Qnil;
+static void
+glut_TimerFuncCallback(value)
+int value;
+{
+ if (!NIL_P(timer_func))
+ rb_funcall(timer_func, callId, 1, INT2NUM(value));
+}
+
+static VALUE
+glut_TimerFunc(obj, arg1, arg2, arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+ unsigned int millis;
+ int value;
+ millis = (unsigned int)NUM2INT(arg1);
+ value = NUM2INT(arg3);
+ if (!rb_obj_is_kind_of(arg2,rb_cProc))
+ rb_raise(rb_eTypeError, "glutTimerFunc:%s", rb_class2name(CLASS_OF(arg2)));
+ timer_func = arg2;
+ glutTimerFunc(millis, glut_TimerFuncCallback, value);
+ return Qnil;
+}
+
+static VALUE menustate_func = Qnil;
+static void
+glut_MenuStateFuncCallback(state)
+int state;
+{
+ if (!NIL_P(menustate_func))
+ rb_funcall(menustate_func, callId, 1, INT2NUM(state));
+}
+
+static VALUE
+glut_MenuStateFunc(obj, arg1)
+VALUE obj,arg1;
+{
+ if (!rb_obj_is_kind_of(arg1,rb_cProc))
+ rb_raise(rb_eTypeError, "glutMenuStateFunc:%s",
+ rb_class2name(CLASS_OF(arg1)));
+ menustate_func = arg1;
+ glutMenuStateFunc(glut_MenuStateFuncCallback);
+ return Qnil;
+}
+
+#if (GLUT_API_VERSION >= 2)
+static void
+glut_SpecialFuncCallback(key, x, y)
+int key, x, y;
+{
+ VALUE func;
+ func = rb_ary_entry(SpecialFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 3,INT2NUM(key), INT2FIX(x), INT2FIX(y));
+}
+static void
+glut_SpaceballMotionFuncCallback(x, y, z)
+int x,y,z;
+{
+ VALUE func;
+ func = rb_ary_entry(SpaceballMotionFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 3,INT2NUM(x), INT2FIX(y), INT2FIX(z));
+}
+static void
+glut_SpaceballRotateFuncCallback(x, y, z)
+int x,y,z;
+{
+ VALUE func;
+ func = rb_ary_entry(SpaceballRotateFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 3,INT2NUM(x), INT2FIX(y), INT2FIX(z));
+}
+static void
+glut_SpaceballButtonFuncCallback(button, state)
+int button, state;
+{
+ VALUE func;
+ func = rb_ary_entry(SpaceballButtonFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2,INT2NUM(button), INT2NUM(state));
+}
+static void
+glut_ButtonBoxFuncCallback(button, state)
+int button, state;
+{
+ VALUE func;
+ func = rb_ary_entry(ButtonBoxFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2,INT2NUM(button), INT2NUM(state));
+}
+static void
+glut_DialsFuncCallback(dial, value)
+int dial, value;
+{
+ VALUE func;
+ func = rb_ary_entry(DialsFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2,INT2NUM(dial), INT2NUM(value));
+}
+static void
+glut_TabletMotionFuncCallback(x, y)
+int x, y;
+{
+ VALUE func;
+ func = rb_ary_entry(TabletMotionFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 2,INT2NUM(x), INT2NUM(y));
+}
+static void
+glut_TabletButtonFuncCallback(button, state, x, y)
+int button, state, x, y;
+{
+ VALUE func;
+ func = rb_ary_entry(TabletButtonFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, 4, INT2NUM(button), INT2NUM(state), INT2NUM(x), INT2NUM(y));
+}
+#if (GLUT_API_VERSION >= 3)
+/*
+extern void APIENTRY glutMenuStatusFunc(void (*)(int status, int x, int y));
+*/
+static void
+glut_OverlayDisplayFuncCallback()
+{
+ VALUE func;
+ func = rb_ary_entry(OverlayDisplayFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 0);
+}
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+static void
+glut_WindowStatusFuncCallback(state)
+int state;
+{
+ VALUE func;
+ func = rb_ary_entry(OverlayDisplayFunc, glutGetWindow());
+ if (!NIL_P(func))
+ rb_funcall(func, callId, 1, INT2NUM(state));
+}
+#endif
+#endif
+#endif
+
+/* GLUT color index sub-API. */
+static VALUE
+glut_SetColor(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ int set;
+ GLfloat red;
+ GLfloat green;
+ GLfloat blue;
+ set = NUM2INT(arg1);
+ red = (GLfloat)NUM2DBL(arg2);
+ green = (GLfloat)NUM2DBL(arg3);
+ blue = (GLfloat)NUM2DBL(arg4);
+ glutSetColor(set, red, green, blue);
+ return Qnil;
+}
+static VALUE
+glut_GetColor(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int ndx;
+ int component;
+ GLfloat ret;
+ ndx = NUM2INT(arg1);
+ component = NUM2INT(arg2);
+ ret = (GLfloat)glutGetColor(ndx, component);
+ return rb_float_new(ret);
+}
+static VALUE
+glut_CopyColormap(obj,arg1)
+VALUE obj,arg1;
+{
+ int win;
+ win = NUM2INT(arg1);
+ glutCopyColormap(win);
+ return Qnil;
+}
+
+/* GLUT state retrieval sub-API. */
+static VALUE
+glut_Get(obj,arg1)
+VALUE obj,arg1;
+{
+ GLenum type;
+ int ret;
+ type = (GLenum)NUM2INT(arg1);
+ ret = glutGet(type);
+ return INT2NUM(ret);
+}
+static VALUE
+glut_DeviceGet(obj,arg1)
+VALUE obj,arg1;
+{
+ GLenum type;
+ int ret;
+ type = (GLenum)NUM2INT(arg1);
+ ret = glutDeviceGet(type);
+ return INT2NUM(ret);
+}
+#if (GLUT_API_VERSION >= 2)
+/* GLUT extension support sub-API */
+static VALUE
+glut_ExtensionSupported(obj,arg1)
+VALUE obj,arg1;
+{
+ int ret;
+ if (TYPE(arg1) != T_STRING) rb_raise(rb_eTypeError, "glutExtensionSupported:%s",
+ rb_class2name(CLASS_OF(arg1)));
+ ret = glutExtensionSupported(RSTRING(arg1)->ptr);
+ return INT2NUM(ret);
+}
+#endif
+#if (GLUT_API_VERSION >= 3)
+static VALUE
+glut_GetModifiers(obj)
+VALUE obj;
+{
+ int ret;
+ ret = glutGetModifiers();
+ return INT2NUM(ret);
+}
+static VALUE
+glut_LayerGet(obj,arg1)
+VALUE obj,arg1;
+{
+ GLenum type;
+ int ret;
+ type = (GLenum)NUM2INT(arg1);
+ ret = glutLayerGet(type);
+ return INT2NUM(ret);
+}
+#endif
+
+/* GLUT font sub-API */
+static VALUE
+glut_BitmapCharacter(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int font;
+ int character;
+ font = NUM2INT(arg1);
+ character = NUM2INT(arg2);
+ glutBitmapCharacter((void*)font, character);
+ return Qnil;
+}
+static VALUE
+glut_BitmapWidth(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int font;
+ int character;
+ int ret;
+ font = NUM2INT(arg1);
+ character = NUM2INT(arg2);
+ ret = glutBitmapWidth((void*)font, character);
+ return INT2NUM(ret);
+}
+static VALUE
+glut_StrokeCharacter(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int font;
+ int character;
+ font = NUM2INT(arg1);
+ character = NUM2INT(arg2);
+ glutStrokeCharacter((void*)font, character);
+ return Qnil;
+}
+static VALUE
+glut_StrokeWidth(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int font;
+ int character;
+ int ret;
+ font = NUM2INT(arg1);
+ character = NUM2INT(arg2);
+ ret = glutStrokeWidth((void*)font, character);
+ return INT2NUM(ret);
+}
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+static VALUE
+glut_BitmapLength(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int font;
+ int ret;
+ if (TYPE(arg2) != T_STRING) rb_raise(rb_eTypeError, "glutBitmapLength:%s",
+ rb_class2name(CLASS_OF(arg2)));
+ font = NUM2INT(arg1);
+ ret = glutBitmapLength((void *)font, (const unsigned char*)RSTRING(arg2)->ptr);
+ return INT2NUM(ret);
+}
+static VALUE
+glut_StrokeLength(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+ int font;
+ int ret;
+ if (TYPE(arg2) != T_STRING) rb_raise(rb_eTypeError, "glutStrokeLength:%s",
+ rb_class2name(CLASS_OF(arg2)));
+ font = NUM2INT(arg1);
+ ret = glutStrokeLength((void *)font, (const unsigned char*)RSTRING(arg2)->ptr);
+ return INT2NUM(ret);
+}
+#endif
+
+/* GLUT pre-built models sub-API */
+static VALUE
+glut_WireSphere(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+ GLdouble radius;
+ GLint slices;
+ GLint stacks;
+ radius = (GLdouble)NUM2DBL(arg1);
+ slices = (GLint)NUM2INT(arg2);
+ stacks = (GLint)NUM2INT(arg3);
+ glutWireSphere(radius, slices, stacks);
+ return Qnil;
+}
+static VALUE
+glut_SolidSphere(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+ GLdouble radius;
+ GLint slices;
+ GLint stacks;
+ radius = (GLdouble)NUM2DBL(arg1);
+ slices = (GLint)NUM2INT(arg2);
+ stacks = (GLint)NUM2INT(arg3);
+ glutSolidSphere(radius, slices, stacks);
+ return Qnil;
+}
+static VALUE
+glut_WireCone(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ GLdouble base;
+ GLdouble height;
+ GLint slices;
+ GLint stacks;
+ base = (GLdouble)NUM2DBL(arg1);
+ height = (GLdouble)NUM2DBL(arg2);
+ slices = (GLint)NUM2INT(arg3);
+ stacks = (GLint)NUM2INT(arg4);
+ glutWireCone(base, height, slices, stacks);
+ return Qnil;
+}
+static VALUE
+glut_SolidCone(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ GLdouble base;
+ GLdouble height;
+ GLint slices;
+ GLint stacks;
+ base = (GLdouble)NUM2DBL(arg1);
+ height = (GLdouble)NUM2DBL(arg2);
+ slices = (GLint)NUM2INT(arg3);
+ stacks = (GLint)NUM2INT(arg4);
+ glutSolidCone(base, height, slices, stacks);
+ return Qnil;
+}
+static VALUE
+glut_WireCube(obj,arg1)
+VALUE obj,arg1;
+{
+ GLdouble size;
+ size = (GLdouble)NUM2DBL(arg1);
+ glutWireCube(size);
+ return Qnil;
+}
+static VALUE
+glut_SolidCube(obj,arg1)
+VALUE obj,arg1;
+{
+ GLdouble size;
+ size = (GLdouble)NUM2DBL(arg1);
+ glutSolidCube(size);
+ return Qnil;
+}
+static VALUE
+glut_WireTorus(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ GLdouble innerRadius;
+ GLdouble outerRadius;
+ GLint sides;
+ GLint rings;
+ innerRadius = (GLdouble)NUM2DBL(arg1);
+ outerRadius = (GLdouble)NUM2DBL(arg2);
+ sides = (GLint)NUM2INT(arg3);
+ rings = (GLint)NUM2INT(arg4);
+ glutWireTorus(innerRadius, outerRadius, sides, rings);
+ return Qnil;
+}
+static VALUE
+glut_SolidTorus(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ GLdouble innerRadius;
+ GLdouble outerRadius;
+ GLint sides;
+ GLint rings;
+ innerRadius = (GLdouble)NUM2DBL(arg1);
+ outerRadius = (GLdouble)NUM2DBL(arg2);
+ sides = (GLint)NUM2INT(arg3);
+ rings = (GLint)NUM2INT(arg4);
+ glutSolidTorus(innerRadius, outerRadius, sides, rings);
+ return Qnil;
+}
+static VALUE
+glut_WireDodecahedron(obj)
+VALUE obj;
+{
+ glutWireDodecahedron();
+ return Qnil;
+}
+static VALUE
+glut_SolidDodecahedron(obj)
+VALUE obj;
+{
+ glutSolidDodecahedron();
+ return Qnil;
+}
+static VALUE
+glut_WireTeapot(obj,arg1)
+VALUE obj,arg1;
+{
+ GLdouble size;
+ size = (GLdouble)NUM2DBL(arg1);
+ glutWireTeapot(size);
+ return Qnil;
+}
+static VALUE
+glut_SolidTeapot(obj,arg1)
+VALUE obj,arg1;
+{
+ GLdouble size;
+ size = (GLdouble)NUM2DBL(arg1);
+ glutSolidTeapot(size);
+ return Qnil;
+}
+static VALUE
+glut_WireOctahedron(obj)
+VALUE obj;
+{
+ glutWireOctahedron();
+ return Qnil;
+}
+static VALUE
+glut_SolidOctahedron(obj)
+VALUE obj;
+{
+ glutSolidOctahedron();
+ return Qnil;
+}
+static VALUE
+glut_WireTetrahedron(obj)
+VALUE obj;
+{
+ glutWireTetrahedron();
+ return Qnil;
+}
+static VALUE
+glut_SolidTetrahedron(obj)
+VALUE obj;
+{
+ glutSolidTetrahedron();
+ return Qnil;
+}
+static VALUE
+glut_WireIcosahedron(obj)
+VALUE obj;
+{
+ glutWireIcosahedron();
+ return Qnil;
+}
+static VALUE
+glut_SolidIcosahedron(obj)
+VALUE obj;
+{
+ glutSolidIcosahedron();
+ return Qnil;
+}
+#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9)
+/* GLUT video resize sub-API. */
+static VALUE
+glut_VideoResizeGet(obj,arg1)
+VALUE obj,arg1;
+{
+ GLenum param;
+ int ret;
+ param = (GLenum)NUM2INT(arg1);
+ ret = glutVideoResizeGet(param);
+ return INT2NUM(ret);
+}
+static VALUE
+glut_SetupVideoResizing(obj)
+VALUE obj;
+{
+ glutSetupVideoResizing();
+ return Qnil;
+}
+static VALUE
+glut_StopVideoResizing(obj)
+VALUE obj;
+{
+ glutStopVideoResizing();
+ return Qnil;
+}
+static VALUE
+glut_VideoResize(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ int x;
+ int y;
+ int width;
+ int height;
+ x = NUM2INT(arg1);
+ y = NUM2INT(arg2);
+ width = NUM2INT(arg3);
+ height = NUM2INT(arg4);
+ glutVideoResize(x,y, width, height);
+ return Qnil;
+}
+static VALUE
+glut_VideoPan(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+ int x;
+ int y;
+ int width;
+ int height;
+ x = NUM2INT(arg1);
+ y = NUM2INT(arg2);
+ width = NUM2INT(arg3);
+ height = NUM2INT(arg4);
+ glutVideoPan(x,y, width, height);
+ return Qnil;
+}
+
+/* GLUT debugging sub-API. */
+static VALUE
+glut_ReportErrors(obj)
+VALUE obj;
+{
+ glutReportErrors();
+ return Qnil;
+}
+#endif
+
+static VALUE mGLUT;
+
+void
+Init_glut()
+{
+ mGLUT = rb_define_module("GLUT");
+
+ rb_global_variable(&g_arg_array);
+ rb_global_variable(&g_menucallback);
+ rb_global_variable(&g_menuargs);
+ g_menucallback = rb_hash_new();
+ g_menuargs = rb_hash_new();
+
+ rb_define_module_function(mGLUT, "Init", glut_Init, -1);
+ rb_define_module_function(mGLUT, "InitDisplayMode", glut_InitDisplayMode, 1);
+ rb_define_module_function(mGLUT, "InitDisplayString", glut_InitDisplayString, 1);
+ rb_define_module_function(mGLUT, "InitWindowPosition", glut_InitWindowPosition, 2);
+ rb_define_module_function(mGLUT, "InitWindowSize", glut_InitWindowSize, 2);
+ rb_define_module_function(mGLUT, "MainLoop", glut_MainLoop, 0);
+ rb_define_module_function(mGLUT, "CreateWindow", glut_CreateWindow, -1);
+ rb_define_module_function(mGLUT, "CreateSubWindow", glut_CreateSubWindow, 5);
+ rb_define_module_function(mGLUT, "DestroyWindow", glut_DestroyWindow, 1);
+ rb_define_module_function(mGLUT, "PostRedisplay", glut_PostRedisplay, 0);
+ rb_define_module_function(mGLUT, "SwapBuffers", glut_SwapBuffers, 0);
+ rb_define_module_function(mGLUT, "GetWindow", glut_GetWindow, 0);
+ rb_define_module_function(mGLUT, "SetWindow", glut_SetWindow, 1);
+ rb_define_module_function(mGLUT, "SetWindowTitle", glut_SetWindowTitle, 1);
+ rb_define_module_function(mGLUT, "SetIconTitle", glut_SetIconTitle, 1);
+ rb_define_module_function(mGLUT, "PositionWindow", glut_PositionWindow, 2);
+ rb_define_module_function(mGLUT, "ReshapeWindow", glut_ReshapeWindow, 2);
+ rb_define_module_function(mGLUT, "PopWindow", glut_PopWindow, 0);
+ rb_define_module_function(mGLUT, "PushWidow", glut_PushWidow, 0);
+ rb_define_module_function(mGLUT, "IconifyWindow", glut_IconifyWindow, 0);
+ rb_define_module_function(mGLUT, "ShowWindow", glut_ShowWindow, 0);
+ rb_define_module_function(mGLUT, "HideWindow", glut_HideWindow, 0);
+ rb_define_module_function(mGLUT, "FullScreen", glut_FullScreen, 0);
+ rb_define_module_function(mGLUT, "SetCurcor", glut_SetCurcor, 1);
+ rb_define_module_function(mGLUT, "WarpPointer", glut_WarpPointer, 2);
+ rb_define_module_function(mGLUT, "EstablishOverlay", glut_EstablishOverlay, 0);
+ rb_define_module_function(mGLUT, "RemoveOverlay", glut_RemoveOverlay, 0);
+ rb_define_module_function(mGLUT, "UseLayer", glut_UseLayer, 1);
+ rb_define_module_function(mGLUT, "PostOverlayRedisplay", glut_PostOverlayRedisplay, 0);
+ rb_define_module_function(mGLUT, "ShowOverlay", glut_ShowOverlay, 0);
+ rb_define_module_function(mGLUT, "HideOverlay", glut_HideOverlay, 0);
+ rb_define_module_function(mGLUT, "CreateMenu", glut_CreateMenu, 1);
+ rb_define_module_function(mGLUT, "DestroyMenu", glut_DestroyMenu, 1);
+ rb_define_module_function(mGLUT, "GetMenu", glut_GetMenu, 0);
+ rb_define_module_function(mGLUT, "SetMenu", glut_SetMenu, 1);
+ rb_define_module_function(mGLUT, "AddMenuEntry", glut_AddMenuEntry, 2);
+ rb_define_module_function(mGLUT, "AddSubMenu", glut_AddSubMenu, 2);
+ rb_define_module_function(mGLUT, "ChangeToMenuEntry", glut_ChangeToMenuEntry, 3);
+ rb_define_module_function(mGLUT, "ChangeToSubMenu", glut_ChangeToSubMenu, 3);
+ rb_define_module_function(mGLUT, "RemoveMenuItem", glut_RemoveMenuItem, 1);
+ rb_define_module_function(mGLUT, "AttachMenu", glut_AttachMenu, 1);
+ rb_define_module_function(mGLUT, "DetachMenu", glut_DetachMenu, 1);
+
+ rb_define_module_function(mGLUT, "SetColor", glut_SetColor, 4);
+ rb_define_module_function(mGLUT, "GetColor", glut_GetColor, 2);
+ rb_define_module_function(mGLUT, "CopyColormap", glut_CopyColormap, 1);
+ rb_define_module_function(mGLUT, "Get", glut_Get, 1);
+ rb_define_module_function(mGLUT, "DeviceGet", glut_DeviceGet, 1);
+ rb_define_module_function(mGLUT, "ExtensionSupported", glut_ExtensionSupported, 1);
+ rb_define_module_function(mGLUT, "GetModifiers", glut_GetModifiers, 0);
+ rb_define_module_function(mGLUT, "LayerGet", glut_LayerGet, 1);
+ rb_define_module_function(mGLUT, "BitmapCharacter", glut_BitmapCharacter, 2);
+ rb_define_module_function(mGLUT, "BitmapWidth", glut_BitmapWidth, 2);
+ rb_define_module_function(mGLUT, "StrokeCharacter", glut_StrokeCharacter, 2);
+ rb_define_module_function(mGLUT, "StrokeWidth", glut_StrokeWidth, 2);
+ rb_define_module_function(mGLUT, "BitmapLength", glut_BitmapLength, 2);
+ rb_define_module_function(mGLUT, "StrokeLength", glut_StrokeLength, 2);
+ rb_define_module_function(mGLUT, "WireSphere", glut_WireSphere, 3);
+ rb_define_module_function(mGLUT, "SolidSphere", glut_SolidSphere, 3);
+ rb_define_module_function(mGLUT, "WireCone", glut_WireCone, 4);
+ rb_define_module_function(mGLUT, "SolidCone", glut_SolidCone, 4);
+ rb_define_module_function(mGLUT, "WireCube", glut_WireCube, 1);
+ rb_define_module_function(mGLUT, "SolidCube", glut_SolidCube, 1);
+ rb_define_module_function(mGLUT, "WireTorus", glut_WireTorus, 4);
+ rb_define_module_function(mGLUT, "SolidTorus", glut_SolidTorus, 4);
+ rb_define_module_function(mGLUT, "WireDodecahedron", glut_WireDodecahedron, 0);
+ rb_define_module_function(mGLUT, "SolidDodecahedron", glut_SolidDodecahedron, 0);
+ rb_define_module_function(mGLUT, "WireTeapot", glut_WireTeapot, 1);
+ rb_define_module_function(mGLUT, "SolidTeapot", glut_SolidTeapot, 1);
+ rb_define_module_function(mGLUT, "WireOctahedron", glut_WireOctahedron, 0);
+ rb_define_module_function(mGLUT, "SolidOctahedron", glut_SolidOctahedron, 0);
+ rb_define_module_function(mGLUT, "WireTetrahedron", glut_WireTetrahedron, 0);
+ rb_define_module_function(mGLUT, "SolidTetrahedron", glut_SolidTetrahedron, 0);
+ rb_define_module_function(mGLUT, "WireIcosahedron", glut_WireIcosahedron, 0);
+ rb_define_module_function(mGLUT, "SolidIcosahedron", glut_SolidIcosahedron, 0);
+ rb_define_module_function(mGLUT, "VideoResizeGet", glut_VideoResizeGet, 1);
+ rb_define_module_function(mGLUT, "SetupVideoResizing", glut_SetupVideoResizing, 0);
+ rb_define_module_function(mGLUT, "StopVideoResizing", glut_StopVideoResizing, 0);
+ rb_define_module_function(mGLUT, "VideoResize", glut_VideoResize, 4);
+ rb_define_module_function(mGLUT, "VideoPan", glut_VideoPan, 4);
+ rb_define_module_function(mGLUT, "ReportErrors", glut_ReportErrors, 0);
+ rb_define_module_function(mGLUT, "IdleFunc", glut_IdleFunc, 1);
+ rb_define_module_function(mGLUT, "TimerFunc", glut_TimerFunc, 3);
+
+ rb_define_const(mGLUT, "API_VERSION", INT2NUM(GLUT_API_VERSION));
+ rb_define_const(mGLUT, "XLIB_IMPLEMENTATION", INT2NUM(GLUT_XLIB_IMPLEMENTATION));
+ rb_define_const(mGLUT, "RGB", INT2NUM(GLUT_RGB));
+ rb_define_const(mGLUT, "RGBA", INT2NUM(GLUT_RGBA));
+ rb_define_const(mGLUT, "INDEX", INT2NUM(GLUT_INDEX));
+ rb_define_const(mGLUT, "SINGLE", INT2NUM(GLUT_SINGLE));
+ rb_define_const(mGLUT, "DOUBLE", INT2NUM(GLUT_DOUBLE));
+ rb_define_const(mGLUT, "ACCUM", INT2NUM(GLUT_ACCUM));
+ rb_define_const(mGLUT, "ALPHA", INT2NUM(GLUT_ALPHA));
+ rb_define_const(mGLUT, "DEPTH", INT2NUM(GLUT_DEPTH));
+ rb_define_const(mGLUT, "STENCIL", INT2NUM(GLUT_STENCIL));
+ rb_define_const(mGLUT, "MULTISAMPLE", INT2NUM(GLUT_MULTISAMPLE));
+ rb_define_const(mGLUT, "STEREO", INT2NUM(GLUT_STEREO));
+ rb_define_const(mGLUT, "LUMINANCE", INT2NUM(GLUT_LUMINANCE));
+ rb_define_const(mGLUT, "LEFT_BUTTON", INT2NUM(GLUT_LEFT_BUTTON));
+ rb_define_const(mGLUT, "MIDDLE_BUTTON", INT2NUM(GLUT_MIDDLE_BUTTON));
+ rb_define_const(mGLUT, "RIGHT_BUTTON", INT2NUM(GLUT_RIGHT_BUTTON));
+ rb_define_const(mGLUT, "DOWN", INT2NUM(GLUT_DOWN));
+ rb_define_const(mGLUT, "UP", INT2NUM(GLUT_UP));
+ rb_define_const(mGLUT, "KEY_F1", INT2NUM(GLUT_KEY_F1));
+ rb_define_const(mGLUT, "KEY_F2", INT2NUM(GLUT_KEY_F2));
+ rb_define_const(mGLUT, "KEY_F3", INT2NUM(GLUT_KEY_F3));
+ rb_define_const(mGLUT, "KEY_F4", INT2NUM(GLUT_KEY_F4));
+ rb_define_const(mGLUT, "KEY_F5", INT2NUM(GLUT_KEY_F5));
+ rb_define_const(mGLUT, "KEY_F6", INT2NUM(GLUT_KEY_F6));
+ rb_define_const(mGLUT, "KEY_F7", INT2NUM(GLUT_KEY_F7));
+ rb_define_const(mGLUT, "KEY_F8", INT2NUM(GLUT_KEY_F8));
+ rb_define_const(mGLUT, "KEY_F9", INT2NUM(GLUT_KEY_F9));
+ rb_define_const(mGLUT, "KEY_F10", INT2NUM(GLUT_KEY_F10));
+ rb_define_const(mGLUT, "KEY_F11", INT2NUM(GLUT_KEY_F11));
+ rb_define_const(mGLUT, "KEY_F12", INT2NUM(GLUT_KEY_F12));
+ rb_define_const(mGLUT, "KEY_LEFT", INT2NUM(GLUT_KEY_LEFT));
+ rb_define_const(mGLUT, "KEY_UP", INT2NUM(GLUT_KEY_UP));
+ rb_define_const(mGLUT, "KEY_RIGHT", INT2NUM(GLUT_KEY_RIGHT));
+ rb_define_const(mGLUT, "KEY_DOWN", INT2NUM(GLUT_KEY_DOWN));
+ rb_define_const(mGLUT, "KEY_PAGE_UP", INT2NUM(GLUT_KEY_PAGE_UP));
+ rb_define_const(mGLUT, "KEY_PAGE_DOWN", INT2NUM(GLUT_KEY_PAGE_DOWN));
+ rb_define_const(mGLUT, "KEY_HOME", INT2NUM(GLUT_KEY_HOME));
+ rb_define_const(mGLUT, "KEY_END", INT2NUM(GLUT_KEY_END));
+ rb_define_const(mGLUT, "KEY_INSERT", INT2NUM(GLUT_KEY_INSERT));
+ rb_define_const(mGLUT, "LEFT", INT2NUM(GLUT_LEFT));
+ rb_define_const(mGLUT, "ENTERED", INT2NUM(GLUT_ENTERED));
+ rb_define_const(mGLUT, "MENU_NOT_IN_USE", INT2NUM(GLUT_MENU_NOT_IN_USE));
+ rb_define_const(mGLUT, "MENU_IN_USE", INT2NUM(GLUT_MENU_IN_USE));
+ rb_define_const(mGLUT, "NOT_VISIBLE", INT2NUM(GLUT_NOT_VISIBLE));
+ rb_define_const(mGLUT, "VISIBLE", INT2NUM(GLUT_VISIBLE));
+ rb_define_const(mGLUT, "HIDDEN", INT2NUM(GLUT_HIDDEN));
+ rb_define_const(mGLUT, "FULLY_RETAINED", INT2NUM(GLUT_FULLY_RETAINED));
+ rb_define_const(mGLUT, "PARTIALLY_RETAINED", INT2NUM(GLUT_PARTIALLY_RETAINED));
+ rb_define_const(mGLUT, "FULLY_COVERED", INT2NUM(GLUT_FULLY_COVERED));
+ rb_define_const(mGLUT, "RED", INT2NUM(GLUT_RED));
+ rb_define_const(mGLUT, "GREEN", INT2NUM(GLUT_GREEN));
+ rb_define_const(mGLUT, "BLUE", INT2NUM(GLUT_BLUE));
+ rb_define_const(mGLUT, "WINDOW_X", INT2NUM(GLUT_WINDOW_X));
+ rb_define_const(mGLUT, "WINDOW_Y", INT2NUM(GLUT_WINDOW_Y));
+ rb_define_const(mGLUT, "WINDOW_WIDTH", INT2NUM(GLUT_WINDOW_WIDTH));
+ rb_define_const(mGLUT, "WINDOW_HEIGHT", INT2NUM(GLUT_WINDOW_HEIGHT));
+ rb_define_const(mGLUT, "WINDOW_BUFFER_SIZE", INT2NUM(GLUT_WINDOW_BUFFER_SIZE));
+ rb_define_const(mGLUT, "WINDOW_STENCIL_SIZE", INT2NUM(GLUT_WINDOW_STENCIL_SIZE));
+ rb_define_const(mGLUT, "WINDOW_DEPTH_SIZE", INT2NUM(GLUT_WINDOW_DEPTH_SIZE));
+ rb_define_const(mGLUT, "WINDOW_RED_SIZE", INT2NUM(GLUT_WINDOW_RED_SIZE));
+ rb_define_const(mGLUT, "WINDOW_GREEN_SIZE", INT2NUM(GLUT_WINDOW_GREEN_SIZE));
+ rb_define_const(mGLUT, "WINDOW_BLUE_SIZE", INT2NUM(GLUT_WINDOW_BLUE_SIZE));
+ rb_define_const(mGLUT, "WINDOW_ALPHA_SIZE", INT2NUM(GLUT_WINDOW_ALPHA_SIZE));
+ rb_define_const(mGLUT, "WINDOW_ACCUM_RED_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_RED_SIZE));
+ rb_define_const(mGLUT, "WINDOW_ACCUM_GREEN_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_GREEN_SIZE));
+ rb_define_const(mGLUT, "WINDOW_ACCUM_BLUE_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_BLUE_SIZE));
+ rb_define_const(mGLUT, "WINDOW_ACCUM_ALPHA_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_ALPHA_SIZE));
+ rb_define_const(mGLUT, "WINDOW_DOUBLEBUFFER", INT2NUM(GLUT_WINDOW_DOUBLEBUFFER));
+ rb_define_const(mGLUT, "WINDOW_RGBA", INT2NUM(GLUT_WINDOW_RGBA));
+ rb_define_const(mGLUT, "WINDOW_PARENT", INT2NUM(GLUT_WINDOW_PARENT));
+ rb_define_const(mGLUT, "WINDOW_NUM_CHILDREN", INT2NUM(GLUT_WINDOW_NUM_CHILDREN));
+ rb_define_const(mGLUT, "WINDOW_COLORMAP_SIZE", INT2NUM(GLUT_WINDOW_COLORMAP_SIZE));
+ rb_define_const(mGLUT, "WINDOW_NUM_SAMPLES", INT2NUM(GLUT_WINDOW_NUM_SAMPLES));
+ rb_define_const(mGLUT, "WINDOW_STEREO", INT2NUM(GLUT_WINDOW_STEREO));
+ rb_define_const(mGLUT, "WINDOW_CURSOR", INT2NUM(GLUT_WINDOW_CURSOR));
+ rb_define_const(mGLUT, "SCREEN_WIDTH", INT2NUM(GLUT_SCREEN_WIDTH));
+ rb_define_const(mGLUT, "SCREEN_HEIGHT", INT2NUM(GLUT_SCREEN_HEIGHT));
+ rb_define_const(mGLUT, "SCREEN_WIDTH_MM", INT2NUM(GLUT_SCREEN_WIDTH_MM));
+ rb_define_const(mGLUT, "SCREEN_HEIGHT_MM", INT2NUM(GLUT_SCREEN_HEIGHT_MM));
+ rb_define_const(mGLUT, "MENU_NUM_ITEMS", INT2NUM(GLUT_MENU_NUM_ITEMS));
+ rb_define_const(mGLUT, "DISPLAY_MODE_POSSIBLE", INT2NUM(GLUT_DISPLAY_MODE_POSSIBLE));
+ rb_define_const(mGLUT, "INIT_WINDOW_X", INT2NUM(GLUT_INIT_WINDOW_X));
+ rb_define_const(mGLUT, "INIT_WINDOW_Y", INT2NUM(GLUT_INIT_WINDOW_Y));
+ rb_define_const(mGLUT, "INIT_WINDOW_WIDTH", INT2NUM(GLUT_INIT_WINDOW_WIDTH));
+ rb_define_const(mGLUT, "INIT_WINDOW_HEIGHT", INT2NUM(GLUT_INIT_WINDOW_HEIGHT));
+ rb_define_const(mGLUT, "INIT_DISPLAY_MODE", INT2NUM(GLUT_INIT_DISPLAY_MODE));
+ rb_define_const(mGLUT, "ELAPSED_TIME", INT2NUM(GLUT_ELAPSED_TIME));
+ rb_define_const(mGLUT, "HAS_KEYBOARD", INT2NUM(GLUT_HAS_KEYBOARD));
+ rb_define_const(mGLUT, "HAS_MOUSE", INT2NUM(GLUT_HAS_MOUSE));
+ rb_define_const(mGLUT, "HAS_SPACEBALL", INT2NUM(GLUT_HAS_SPACEBALL));
+ rb_define_const(mGLUT, "HAS_DIAL_AND_BUTTON_BOX", INT2NUM(GLUT_HAS_DIAL_AND_BUTTON_BOX));
+ rb_define_const(mGLUT, "HAS_TABLET", INT2NUM(GLUT_HAS_TABLET));
+ rb_define_const(mGLUT, "NUM_MOUSE_BUTTONS", INT2NUM(GLUT_NUM_MOUSE_BUTTONS));
+ rb_define_const(mGLUT, "NUM_SPACEBALL_BUTTONS", INT2NUM(GLUT_NUM_SPACEBALL_BUTTONS));
+ rb_define_const(mGLUT, "NUM_BUTTON_BOX_BUTTONS", INT2NUM(GLUT_NUM_BUTTON_BOX_BUTTONS));
+ rb_define_const(mGLUT, "NUM_DIALS", INT2NUM(GLUT_NUM_DIALS));
+ rb_define_const(mGLUT, "NUM_TABLET_BUTTONS", INT2NUM(GLUT_NUM_TABLET_BUTTONS));
+ rb_define_const(mGLUT, "OVERLAY_POSSIBLE", INT2NUM(GLUT_OVERLAY_POSSIBLE));
+ rb_define_const(mGLUT, "LAYER_IN_USE", INT2NUM(GLUT_LAYER_IN_USE));
+ rb_define_const(mGLUT, "HAS_OVERLAY", INT2NUM(GLUT_HAS_OVERLAY));
+ rb_define_const(mGLUT, "TRANSPARENT_INDEX", INT2NUM(GLUT_TRANSPARENT_INDEX));
+ rb_define_const(mGLUT, "NORMAL_DAMAGED", INT2NUM(GLUT_NORMAL_DAMAGED));
+ rb_define_const(mGLUT, "OVERLAY_DAMAGED", INT2NUM(GLUT_OVERLAY_DAMAGED));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_POSSIBLE", INT2NUM(GLUT_VIDEO_RESIZE_POSSIBLE));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_IN_USE", INT2NUM(GLUT_VIDEO_RESIZE_IN_USE));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_X_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_X_DELTA));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_Y_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_Y_DELTA));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_WIDTH_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_WIDTH_DELTA));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_HEIGHT_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_HEIGHT_DELTA));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_X", INT2NUM(GLUT_VIDEO_RESIZE_X));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_Y", INT2NUM(GLUT_VIDEO_RESIZE_Y));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_WIDTH", INT2NUM(GLUT_VIDEO_RESIZE_WIDTH));
+ rb_define_const(mGLUT, "VIDEO_RESIZE_HEIGHT", INT2NUM(GLUT_VIDEO_RESIZE_HEIGHT));
+ rb_define_const(mGLUT, "NORMAL", INT2NUM(GLUT_NORMAL));
+ rb_define_const(mGLUT, "OVERLAY", INT2NUM(GLUT_OVERLAY));
+ rb_define_const(mGLUT, "ACTIVE_SHIFT", INT2NUM(GLUT_ACTIVE_SHIFT));
+ rb_define_const(mGLUT, "ACTIVE_CTRL", INT2NUM(GLUT_ACTIVE_CTRL));
+ rb_define_const(mGLUT, "ACTIVE_ALT", INT2NUM(GLUT_ACTIVE_ALT));
+ rb_define_const(mGLUT, "CURSOR_RIGHT_ARROW", INT2NUM(GLUT_CURSOR_RIGHT_ARROW));
+ rb_define_const(mGLUT, "CURSOR_LEFT_ARROW", INT2NUM(GLUT_CURSOR_LEFT_ARROW));
+ rb_define_const(mGLUT, "CURSOR_INFO", INT2NUM(GLUT_CURSOR_INFO));
+ rb_define_const(mGLUT, "CURSOR_DESTROY", INT2NUM(GLUT_CURSOR_DESTROY));
+ rb_define_const(mGLUT, "CURSOR_HELP", INT2NUM(GLUT_CURSOR_HELP));
+ rb_define_const(mGLUT, "CURSOR_CYCLE", INT2NUM(GLUT_CURSOR_CYCLE));
+ rb_define_const(mGLUT, "CURSOR_SPRAY", INT2NUM(GLUT_CURSOR_SPRAY));
+ rb_define_const(mGLUT, "CURSOR_WAIT", INT2NUM(GLUT_CURSOR_WAIT));
+ rb_define_const(mGLUT, "CURSOR_TEXT", INT2NUM(GLUT_CURSOR_TEXT));
+ rb_define_const(mGLUT, "CURSOR_CROSSHAIR", INT2NUM(GLUT_CURSOR_CROSSHAIR));
+ rb_define_const(mGLUT, "CURSOR_UP_DOWN", INT2NUM(GLUT_CURSOR_UP_DOWN));
+ rb_define_const(mGLUT, "CURSOR_LEFT_RIGHT", INT2NUM(GLUT_CURSOR_LEFT_RIGHT));
+ rb_define_const(mGLUT, "CURSOR_TOP_SIDE", INT2NUM(GLUT_CURSOR_TOP_SIDE));
+ rb_define_const(mGLUT, "CURSOR_BOTTOM_SIDE", INT2NUM(GLUT_CURSOR_BOTTOM_SIDE));
+ rb_define_const(mGLUT, "CURSOR_LEFT_SIDE", INT2NUM(GLUT_CURSOR_LEFT_SIDE));
+ rb_define_const(mGLUT, "CURSOR_RIGHT_SIDE", INT2NUM(GLUT_CURSOR_RIGHT_SIDE));
+ rb_define_const(mGLUT, "CURSOR_TOP_LEFT_CORNER", INT2NUM(GLUT_CURSOR_TOP_LEFT_CORNER));
+ rb_define_const(mGLUT, "CURSOR_TOP_RIGHT_CORNER", INT2NUM(GLUT_CURSOR_TOP_RIGHT_CORNER));
+ rb_define_const(mGLUT, "CURSOR_BOTTOM_RIGHT_CORNER", INT2NUM(GLUT_CURSOR_BOTTOM_RIGHT_CORNER));
+ rb_define_const(mGLUT, "CURSOR_BOTTOM_LEFT_CORNER", INT2NUM(GLUT_CURSOR_BOTTOM_LEFT_CORNER));
+ rb_define_const(mGLUT, "CURSOR_INHERIT", INT2NUM(GLUT_CURSOR_INHERIT));
+ rb_define_const(mGLUT, "CURSOR_NONE", INT2NUM(GLUT_CURSOR_NONE));
+ rb_define_const(mGLUT, "CURSOR_FULL_CROSSHAIR", INT2NUM(GLUT_CURSOR_FULL_CROSSHAIR));
+ rb_define_const(mGLUT, "BITMAP_9_BY_15", INT2NUM((VALUE)GLUT_BITMAP_9_BY_15));
+ rb_define_const(mGLUT, "BITMAP_8_BY_13", INT2NUM((VALUE)GLUT_BITMAP_8_BY_13));
+ rb_define_const(mGLUT, "BITMAP_TIMES_ROMAN_10", INT2NUM((VALUE)GLUT_BITMAP_TIMES_ROMAN_10));
+ rb_define_const(mGLUT, "BITMAP_TIMES_ROMAN_24", INT2NUM((VALUE)GLUT_BITMAP_TIMES_ROMAN_24));
+ rb_define_const(mGLUT, "BITMAP_HELVETICA_10", INT2NUM((VALUE)GLUT_BITMAP_HELVETICA_10));
+ rb_define_const(mGLUT, "BITMAP_HELVETICA_12", INT2NUM((VALUE)GLUT_BITMAP_HELVETICA_12));
+ rb_define_const(mGLUT, "BITMAP_HELVETICA_18", INT2NUM((VALUE)GLUT_BITMAP_HELVETICA_18));
+ rb_define_const(mGLUT, "STROKE_ROMAN", INT2NUM((VALUE)GLUT_STROKE_ROMAN));
+ rb_define_const(mGLUT, "STROKE_MONO_ROMAN", INT2NUM((VALUE)GLUT_STROKE_MONO_ROMAN));
+
+ callId = rb_intern("call");
+
+ WINDOW_CALLBACK_DEFINE(DisplayFunc);
+ WINDOW_CALLBACK_DEFINE(ReshapeFunc);
+ WINDOW_CALLBACK_DEFINE(KeyboardFunc);
+ WINDOW_CALLBACK_DEFINE(MouseFunc);
+ WINDOW_CALLBACK_DEFINE(MotionFunc);
+ WINDOW_CALLBACK_DEFINE(PassiveMotionFunc);
+ WINDOW_CALLBACK_DEFINE(EntryFunc);
+ WINDOW_CALLBACK_DEFINE(VisibilityFunc);
+/*
+ GENERAL_CALLBACK_DEFINE(IdleFunc);
+ GENERAL_CALLBACK_DEFINE(TimerFunc);
+ MENU_CALLBACK_DEFINE(MenuStateFunc);
+*/
+ WINDOW_CALLBACK_DEFINE(SpecialFunc);
+ WINDOW_CALLBACK_DEFINE(SpaceballMotionFunc);
+ WINDOW_CALLBACK_DEFINE(SpaceballRotateFunc);
+ WINDOW_CALLBACK_DEFINE(SpaceballButtonFunc);
+ WINDOW_CALLBACK_DEFINE(ButtonBoxFunc);
+ WINDOW_CALLBACK_DEFINE(DialsFunc);
+ WINDOW_CALLBACK_DEFINE(TabletMotionFunc);
+ WINDOW_CALLBACK_DEFINE(TabletButtonFunc);
+/*
+ WINDOW_GLOBAL_VAR_DEFINE(MenuStatusFunc);
+*/
+ WINDOW_CALLBACK_DEFINE(OverlayDisplayFunc);
+ WINDOW_CALLBACK_DEFINE(WindowStatusFunc);
+
+ rb_gc_register_address(&idle_func);
+ rb_gc_register_address(&timer_func);
+ rb_gc_register_address(&menustate_func);
+}
+
Property changes on: branches/upstream/libopengl-ruby/current/glut.c
___________________________________________________________________
Added: svn:executable
+
More information about the Pkg-ruby-extras-commits
mailing list