module Glut

Constants

GLUT_3_2_CORE_PROFILE
GLUT_ACCUM
GLUT_ACTIVE_ALT
GLUT_ACTIVE_CTRL
GLUT_ACTIVE_SHIFT
GLUT_ALPHA
GLUT_API_VERSION
GLUT_BITMAP_8_BY_13
GLUT_BITMAP_9_BY_15

hardcoded, see bitmap_font_map for explanation

GLUT_BITMAP_HELVETICA_10
GLUT_BITMAP_HELVETICA_12
GLUT_BITMAP_HELVETICA_18
GLUT_BITMAP_TIMES_ROMAN_10
GLUT_BITMAP_TIMES_ROMAN_24
GLUT_BLUE
GLUT_CURSOR_BOTTOM_LEFT_CORNER
GLUT_CURSOR_BOTTOM_RIGHT_CORNER
GLUT_CURSOR_BOTTOM_SIDE
GLUT_CURSOR_CROSSHAIR
GLUT_CURSOR_CYCLE
GLUT_CURSOR_DESTROY
GLUT_CURSOR_FULL_CROSSHAIR
GLUT_CURSOR_HELP
GLUT_CURSOR_INFO
GLUT_CURSOR_INHERIT
GLUT_CURSOR_LEFT_ARROW
GLUT_CURSOR_LEFT_RIGHT
GLUT_CURSOR_LEFT_SIDE
GLUT_CURSOR_NONE
GLUT_CURSOR_RIGHT_ARROW
GLUT_CURSOR_RIGHT_SIDE
GLUT_CURSOR_SPRAY
GLUT_CURSOR_TEXT
GLUT_CURSOR_TOP_LEFT_CORNER
GLUT_CURSOR_TOP_RIGHT_CORNER
GLUT_CURSOR_TOP_SIDE
GLUT_CURSOR_UP_DOWN
GLUT_CURSOR_WAIT
GLUT_DEPTH
GLUT_DEVICE_IGNORE_KEY_REPEAT
GLUT_DEVICE_KEY_REPEAT
GLUT_DISPLAY_MODE_POSSIBLE
GLUT_DOUBLE
GLUT_DOWN
GLUT_ELAPSED_TIME
GLUT_ENTERED
GLUT_FULLY_COVERED
GLUT_FULLY_RETAINED
GLUT_GAME_MODE_ACTIVE
GLUT_GAME_MODE_DISPLAY_CHANGED
GLUT_GAME_MODE_HEIGHT
GLUT_GAME_MODE_PIXEL_DEPTH
GLUT_GAME_MODE_POSSIBLE
GLUT_GAME_MODE_REFRESH_RATE
GLUT_GAME_MODE_WIDTH
GLUT_GREEN
GLUT_HAS_DIAL_AND_BUTTON_BOX
GLUT_HAS_JOYSTICK
GLUT_HAS_KEYBOARD
GLUT_HAS_MOUSE
GLUT_HAS_OVERLAY
GLUT_HAS_SPACEBALL
GLUT_HAS_TABLET
GLUT_HIDDEN
GLUT_INDEX
GLUT_INIT_DISPLAY_MODE
GLUT_INIT_WINDOW_HEIGHT
GLUT_INIT_WINDOW_WIDTH
GLUT_INIT_WINDOW_X
GLUT_INIT_WINDOW_Y
GLUT_JOYSTICK_AXES
GLUT_JOYSTICK_BUTTONS
GLUT_JOYSTICK_BUTTON_A
GLUT_JOYSTICK_BUTTON_B
GLUT_JOYSTICK_BUTTON_C
GLUT_JOYSTICK_BUTTON_D
GLUT_JOYSTICK_POLL_RATE
GLUT_KEY_DOWN
GLUT_KEY_END
GLUT_KEY_F1
GLUT_KEY_F10
GLUT_KEY_F11
GLUT_KEY_F12
GLUT_KEY_F2
GLUT_KEY_F3
GLUT_KEY_F4
GLUT_KEY_F5
GLUT_KEY_F6
GLUT_KEY_F7
GLUT_KEY_F8
GLUT_KEY_F9
GLUT_KEY_HOME
GLUT_KEY_INSERT
GLUT_KEY_LEFT
GLUT_KEY_PAGE_DOWN
GLUT_KEY_PAGE_UP
GLUT_KEY_REPEAT_DEFAULT
GLUT_KEY_REPEAT_OFF
GLUT_KEY_REPEAT_ON
GLUT_KEY_RIGHT
GLUT_KEY_UP
GLUT_LAYER_IN_USE
GLUT_LEFT
GLUT_LEFT_BUTTON
GLUT_LUMINANCE
GLUT_MENU_IN_USE
GLUT_MENU_NOT_IN_USE
GLUT_MENU_NUM_ITEMS
GLUT_MIDDLE_BUTTON
GLUT_MULTISAMPLE
GLUT_NORMAL
GLUT_NORMAL_DAMAGED
GLUT_NOT_VISIBLE
GLUT_NO_RECOVERY
GLUT_NUM_BUTTON_BOX_BUTTONS
GLUT_NUM_DIALS
GLUT_NUM_MOUSE_BUTTONS
GLUT_NUM_SPACEBALL_BUTTONS
GLUT_NUM_TABLET_BUTTONS
GLUT_OVERLAY
GLUT_OVERLAY_DAMAGED
GLUT_OVERLAY_POSSIBLE
GLUT_OWNS_JOYSTICK
GLUT_PARTIALLY_RETAINED
GLUT_RED
GLUT_RGB
GLUT_RGBA
GLUT_RIGHT_BUTTON
GLUT_SCREEN_HEIGHT
GLUT_SCREEN_HEIGHT_MM
GLUT_SCREEN_WIDTH
GLUT_SCREEN_WIDTH_MM
GLUT_SINGLE
GLUT_STENCIL
GLUT_STEREO
GLUT_STROKE_MONO_ROMAN
GLUT_STROKE_ROMAN
GLUT_TRANSPARENT_INDEX
GLUT_UP
GLUT_VIDEO_RESIZE_HEIGHT
GLUT_VIDEO_RESIZE_HEIGHT_DELTA
GLUT_VIDEO_RESIZE_IN_USE
GLUT_VIDEO_RESIZE_POSSIBLE
GLUT_VIDEO_RESIZE_WIDTH
GLUT_VIDEO_RESIZE_WIDTH_DELTA
GLUT_VIDEO_RESIZE_X
GLUT_VIDEO_RESIZE_X_DELTA
GLUT_VIDEO_RESIZE_Y
GLUT_VIDEO_RESIZE_Y_DELTA
GLUT_VISIBLE
GLUT_WINDOW_ACCUM_ALPHA_SIZE
GLUT_WINDOW_ACCUM_BLUE_SIZE
GLUT_WINDOW_ACCUM_GREEN_SIZE
GLUT_WINDOW_ACCUM_RED_SIZE
GLUT_WINDOW_ALPHA_SIZE
GLUT_WINDOW_BLUE_SIZE
GLUT_WINDOW_BUFFER_SIZE
GLUT_WINDOW_COLORMAP_SIZE
GLUT_WINDOW_CURSOR
GLUT_WINDOW_DEPTH_SIZE
GLUT_WINDOW_DOUBLEBUFFER
GLUT_WINDOW_FORMAT_ID
GLUT_WINDOW_GREEN_SIZE
GLUT_WINDOW_HEIGHT
GLUT_WINDOW_NUM_CHILDREN
GLUT_WINDOW_NUM_SAMPLES
GLUT_WINDOW_PARENT
GLUT_WINDOW_RED_SIZE
GLUT_WINDOW_RGBA
GLUT_WINDOW_STENCIL_SIZE
GLUT_WINDOW_STEREO
GLUT_WINDOW_WIDTH
GLUT_WINDOW_X
GLUT_WINDOW_Y
GLUT_XLIB_IMPLEMENTATION
VERSION

Public Class Methods

glutAddMenuEntry(p1, p2) click to toggle source
static VALUE
glut_AddMenuEntry(obj,arg1,arg2)
VALUE obj,arg1,arg2;
{
        Check_Type(arg1,T_STRING);
        glutAddMenuEntry(RSTRING_PTR(arg1), NUM2INT(arg2));
        return Qnil;
}
glutAddSubMenu(p1, p2) click to toggle source
static VALUE
glut_AddSubMenu(obj,arg1,arg2)
VALUE obj,arg1,arg2;
{
        Check_Type(arg1,T_STRING);
        glutAddSubMenu(RSTRING_PTR(arg1), NUM2INT(arg2));
        return Qnil;
}
glutAttachMenu(p1) click to toggle source
static VALUE
glut_AttachMenu(obj,arg1)
VALUE obj, arg1;
{
        glutAttachMenu(NUM2INT(arg1));
        return Qnil;
}
glutBitmapCharacter(p1, p2) click to toggle source
static VALUE
glut_BitmapCharacter(obj,arg1,arg2)
VALUE obj,arg1,arg2;
{
        int character;
        int font;
        font = NUM2INT(arg1);
        character = NUM2INT(arg2);
        glutBitmapCharacter(bitmap_font_map(font),character);
        return Qnil;
}
glutBitmapLength(p1, p2) click to toggle source
static VALUE
glut_BitmapLength(obj,arg1,arg2)
VALUE obj,arg1,arg2;
{
        int font;
        int ret;
        Check_Type(arg2,T_STRING);
        font = NUM2INT(arg1);
        ret = glutBitmapLength(bitmap_font_map(font), (const unsigned char*)RSTRING_PTR(arg2));
        return INT2NUM(ret);
}
glutBitmapWidth(p1, p2) click to toggle source
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(bitmap_font_map(font), character);
        return INT2NUM(ret);
}
glutChangeToMenuEntry(p1, p2, p3) click to toggle source
static VALUE glut_ChangeToMenuEntry(obj,arg1,arg2,arg3)
VALUE obj,arg1,arg2,arg3;
{
        Check_Type(arg2,T_STRING);
        glutChangeToMenuEntry(NUM2INT(arg1), RSTRING_PTR(arg2), NUM2INT(arg3));
        return Qnil;
}
glutChangeToSubMenu(p1, p2, p3) click to toggle source
static VALUE glut_ChangeToSubMenu(obj,arg1,arg2,arg3)
VALUE obj,arg1,arg2,arg3;
{
        Check_Type(arg2,T_STRING);
        glutChangeToSubMenu(NUM2INT(arg1), RSTRING_PTR(arg2), NUM2INT(arg3));
        return Qnil;
}
glutCheckLoop() click to toggle source
static VALUE
glut_CheckLoop(void) {
  rb_warn("calling fake CheckLoop implementation which never returns");

  glut_MainLoop();

  return Qnil;
}
glutCopyColormap(p1) click to toggle source
static VALUE
glut_CopyColormap(obj,arg1)
VALUE obj,arg1;
{
        int win;
        win = NUM2INT(arg1);
        glutCopyColormap(win);
        return Qnil;
}
glutCreateMenu(p1) click to toggle source
static VALUE
glut_CreateMenu(VALUE obj, VALUE callback) {
        int menu;

  callback = rb_glut_check_callback(obj, callback);

        if (NIL_P(callback))
                menu = glutCreateMenu(NULL);
        else
                menu = glutCreateMenu(glut_CreateMenuCallback);

        rb_ary_store(menu_callback, menu, callback);

        return INT2FIX(menu);
}
glutCreateSubWindow(p1, p2, p3, p4, p5) click to toggle source
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);
}
glutCreateWindow(p1 = v1) click to toggle source

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");
        Check_Type(title,T_STRING);
        ret = glutCreateWindow(RSTRING_PTR(title));
        return INT2NUM(ret);
}
glutDestroyMenu(p1) click to toggle source
static VALUE
glut_DestroyMenu(obj,arg1)
VALUE obj,arg1;
{
        int menu;
        menu = NUM2INT(arg1);
        glutDestroyMenu(menu);
        //rb_hash_aset(g_menucallback, menu, Qnil);
        //rb_hash_aset(g_menuargs, menu, Qnil);
        return Qnil;
}
glutDestroyWindow(p1) click to toggle source
static VALUE
glut_DestroyWindow(obj,arg1)
VALUE obj,arg1;
{
        int win;
        win = NUM2INT(arg1);
        glutDestroyWindow(win);
        return Qnil;
}
glutDetachMenu(p1) click to toggle source
static VALUE
glut_DetachMenu(obj,arg1)
VALUE obj, arg1;
{
        glutDetachMenu(NUM2INT(arg1));
        return Qnil;
}
glutDeviceGet(p1) click to toggle source
static VALUE
glut_DeviceGet(obj,arg1)
VALUE obj,arg1;
{
        GLenum type;
        int ret;
        type = (GLenum)NUM2INT(arg1);
        ret = glutDeviceGet(type);
        return INT2NUM(ret);
}
glutExtensionSupported(p1) click to toggle source

GLUT extension support sub-API

static VALUE
glut_ExtensionSupported(obj,arg1)
VALUE obj,arg1;
{
        int ret;
        Check_Type(arg1,T_STRING);
        ret = glutExtensionSupported(RSTRING_PTR(arg1));
        return INT2NUM(ret);
}
glutGameModeGet(p1) click to toggle source
static VALUE
glut_GameModeGet(obj,arg1)
VALUE obj,arg1;
{
        GLenum info;
        int i;
        info = (GLenum)NUM2INT(arg1);
        i = glutGameModeGet(info);
        return INT2NUM(i);
}
glutGameModeString(p1) click to toggle source
static VALUE
glut_GameModeString(obj,arg1)
VALUE obj,arg1;
{
        Check_Type(arg1,T_STRING);
        glutGameModeString((const char*)RSTRING_PTR(arg1));
        return Qnil;
}
glutGet(p1) click to toggle source

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);
}
glutGetColor(p1, p2) click to toggle source
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);
}
glutGetMenu() click to toggle source
static VALUE
glut_GetMenu(obj)
VALUE obj;
{
        int ret;
        ret = glutGetMenu();
        return INT2NUM(ret);
}
glutGetModifiers() click to toggle source
static VALUE
glut_GetModifiers(obj)
VALUE obj;
{
        int ret;
        ret = glutGetModifiers();
        return INT2NUM(ret);
}
glutGetWindow() click to toggle source
static VALUE
glut_GetWindow(obj)
VALUE obj;
{
        int ret;
        ret = glutGetWindow();
        return INT2NUM(ret);
}
glutIgnoreKeyRepeat(p1) click to toggle source
static VALUE
glut_IgnoreKeyRepeat(obj,arg1)
VALUE obj,arg1;
{
        GLenum ignore;
        ignore = (int) NUM2INT(arg1);
        glutIgnoreKeyRepeat(ignore);
        return Qnil;
}
glutInit(p1 = v1) click to toggle source
static VALUE glut_Init( int argc, VALUE * argv, VALUE obj)
{
        int largc;
        char** largv;
        VALUE new_argv;
        VALUE orig_arg;
        int i;

        if (rb_scan_args(argc, argv, "01", &orig_arg) == 0)
                orig_arg = rb_eval_string("[$0] + ARGV");
        else
                Check_Type(orig_arg, T_ARRAY);

        /* converts commandline parameters from ruby to C, passes them
        to glutInit and returns the parameters stripped of glut-specific
        commands ("-display","-geometry" etc.) */
        largc = (int)RARRAY_LENINT(orig_arg);
        largv = ALLOCA_N(char*, largc);
        for (i = 0; i < largc; i++)
                largv[i] = StringValueCStr(RARRAY_PTR(orig_arg)[i]);

        glutInit(&largc, largv);

        new_argv = rb_ary_new2(largc);
        for (i = 0; i < largc; i++)
                rb_ary_push(new_argv,rb_str_new2(largv[i]));

        rb_ary_shift(new_argv);

        return new_argv;
}
glutInitDisplayMode(p1) click to toggle source
static VALUE glut_InitDisplayMode(obj,arg1)
VALUE obj,arg1;
{
        unsigned int mode;
        mode = (unsigned int)NUM2INT(arg1);
        glutInitDisplayMode(mode);
        return Qnil;
}
glutInitDisplayString(p1) click to toggle source
static VALUE
glut_InitDisplayString(obj,arg1)
VALUE obj,arg1;
{
        Check_Type(arg1,T_STRING);
        glutInitDisplayString(RSTRING_PTR(arg1));
        return Qnil;
}
glutInitWindowPosition(p1, p2) click to toggle source
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;
}
glutInitWindowSize(p1, p2) click to toggle source
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;
}
glutLayerGet(p1) click to toggle source
static VALUE
glut_LayerGet(obj,arg1)
VALUE obj,arg1;
{
        GLenum type;
        int ret;
        type = (GLenum)NUM2INT(arg1);
        ret = glutLayerGet(type);
        return INT2NUM(ret);
}
glutMainLoop() click to toggle source
static VALUE
glut_MainLoop(void) {
  rb_thread_call_without_gvl(glut_MainLoop0, NULL, NULL, NULL);

  return Qnil; /* never reached */
}
glutPositionWindow(p1, p2) click to toggle source
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;
}
glutPostWindowOverlayRedisplay(p1) click to toggle source
static VALUE
glut_PostWindowOverlayRedisplay(obj,arg1)
VALUE obj,arg1;
{
        int win;
        win = (int) NUM2INT(arg1);
        glutPostWindowOverlayRedisplay(win);
        return Qnil;
}
glutPostWindowRedisplay(p1) click to toggle source
static VALUE
glut_PostWindowRedisplay(obj,arg1)
VALUE obj,arg1;
{
        int win;
        win = (int) NUM2INT(arg1);
        glutPostWindowRedisplay(win);
        return Qnil;
}
glutRemoveMenuItem(p1) click to toggle source
static VALUE glut_RemoveMenuItem( VALUE obj, VALUE arg1 )
{
        glutRemoveMenuItem(NUM2INT(arg1));
        return Qnil;
}
glutReshapeWindow(p1, p2) click to toggle source
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;
}
glutSetColor(p1, p2, p3, p4) click to toggle source

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;
}
glutSetCursor(p1) click to toggle source
static VALUE
glut_SetCursor(obj,arg1)
VALUE obj,arg1;
{
        int cursor;
        cursor = NUM2INT(arg1);
        glutSetCursor(cursor);
        return Qnil;
}
glutSetIconTitle(p1) click to toggle source
static VALUE
glut_SetIconTitle(obj, arg1)
VALUE obj,arg1;
{
        Check_Type(arg1,T_STRING);
        glutSetIconTitle(RSTRING_PTR(arg1));
        return Qnil;
}
glutSetKeyRepeat(p1) click to toggle source
static VALUE
glut_SetKeyRepeat(obj,arg1)
VALUE obj,arg1;
{
        GLenum repeatMode;
        repeatMode = (int) NUM2INT(arg1);
        glutSetKeyRepeat(repeatMode);
        return Qnil;
}
glutSetMenu(p1) click to toggle source
static VALUE
glut_SetMenu(obj,arg1)
VALUE obj,arg1;
{
        glutSetMenu(NUM2INT(arg1));
        return Qnil;
}
glutSetWindow(p1) click to toggle source
static VALUE
glut_SetWindow(obj,arg1)
VALUE obj,arg1;
{
        int win;
        win = NUM2INT(arg1);
        glutSetWindow(win);
        return Qnil;
}
glutSetWindowTitle(p1) click to toggle source
static VALUE
glut_SetWindowTitle(obj,arg1)
VALUE obj,arg1;
{
        Check_Type(arg1,T_STRING);
        glutSetWindowTitle(RSTRING_PTR(arg1));
        return Qnil;
}
glutSolidCone(p1, p2, p3, p4) click to toggle source
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;
}
glutSolidCube(p1) click to toggle source
static VALUE
glut_SolidCube(obj,arg1)
VALUE obj,arg1;
{
        GLdouble size;
        size = (GLdouble)NUM2DBL(arg1);
        glutSolidCube(size);
        return Qnil;
}
glutSolidSphere(p1, p2, p3) click to toggle source
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;
}
glutSolidTeapot(p1) click to toggle source
static VALUE
glut_SolidTeapot(obj,arg1)
VALUE obj,arg1;
{
        GLdouble size;
        size = (GLdouble)NUM2DBL(arg1);
        glutSolidTeapot(size);
        return Qnil;
}
glutSolidTorus(p1, p2, p3, p4) click to toggle source
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;
}
glutStrokeCharacter(p1, p2) click to toggle source
static VALUE
glut_StrokeCharacter(obj,arg1,arg2)
VALUE obj,arg1,arg2;
{
        int font;
        int character;
        font = NUM2INT(arg1);
        character = NUM2INT(arg2);
        glutStrokeCharacter(stroke_font_map(font), character);
        return Qnil;
}
glutStrokeLength(p1, p2) click to toggle source
static VALUE
glut_StrokeLength(obj,arg1,arg2)
VALUE obj,arg1,arg2;
{
        int font;
        int ret;
        Check_Type(arg2,T_STRING);
        font = NUM2INT(arg1);
        ret = glutStrokeLength(stroke_font_map(font), (const unsigned char*)RSTRING_PTR(arg2));
        return INT2NUM(ret);
}
glutStrokeWidth(p1, p2) click to toggle source
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(stroke_font_map(font), character);
        return INT2NUM(ret);
}
glutUseLayer(p1) click to toggle source
static VALUE
glut_UseLayer(obj,arg1)
VALUE obj, arg1;
{
        GLenum layer;
        layer = (GLenum)NUM2INT(arg1);
        glutUseLayer(layer);
        return Qnil;
}
glutVideoPan(p1, p2, p3, p4) click to toggle source
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;
}
glutVideoResize(p1, p2, p3, p4) click to toggle source
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;
}
glutVideoResizeGet(p1) click to toggle source

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);
}
glutWarpPointer(p1, p2) click to toggle source
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;
}
glutWireCone(p1, p2, p3, p4) click to toggle source
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;
}
glutWireCube(p1) click to toggle source
static VALUE
glut_WireCube(obj,arg1)
VALUE obj,arg1;
{
        GLdouble size;
        size = (GLdouble)NUM2DBL(arg1);
        glutWireCube(size);
        return Qnil;
}
glutWireSphere(p1, p2, p3) click to toggle source

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;
}
glutWireTeapot(p1) click to toggle source
static VALUE
glut_WireTeapot(obj,arg1)
VALUE obj,arg1;
{
        GLdouble size;
        size = (GLdouble)NUM2DBL(arg1);
        glutWireTeapot(size);
        return Qnil;
}
glutWireTorus(p1, p2, p3, p4) click to toggle source
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;
}