addons/OpenGL/source/IoGLUT.c

   1 /*#io
   2 GLUT ioDoc(
   3                          docCopyright("Steve Dekorte", 2002)
   4                          docLicense("BSD revised")
   5                          docCategory("Graphics")
   6  */
   7
   8 #include "IoGLUT.h"
   9
  10 #include "List.h"
  11 #include "IoState.h"
  12 #include "IoNumber.h"
  13 #include "IoCFunction.h"
  14 #include "IoSeq.h"
  15 #include "IoList.h"
  16 #include "List.h"
  17 #include "IoDirectory.h"
  18 #include <time.h>
  19
  20 #define DATA(self) ((IoGLUTData *)IoObject_dataPointer(self))
  21
  22 void IoGlutTimerFunc(int vv);
  23
  24 static IoGLUT *proto = NULL;
  25
  26
  27 IoTag *IoGLUT_newTag(void *state)
  28 {
  29         IoTag *tag = IoTag_newWithName_("GLUT");
  30         IoTag_state_(tag, state);
  31         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoGLUT_rawClone);
  32         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoGLUT_free);
  33         IoTag_markFunc_(tag, (IoTagMarkFunc *)IoGLUT_mark);
  34         return tag;
  35 }
  36
  37 #define GLUTMESSAGE(name) \
  38 IoMessage_newWithName_label_(state, IOSYMBOL(name), IOSYMBOL("[GLUT]"))
  39
  40 IoGLUT *IoGLUT_proto(void *state)
  41 {
  42         IoObject *self = IoObject_new(state);
  43         /*printf("state = %p proto = %p self = %p\n", state, proto, self); */
  44
  45         proto = self;
  46         IoObject_tag_(self, IoGLUT_newTag(state));
  47         IoObject_setDataPointer_(self, calloc(1, sizeof(IoGLUTData)));
  48
  49         DATA(self)->coroutine = IoCoroutine_new(state);
  50         //printf("GLUT coro = %p\n", DATA(self)->coroutine);
  51
  52         DATA(self)->eventTarget = NULL;
  53         DATA(self)->entryMessage      = GLUTMESSAGE("entry");
  54         DATA(self)->displayMessage    = GLUTMESSAGE("display");
  55         DATA(self)->keyboardMessage   = GLUTMESSAGE("keyboard");
  56         DATA(self)->keyboardUpMessage = GLUTMESSAGE("keyboardUp");
  57         DATA(self)->joystickMessage   = GLUTMESSAGE("joystick");
  58         DATA(self)->motionMessage     = GLUTMESSAGE("motion");
  59         DATA(self)->menuMessage       = GLUTMESSAGE("menu");
  60         DATA(self)->mouseMessage      = GLUTMESSAGE("mouse");
  61         DATA(self)->passiveMotionMessage = GLUTMESSAGE("passiveMotion");
  62         DATA(self)->reshapeMessage = GLUTMESSAGE("reshape");
  63         DATA(self)->specialMessage = GLUTMESSAGE("special");
  64         DATA(self)->timerMessage   = GLUTMESSAGE("timer");
  65
  66         DATA(self)->acceptsDropMessage = GLUTMESSAGE("acceptsDrop");
  67         DATA(self)->dragMessage   = GLUTMESSAGE("drag");
  68         DATA(self)->dropMessage   = GLUTMESSAGE("drop");
  69         DATA(self)->copyMessage   = GLUTMESSAGE("copy");
  70         DATA(self)->pasteMessage  = GLUTMESSAGE("paste");
  71         DATA(self)->deleteMessage = GLUTMESSAGE("delete");
  72         DATA(self)->nanoSleepPeriod = 1000000000/2;
  73
  74
  75
  76
  77         //printf("GLUT coro = %p\n", (void *)DATA(self)->coroutine);
  78         IoState_retain_(state, self);
  79         IoState_retain_(state, DATA(self)->coroutine);
  80         IoState_retain_(state, DATA(self)->displayMessage);
  81         IoState_retain_(state, DATA(self)->reshapeMessage);
  82         IoState_retain_(state, DATA(self)->timerMessage);
  83
  84
  85
  86         DATA(self)->j = IoSeq_newFloatArrayOfSize_(state, 0);
  87         DATA(self)->lastJ = UArray_new();
  88         UArray_setItemType_(DATA(self)->lastJ, CTYPE_float32_t);
  89
  90         IoState_registerProtoWithFunc_(state, self, IoGLUT_proto);
  91
  92
  93         //-----------------------------
  94
  95         IoState_retain_(state, DATA(self)->j);
  96
  97         IoState_retain_(state, DATA(self)->coroutine);
  98         IoState_retain_(state, DATA(self)->entryMessage);
  99         IoState_retain_(state, DATA(self)->displayMessage);
 100         IoState_retain_(state, DATA(self)->keyboardMessage);
 101         IoState_retain_(state, DATA(self)->keyboardUpMessage);
 102         IoState_retain_(state, DATA(self)->joystickMessage);
 103         IoState_retain_(state, DATA(self)->menuMessage);
 104         IoState_retain_(state, DATA(self)->mouseMessage);
 105         IoState_retain_(state, DATA(self)->motionMessage);
 106         IoState_retain_(state, DATA(self)->passiveMotionMessage);
 107         IoState_retain_(state, DATA(self)->reshapeMessage);
 108         IoState_retain_(state, DATA(self)->specialMessage);
 109         IoState_retain_(state, DATA(self)->timerMessage);
 110
 111         IoState_retain_(state, DATA(self)->acceptsDropMessage);
 112         IoState_retain_(state, DATA(self)->dragMessage);
 113         IoState_retain_(state, DATA(self)->dropMessage);
 114         IoState_retain_(state, DATA(self)->copyMessage);
 115         IoState_retain_(state, DATA(self)->pasteMessage);
 116         IoState_retain_(state, DATA(self)->deleteMessage);
 117
 118         IoGLUT_protoInit(self);
 119         return self;
 120 }
 121
 122 IoGLUT *IoGLUT_new(void *state)
 123 {
 124         return IoState_protoWithInitFunction_(state, IoGLUT_proto);
 125 }
 126
 127 void IoGLUT_free(IoGLUT *self)
 128 {
 129         /* add code to shut down GLUT */
 130         free(IoObject_dataPointer(self));
 131 }
 132
 133 void IoGLUT_mark(IoGLUT *self)
 134 {
 135         //printf("IoGLUT_mark\n");
 136
 137         if (DATA(self)->eventTarget)
 138         {
 139                 IoObject_shouldMark(DATA(self)->eventTarget);
 140         }
 141
 142         IoObject_shouldMark(DATA(self)->j);
 143
 144         IoObject_shouldMark(DATA(self)->coroutine);
 145         IoObject_shouldMark(DATA(self)->entryMessage);
 146         IoObject_shouldMark(DATA(self)->displayMessage);
 147         IoObject_shouldMark(DATA(self)->keyboardMessage);
 148         IoObject_shouldMark(DATA(self)->keyboardUpMessage);
 149         IoObject_shouldMark(DATA(self)->joystickMessage);
 150         IoObject_shouldMark(DATA(self)->menuMessage);
 151         IoObject_shouldMark(DATA(self)->mouseMessage);
 152         IoObject_shouldMark(DATA(self)->motionMessage);
 153         IoObject_shouldMark(DATA(self)->passiveMotionMessage);
 154         IoObject_shouldMark(DATA(self)->reshapeMessage);
 155         IoObject_shouldMark(DATA(self)->specialMessage);
 156         IoObject_shouldMark(DATA(self)->timerMessage);
 157
 158         IoObject_shouldMark(DATA(self)->acceptsDropMessage);
 159         IoObject_shouldMark(DATA(self)->dragMessage);
 160         IoObject_shouldMark(DATA(self)->dropMessage);
 161         IoObject_shouldMark(DATA(self)->copyMessage);
 162         IoObject_shouldMark(DATA(self)->pasteMessage);
 163         IoObject_shouldMark(DATA(self)->deleteMessage);
 164 }
 165
 166 /* ----------------------------------------------------------- */
 167
 168 IoObject *IoGLUT_rawClone(IoGLUT *self)
 169 {
 170         return IoState_protoWithInitFunction_(IOSTATE, IoGLUT_proto);
 171 }
 172
 173 /* ----------------------------------------------------------- */
 174
 175 IoObject *IoGLUT_glutInitDisplayMode(IoGLUT *self, IoObject *locals, IoMessage *m)
 176 {
 177         int mode = IoMessage_locals_intArgAt_(m, locals, 0);
 178         glutInitDisplayMode(mode);
 179         return self;
 180 }
 181
 182 IoObject *IoGLUT_glutInitWindowSize(IoGLUT *self, IoObject *locals, IoMessage *m)
 183 {
 184         int w  = IoMessage_locals_intArgAt_(m, locals, 0);
 185         int h = IoMessage_locals_intArgAt_(m, locals, 1);
 186         //printf("glutInitWindowSize(%i, %i)\n", w, h);
 187         glutInitWindowSize(w, h);
 188         return self;
 189 }
 190
 191 IoObject *IoGLUT_glutInitWindowPosition(IoGLUT *self, IoObject *locals, IoMessage *m)
 192 {
 193         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 194         int y = IoMessage_locals_intArgAt_(m, locals, 1);
 195         //printf("glutInitWindowPosition(%i, %i)\n", x, y);
 196         glutInitWindowPosition(x, y);
 197         return self;
 198 }
 199
 200 void IoGlutIdleFunc(void)
 201 {
 202         //IoState_yield(IoObject_state(proto));
 203 }
 204
 205 IoObject *IoGLUT_glutInit(IoGLUT *self, IoObject *locals, IoMessage *m)
 206 {
 207         IoState *state = IOSTATE;
 208         int argc = state->mainArgs->argc;
 209         UArray *ba = IoDirectory_CurrentWorkingDirectoryAsUArray();
 210         glutInit(&argc, (char **)(state->mainArgs->argv));
 211         IoDirectory_SetCurrentWorkingDirectory(UArray_asCString(ba));
 212         UArray_free(ba);
 213
 214     //glutIdleFunc(IoGlutIdleFunc);
 215     //glutTimerFunc((unsigned int)10, IoGlutTimerFunc, -1);
 216         return self;
 217 }
 218
 219 IoObject *IoGLUT_glutInitDisplayString(IoGLUT *self, IoObject *locals, IoMessage *m)
 220 {
 221         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 222         glutInitDisplayString(IoSeq_asCString(s));
 223         return self;
 224 }
 225
 226 IoObject *IoGLUT_glutCreateWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 227 {
 228         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 229         int windowId = glutCreateWindow(IoSeq_asCString(s));
 230         return IONUMBER(windowId);
 231 }
 232
 233 IoObject *IoGLUT_glutCreateSubWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 234 {
 235         int win = IoMessage_locals_intArgAt_(m, locals, 0);
 236         int x = IoMessage_locals_intArgAt_(m, locals, 1);
 237         int y = IoMessage_locals_intArgAt_(m, locals, 2);
 238         int w = IoMessage_locals_intArgAt_(m, locals, 3);
 239         int h = IoMessage_locals_intArgAt_(m, locals, 4);
 240         return IONUMBER(glutCreateSubWindow(win, x, y, w, h));
 241 }
 242
 243 IoObject *IoGLUT_glutSetWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 244 {
 245         int win = IoMessage_locals_intArgAt_(m, locals, 0);
 246         glutSetWindow(win);
 247         return self;
 248 }
 249
 250 IoObject *IoGLUT_glutGetWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 251 {
 252         return IONUMBER(glutGetWindow());
 253 }
 254
 255 IoObject *IoGLUT_glutGet(IoGLUT *self, IoObject *locals, IoMessage *m)
 256 {
 257         GLenum n = IoMessage_locals_intArgAt_(m, locals, 0);
 258         return IONUMBER(glutGet(n));
 259 }
 260
 261 IoObject *IoGLUT_glutDestroyWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 262 {
 263         int win = IoMessage_locals_intArgAt_(m, locals, 0);
 264         glutDestroyWindow(win);
 265         return self;
 266 }
 267
 268 IoObject *IoGLUT_glutPositionWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 269 {
 270         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 271         int y = IoMessage_locals_intArgAt_(m, locals, 1);
 272         glutPositionWindow(x, y);
 273         return self;
 274 }
 275
 276 IoObject *IoGLUT_glutReshapeWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 277 {
 278         int w = IoMessage_locals_intArgAt_(m, locals, 0);
 279         int h = IoMessage_locals_intArgAt_(m, locals, 1);
 280         glutReshapeWindow(w, h);
 281         return self;
 282 }
 283
 284 IoObject *IoGLUT_glutPopWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 285 {
 286         glutPopWindow(); return self;
 287 }
 288
 289 IoObject *IoGLUT_glutPushWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 290 {
 291         glutPushWindow();
 292         return self;
 293 }
 294
 295 IoObject *IoGLUT_glutShowWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 296 {
 297         glutShowWindow();
 298         return self;
 299 }
 300
 301 IoObject *IoGLUT_glutHideWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 302 {
 303         glutHideWindow();
 304         return self;
 305 }
 306
 307 IoObject *IoGLUT_glutIconifyWindow(IoGLUT *self, IoObject *locals, IoMessage *m)
 308 {
 309         glutIconifyWindow();
 310         return self;
 311 }
 312
 313 IoObject *IoGLUT_glutSetWindowTitle(IoGLUT *self, IoObject *locals, IoMessage *m)
 314 {
 315         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 316         glutSetWindowTitle(CSTRING(s));
 317         return self;
 318 }
 319
 320 IoObject *IoGLUT_glutSetIconTitle(IoGLUT *self, IoObject *locals, IoMessage *m)
 321 {
 322         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 323         glutSetIconTitle(CSTRING(s));
 324         return self;
 325 }
 326
 327 IoObject *IoGLUT_glutEventTarget_(IoGLUT *self, IoObject *locals, IoMessage *m)
 328 {
 329         DATA(proto)->eventTarget = IOREF(IoMessage_locals_valueArgAt_(m, locals, 0));
 330         return self;
 331 }
 332
 333 // events
 334
 335 void IoGlutDisplayFunc(void)
 336 {
 337         //printf("IoGlutDisplayFunc\n");
 338         IoState_pushRetainPool(IoObject_state(proto));
 339
 340         IoGLUT_tryCallback(proto, DATA(proto)->displayMessage);
 341
 342         IoState_popRetainPool(IoObject_state(proto));
 343 }
 344
 345 IoObject *IoGLUT_glutDisplayFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 346 {
 347         glutDisplayFunc(IoGlutDisplayFunc);
 348         return self;
 349 }
 350
 351 void IoGlutKeyboardFunc(unsigned char key, int xv, int yv)
 352 {
 353         IoState_pushRetainPool(IoObject_state(proto));
 354         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardMessage, 0, (int)key);
 355         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardMessage, 1, xv);
 356         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardMessage, 2, yv);
 357
 358         IoGLUT_tryCallback(proto, DATA(proto)->keyboardMessage);
 359
 360         IoState_popRetainPool(IoObject_state(proto));
 361 }
 362
 363 IoObject *IoGLUT_glutKeyboardFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 364 {
 365         glutKeyboardFunc(IoGlutKeyboardFunc);
 366         return self;
 367 }
 368
 369 void IoGlutSpecialFunc(int key, int xv, int yv)
 370 {
 371         IoState_pushRetainPool(IoObject_state(proto));
 372         IoMessage_setCachedArg_toInt_(DATA(proto)->specialMessage, 0, (int)key);
 373         IoMessage_setCachedArg_toInt_(DATA(proto)->specialMessage, 1, xv);
 374         IoMessage_setCachedArg_toInt_(DATA(proto)->specialMessage, 2, yv);
 375
 376         IoGLUT_tryCallback(proto, DATA(proto)->specialMessage);
 377
 378         IoState_popRetainPool(IoObject_state(proto));
 379 }
 380
 381 IoObject *IoGLUT_glutSpecialFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 382 {
 383         glutSpecialFunc(IoGlutSpecialFunc);
 384         return self;
 385 }
 386
 387 void IoGlutKeyboardUpFunc(unsigned char key, int xv, int yv)
 388 {
 389         IoState_pushRetainPool(IoObject_state(proto));
 390         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardUpMessage, 0, (int)key);
 391         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardUpMessage, 1, xv);
 392         IoMessage_setCachedArg_toInt_(DATA(proto)->keyboardUpMessage, 2, yv);
 393
 394         IoGLUT_tryCallback(proto, DATA(proto)->keyboardUpMessage);
 395
 396         IoState_popRetainPool(IoObject_state(proto));
 397 }
 398
 399 IoObject *IoGLUT_glutKeyboardUpFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 400 {
 401 #if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13)
 402         glutKeyboardUpFunc(IoGlutKeyboardUpFunc);
 403         return self;
 404 #endif
 405 }
 406
 407 IoObject *IoGLUT_glutGetModifiers(IoGLUT *self, IoObject *locals, IoMessage *m)
 408 {
 409         return IONUMBER(glutGetModifiers());
 410 }
 411
 412 void IoGlutEntryFunc(int state)
 413 {
 414         IoState_pushRetainPool(IoObject_state(proto));
 415         IoMessage_setCachedArg_toInt_(DATA(proto)->entryMessage, 0, state);
 416
 417         IoGLUT_tryCallback(proto, DATA(proto)->entryMessage);
 418
 419         IoState_popRetainPool(IoObject_state(proto));
 420 }
 421
 422 IoObject *IoGLUT_glutEntryFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 423 {
 424         glutEntryFunc(IoGlutEntryFunc); return self;
 425 }
 426
 427 void IoGlutMotionFunc(int xv, int yv)
 428 {
 429         IoState_pushRetainPool(IoObject_state(proto));
 430
 431         {
 432                 IoMessage_setCachedArg_toInt_(DATA(proto)->motionMessage, 0, xv);
 433                 IoMessage_setCachedArg_toInt_(DATA(proto)->motionMessage, 1, yv);
 434
 435                 IoGLUT_tryCallback(proto, DATA(proto)->motionMessage);
 436         }
 437
 438         IoState_popRetainPool(IoObject_state(proto));
 439 }
 440
 441 IoObject *IoGLUT_glutMotionFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 442 {
 443         glutMotionFunc(IoGlutMotionFunc);
 444         return self;
 445 }
 446
 447 void IoGlutPassiveMotionFunc(int xv, int yv)
 448 {
 449         IoState_pushRetainPool(IoObject_state(proto));
 450
 451         {
 452                 IoMessage_setCachedArg_toInt_(DATA(proto)->passiveMotionMessage, 0, xv);
 453                 IoMessage_setCachedArg_toInt_(DATA(proto)->passiveMotionMessage, 1, yv);
 454
 455                 IoGLUT_tryCallback(proto, DATA(proto)->passiveMotionMessage);
 456         }
 457
 458         IoState_popRetainPool(IoObject_state(proto));
 459 }
 460
 461 IoObject *IoGLUT_glutPassiveMotionFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 462 {
 463         glutPassiveMotionFunc(IoGlutPassiveMotionFunc);
 464         return self;
 465 }
 466
 467 void IoGlutMouseFunc(int button, int state, int xv, int yv)
 468 {
 469         IoState_pushRetainPool(IoObject_state(proto));
 470
 471         {
 472                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 0, button);
 473                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 1, state);
 474                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 2, xv);
 475                 IoMessage_setCachedArg_toInt_(DATA(proto)->mouseMessage, 3, yv);
 476
 477                 IoGLUT_tryCallback(proto, DATA(proto)->mouseMessage);
 478         }
 479
 480         IoState_popRetainPool(IoObject_state(proto));
 481 }
 482
 483 IoObject *IoGLUT_glutMouseFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 484 {
 485         glutMouseFunc(IoGlutMouseFunc);
 486         return self;
 487 }
 488
 489 void IoGlutReshapeFunc(int width, int height)
 490 {
 491         //printf("IoGlutReshapeFunc\n");
 492         IoState_pushRetainPool(IoObject_state(proto));
 493         {
 494                 IoMessage_setCachedArg_toInt_(DATA(proto)->reshapeMessage, 0, width?width:1);
 495                 IoMessage_setCachedArg_toInt_(DATA(proto)->reshapeMessage, 1, height?height:1);
 496
 497                 IoGLUT_tryCallback(proto, DATA(proto)->reshapeMessage);
 498         }
 499
 500         IoState_popRetainPool(IoObject_state(proto));
 501 }
 502
 503 IoObject *IoGLUT_glutReshapeFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 504 {
 505         glutReshapeFunc(IoGlutReshapeFunc);
 506         return self;
 507 }
 508
 509 void IoGlutTimerFunc(int vv)
 510 {
 511         IoState *state = IoObject_state(proto);
 512
 513         //printf("IoGlutTimerFunc\n");
 514
 515         IoState_pushRetainPool(state);
 516
 517         if (vv == -1)
 518         {
 519                 //IoState_yield(IoObject_state(proto));
 520                 glutTimerFunc((unsigned int)100, IoGlutTimerFunc, -1);
 521         }
 522         else
 523         {
 524                 IoObject *m = DATA(proto)->timerMessage;
 525                 IoMessage_setCachedArg_toInt_(m, 0, vv);
 526                 IoGLUT_tryCallback(proto, m);
 527         }
 528         IoState_popRetainPool(state);
 529 }
 530
 531 IoObject *IoGLUT_glutTimerFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 532 {
 533         unsigned int msecs = IoMessage_locals_longArgAt_(m, locals, 0);
 534         int v = IoMessage_locals_intArgAt_(m, locals, 1);
 535         //printf("IoGLUT_glutTimerFunc msecs %i v %i\n", msecs, v);
 536         glutTimerFunc((unsigned int)msecs, IoGlutTimerFunc, v);
 537         return self;
 538 }
 539
 540 IoObject *IoGLUT_tryCallback(IoGLUT *self, IoMessage *m)
 541 {
 542         IoState *state = IoObject_state(proto);
 543         IoObject *tryCoro = DATA(self)->coroutine;
 544         IoObject *t = DATA(proto)->eventTarget;
 545         IoObject *result = state->ioNil;
 546
 547         //printf("IoGLUT_tryCallback(self, %p)\n", (void *)m);
 548
 549         if (t)
 550         {
 551                 //result = IoState_tryToPerform(state, t, t, m);
 552
 553
 554                 //IoCoroutine_try(tryCoro, t, t, m);
 555                 IoMessage_locals_performOn_(m, t, t);
 556
 557                 if (IoCoroutine_rawException(tryCoro) != state->ioNil)
 558                 {
 559                         IoState_exception_(state, tryCoro);
 560                 }
 561
 562                 IoCoroutine_clearStack(tryCoro);
 563                 return IoCoroutine_rawResult(tryCoro);
 564         }
 565
 566         return result;
 567 }
 568
 569 #ifdef GLUT_KEY_REPEAT_ON
 570 IoObject *IoGLUT_glutIgnoreKeyRepeat(IoGLUT *self, IoObject *locals, IoMessage *m)
 571 {
 572         int v = IoMessage_locals_intArgAt_(m, locals, 0);
 573         glutIgnoreKeyRepeat(v);
 574         return self;
 575 }
 576 #endif
 577
 578 IoObject *IoGLUT_glutMainLoop(IoGLUT *self, IoObject *locals, IoMessage *m)
 579 {
 580         glutMainLoop();
 581         return self;
 582 }
 583
 584 IoObject *IoGLUT_glutPostRedisplay(IoGLUT *self, IoObject *locals, IoMessage *m)
 585 {
 586         glutPostRedisplay();
 587         return self;
 588 }
 589
 590 IoObject *IoGLUT_glutSwapBuffers(IoGLUT *self, IoObject *locals, IoMessage *m)
 591 {
 592         glutSwapBuffers();
 593         return self;
 594 }
 595
 596 IoObject *IoGLUT_glutSolidCone(IoGLUT *self, IoObject *locals, IoMessage *m)
 597 {
 598         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 599         GLdouble height = IoMessage_locals_intArgAt_(m, locals, 1);
 600         GLint slices = IoMessage_locals_intArgAt_(m, locals, 2);
 601         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 3);
 602         glutSolidCone(radius, height, slices, stacks);
 603         return self;
 604 }
 605
 606 IoObject *IoGLUT_glutWireCone(IoGLUT *self, IoObject *locals, IoMessage *m)
 607 {
 608         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 609         GLdouble height = IoMessage_locals_intArgAt_(m, locals, 1);
 610         GLint slices = IoMessage_locals_intArgAt_(m, locals, 2);
 611         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 3);
 612         glutWireCone(radius, height, slices, stacks);
 613         return self;
 614 }
 615
 616 IoObject *IoGLUT_glutSolidSphere(IoGLUT *self, IoObject *locals, IoMessage *m)
 617 {
 618         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 619         GLint slices = IoMessage_locals_intArgAt_(m, locals, 1);
 620         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 2);
 621         glutSolidSphere(radius, slices, stacks);
 622         return self;
 623 }
 624
 625 IoObject *IoGLUT_glutWireSphere(IoGLUT *self, IoObject *locals, IoMessage *m)
 626 {
 627         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 628         GLint slices = IoMessage_locals_intArgAt_(m, locals, 1);
 629         GLint stacks = IoMessage_locals_intArgAt_(m, locals, 2);
 630         glutWireSphere(radius, slices, stacks);
 631         return self;
 632 }
 633
 634 IoObject *IoGLUT_glutSolidTorus(IoGLUT *self, IoObject *locals, IoMessage *m)
 635 {
 636         GLdouble innerRadius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 637         GLdouble outerRadius = IoMessage_locals_doubleArgAt_(m, locals, 1);
 638         GLint nsides = IoMessage_locals_intArgAt_(m, locals, 2);
 639         GLint rings = IoMessage_locals_intArgAt_(m, locals, 3);
 640         glutSolidTorus(innerRadius, outerRadius, nsides, rings);
 641         return self;
 642 }
 643
 644 IoObject *IoGLUT_glutWireTorus(IoGLUT *self, IoObject *locals, IoMessage *m)
 645 {
 646         GLdouble innerRadius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 647         GLdouble outerRadius = IoMessage_locals_doubleArgAt_(m, locals, 1);
 648         GLint nsides = IoMessage_locals_intArgAt_(m, locals, 2);
 649         GLint rings = IoMessage_locals_intArgAt_(m, locals, 3);
 650         glutWireTorus(innerRadius, outerRadius, nsides, rings);
 651         return self;
 652 }
 653
 654 IoObject *IoGLUT_glutSolidDodecahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 655 {
 656         glutSolidDodecahedron();
 657         return self;
 658 }
 659
 660 IoObject *IoGLUT_glutWireDodecahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 661 {
 662         glutWireDodecahedron();
 663         return self;
 664 }
 665
 666 IoObject *IoGLUT_glutSolidOctahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 667 {
 668         glutSolidOctahedron();
 669         return self;
 670 }
 671
 672 IoObject *IoGLUT_glutWireOctahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 673 {
 674         glutWireOctahedron();
 675         return self;
 676 }
 677
 678 IoObject *IoGLUT_glutSolidTetrahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 679 {
 680         glutSolidTetrahedron();
 681         return self;
 682 }
 683
 684 IoObject *IoGLUT_glutWireTetrahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 685 {
 686         glutWireTetrahedron();
 687         return self;
 688 }
 689
 690 IoObject *IoGLUT_glutSolidIcosahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 691 {
 692         glutSolidIcosahedron();
 693         return self;
 694 }
 695
 696 IoObject *IoGLUT_glutWireIcosahedron(IoGLUT *self, IoObject *locals, IoMessage *m)
 697 {
 698         glutWireIcosahedron();
 699         return self;
 700 }
 701
 702 IoObject *IoGLUT_glutSolidTeapot(IoGLUT *self, IoObject *locals, IoMessage *m)
 703 {
 704         GLdouble r = IoMessage_locals_doubleArgAt_(m, locals, 0);
 705         glutSolidTeapot(r);
 706         return self;
 707 }
 708
 709 IoObject *IoGLUT_glutWireTeapot(IoGLUT *self, IoObject *locals, IoMessage *m)
 710 {
 711         GLdouble r = IoMessage_locals_doubleArgAt_(m, locals, 0);
 712         glutWireTeapot(r);
 713         return self;
 714 }
 715
 716 IoObject *IoGLUT_glutSolidCube(IoGLUT *self, IoObject *locals, IoMessage *m)
 717 {
 718         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 719         glutSolidCube(radius);
 720         return self;
 721 }
 722
 723 IoObject *IoGLUT_glutWireCube(IoGLUT *self, IoObject *locals, IoMessage *m)
 724 {
 725         GLdouble radius = IoMessage_locals_doubleArgAt_(m, locals, 0);
 726         glutWireCube(radius);
 727         return self;
 728 }
 729
 730 IoObject *IoGLUT_glutStrokeCharacter(IoGLUT *self, IoObject *locals, IoMessage *m)
 731 {
 732         int fontNum = IoMessage_locals_intArgAt_(m, locals, 0);
 733         char c = IoMessage_locals_intArgAt_(m, locals, 1);
 734         void *font = GLUT_STROKE_ROMAN;
 735         if (fontNum) font = GLUT_STROKE_MONO_ROMAN;
 736         glutStrokeCharacter(font, c);
 737         return self;
 738 }
 739
 740 IoObject *IoGLUT_glutStrokeString(IoGLUT *self, IoObject *locals, IoMessage *m)
 741 {
 742         int fontNum = IoMessage_locals_intArgAt_(m, locals, 0);
 743         IoSymbol *string = IoMessage_locals_seqArgAt_(m, locals, 1);
 744         char *s = CSTRING(string);
 745         void *font = GLUT_STROKE_ROMAN;
 746         if (fontNum) font = GLUT_STROKE_MONO_ROMAN;
 747
 748         while (*s)
 749         {
 750                 glutStrokeCharacter(font, *s);
 751                 s++;
 752         }
 753
 754         return self;
 755 }
 756
 757 /* --- GLUT game mode ----------------------------------------------------- */
 758
 759 IoObject *IoGLUT_glutFullScreen(IoGLUT *self, IoObject *locals, IoMessage *m)
 760 {
 761         glutFullScreen();
 762         return self;
 763 }
 764
 765 #ifdef GLUT_GAME_MODE_ACTIVE
 766
 767 IoObject *IoGLUT_glutEnterGameMode(IoGLUT *self, IoObject *locals, IoMessage *m)
 768 {
 769         glutEnterGameMode();
 770         return self;
 771 }
 772
 773 IoObject *IoGLUT_glutLeaveGameMode(IoGLUT *self, IoObject *locals, IoMessage *m)
 774 {
 775         glutLeaveGameMode();
 776         return self;
 777 }
 778
 779 IoObject *IoGLUT_glutWarpPointer(IoGLUT *self, IoObject *locals, IoMessage *m)
 780 {
 781         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 782         int y = IoMessage_locals_intArgAt_(m, locals, 1);
 783         glutWarpPointer(x, y);
 784         return self;
 785 }
 786
 787 IoObject *IoGLUT_glutGameModeString(IoGLUT *self, IoObject *locals, IoMessage *m)
 788 {
 789         IoSymbol *s = IoMessage_locals_symbolArgAt_(m, locals, 0);
 790         glutGameModeString(IoSeq_asCString(s));
 791         return self;
 792 }
 793
 794 #endif
 795
 796 IoObject *IoGLUT_glutSetCursor(IoGLUT *self, IoObject *locals, IoMessage *m)
 797 {
 798         int x = IoMessage_locals_intArgAt_(m, locals, 0);
 799         glutSetCursor(x);
 800         return self;
 801 }
 802
 803 // Menus --------------------------------------------------------------------
 804
 805 void IoGlutMenuFunc(int menuId)
 806 {
 807         IoState_pushRetainPool(IoObject_state(proto));
 808
 809         {
 810                 IoMessage_setCachedArg_toInt_(DATA(proto)->menuMessage, 0, menuId);
 811                 IoGLUT_tryCallback(proto, DATA(proto)->menuMessage);
 812         }
 813
 814         IoState_popRetainPool(IoObject_state(proto));
 815 }
 816
 817 IoObject *IoGLUT_glutCreateMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 818 {
 819         int menuId = glutCreateMenu(IoGlutMenuFunc);
 820         return IONUMBER(menuId);
 821 }
 822
 823 IoObject *IoGLUT_glutSetMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 824 {
 825         int menuId = IoMessage_locals_intArgAt_(m, locals, 0);
 826         glutSetMenu(menuId);
 827         return self;
 828 }
 829
 830 IoObject *IoGLUT_glutGetMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 831 {
 832         return IONUMBER(glutGetMenu());
 833 }
 834
 835 IoObject *IoGLUT_glutDestroyMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 836 {
 837         int menuId = IoMessage_locals_intArgAt_(m, locals, 0);
 838         glutDestroyMenu(menuId);
 839         return self;
 840 }
 841
 842 IoObject *IoGLUT_glutAddMenuEntry(IoGLUT *self, IoObject *locals, IoMessage *m)
 843 {
 844         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 0);
 845         int entryId = IoMessage_locals_intArgAt_(m, locals, 1);
 846         glutAddMenuEntry(CSTRING(name), entryId);
 847         return self;
 848 }
 849
 850 IoObject *IoGLUT_glutAddSubMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 851 {
 852         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 0);
 853         int entryId = IoMessage_locals_intArgAt_(m, locals, 1);
 854         glutAddSubMenu(CSTRING(name), entryId);
 855         return self;
 856 }
 857
 858 IoObject *IoGLUT_glutChangeToMenuEntry(IoGLUT *self, IoObject *locals, IoMessage *m)
 859 {
 860         int entryId = IoMessage_locals_intArgAt_(m, locals, 0);
 861         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 1);
 862         int value = IoMessage_locals_intArgAt_(m, locals, 2);
 863         glutChangeToMenuEntry(entryId, CSTRING(name), value);
 864         return self;
 865 }
 866
 867 // GLUT_MENU_NUM_ITEMS
 868
 869 IoObject *IoGLUT_glutChangeToSubMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 870 {
 871         int entryId = IoMessage_locals_intArgAt_(m, locals, 0);
 872         IoSymbol *name = IoMessage_locals_symbolArgAt_(m, locals, 1);
 873         int value = IoMessage_locals_intArgAt_(m, locals, 2);
 874         glutChangeToSubMenu(entryId, CSTRING(name), value);
 875         return self;
 876 }
 877
 878 IoObject *IoGLUT_glutRemoveMenuItem(IoGLUT *self, IoObject *locals, IoMessage *m)
 879 {
 880         int entry = IoMessage_locals_intArgAt_(m, locals, 0);
 881         glutRemoveMenuItem(entry);
 882         return self;
 883 }
 884
 885 IoObject *IoGLUT_glutAttachMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 886 {
 887         int button = IoMessage_locals_intArgAt_(m, locals, 0);
 888         glutAttachMenu(button);
 889         return self;
 890 }
 891
 892 IoObject *IoGLUT_glutDetachMenu(IoGLUT *self, IoObject *locals, IoMessage *m)
 893 {
 894         int button = IoMessage_locals_intArgAt_(m, locals, 0);
 895         glutAttachMenu(button);
 896         return self;
 897 }
 898
 899 // Joystick --------------------------------------------------------------------
 900
 901 void IoGlutJoystickFunc(unsigned int buttonMask, int x, int y, int z)
 902 {
 903         UArray *j = IoSeq_rawUArray(DATA(proto)->j);
 904         UArray *lastJ = DATA(proto)->lastJ;
 905         vec3f v = {x, y, z};
 906
 907         IoSeq_setVec3f_(DATA(proto)->j, v);
 908         UArray_subtract_(lastJ, j);
 909
 910         if (DATA(proto)->lastJoystickButton != buttonMask || UArray_sumAsDouble(lastJ) != 0.0) // only send callback if a change occurs
 911         {
 912                 //printf("sum %f\n", (float)Vector_sum(lastJ));
 913                 //printf("b %i %i\n", (int)buttonMask, (int)DATA(proto)->lastJoystickButton);
 914                 IoState_pushRetainPool(IoObject_state(proto));
 915
 916                 {
 917                         IoMessage_setCachedArg_toInt_(DATA(proto)->joystickMessage, 0, (int)buttonMask);
 918                         IoMessage_setCachedArg_to_(DATA(proto)->joystickMessage, 1, DATA(proto)->j);
 919                         IoGLUT_tryCallback(proto, DATA(proto)->joystickMessage);
 920                 }
 921
 922                 DATA(proto)->lastJoystickButton = buttonMask;
 923
 924                 IoState_popRetainPool(IoObject_state(proto));
 925         }
 926
 927         UArray_copy_(lastJ, j);
 928 }
 929
 930 /*
 931 IoObject *IoGLUT_glutInitJoystick(IoGLUT *self, IoObject *locals, IoMessage *m)
 932 {
 933         IoSymbol *deviceName = IoMessage_locals_symbolArgAt_(m, locals, 0);
 934         // deviceName something like /dev/input/js0
 935         glutInitJoystick(IoGlutJoystickFunc, CSTRING(deviceName));
 936         return self;
 937 }
 938 */
 939 IoObject *IoGLUT_glutJoystickFunc(IoGLUT *self, IoObject *locals, IoMessage *m)
 940 {
 941         int pollInterval = IoMessage_locals_intArgAt_(m, locals, 0);
 942         glutJoystickFunc(IoGlutJoystickFunc, pollInterval);
 943         return self;
 944 }
 945
 946
 947 /* -------------------------------------------------------------------*/
 948
 949 /* can use NULL tag since the methods don't access DATA(self) - they use DATA(proto) instead */
 950 #define IOCFUNCTION_GLUT(func) IOCFUNCTION(func, NULL)
 951
 952 #include "IoGLUTconst.h"
 953 #include "IoGLUTfunc.h"
 954
 955 void IoGLUT_protoInit(IoGLUT *self)
 956 {
 957         IoObject_setSlot_to_(self,IOSYMBOL("clone"), IOCFUNCTION_GLUT(IoObject_self));
 958
 959         /* GLUT Constants */
 960         {
 961                 t_ioGLUT_constTable *curpos=ioGLUT_constTable;
 962                 while (curpos->name)
 963                 {
 964                         IoObject_setSlot_to_(self,
 965                                                          IOSYMBOL(curpos->name),
 966                                                          IONUMBER(curpos->value));
 967                         curpos++;
 968                 }
 969         }
 970
 971         /* GLUT Functions */
 972         {
 973                 t_ioGLUT_funcTable *curpos=ioGLUT_funcTable;
 974
 975                 while (curpos->name)
 976                 {
 977                         IoCFunction *f = IoCFunction_newWithFunctionPointer_tag_name_(IOSTATE, curpos->func, NULL, curpos->name);
 978                         IoObject_setSlot_to_(self, IOSYMBOL(curpos->name), f);
 979                         curpos++;
 980                 }
 981         }
 982 }
 983
 984 // --- Extra In --------------------------------------------------------------
 985
 986 int IoGlutAcceptsDropFunc(
 987                                          int x,
 988                                          int y,
 989                                          const char *type,
 990                                          const unsigned char *data,
 991                                          int dataLength)
 992 {
 993         int result = 0;
 994         IoState *state = IoObject_state(proto);
 995         IoState_pushRetainPool(state);
 996
 997         {
 998                 IoMessage *m = DATA(proto)->acceptsDropMessage;
 999                 IoSymbol *typeString = IoState_symbolWithCString_(state, (char *)type);
1000                 IoSeq *dataBuffer = IoSeq_newWithData_length_(state, (unsigned char *)data, dataLength);
1001
1002                 IoMessage_setCachedArg_toInt_(m, 0, x);
1003                 IoMessage_setCachedArg_toInt_(m, 1, y);
1004                 IoMessage_setCachedArg_to_(m, 2, typeString);
1005                 IoMessage_setCachedArg_to_(m, 3, dataBuffer);
1006
1007                 if (DATA(proto)->eventTarget)
1008                 {
1009                         IoObject *r = IoGLUT_tryCallback(proto, m);
1010 ;
1011                         if (r && ISNUMBER(r))
1012                         {
1013                                 result = CNUMBER(r);
1014                         }
1015                 }
1016         }
1017
1018         IoState_popRetainPool(state);
1019         return result;
1020 }
1021
1022 void IoGlutDropFunc(
1023                                 int x,
1024                                 int y,
1025                                 const char *type,
1026                                 const unsigned char *data,
1027                                 int dataLength)
1028 {
1029         IoState *state = IoObject_state(proto);
1030         IoState_pushRetainPool(state);
1031
1032         {
1033                 IoMessage *m = DATA(proto)->dropMessage;
1034                 IoSymbol *typeString = IoState_symbolWithCString_(state, (char *)type);
1035                 IoSeq *dataBuffer = IoSeq_newWithData_length_(state, (unsigned char *)data, dataLength);
1036
1037                 IoMessage_setCachedArg_toInt_(m, 0, x);
1038                 IoMessage_setCachedArg_toInt_(m, 1, y);
1039                 IoMessage_setCachedArg_to_(m, 2, typeString);
1040                 IoMessage_setCachedArg_to_(m, 3, dataBuffer);
1041
1042                 IoGLUT_tryCallback(proto, m);
1043         }
1044
1045         IoState_popRetainPool(state);
1046 }
1047
1048 void IoGlutPasteFunc(
1049                                  const char *type,
1050                                  const unsigned char *data,
1051                                  int dataLength)
1052 {
1053         IoState *state = IoObject_state(proto);
1054         IoState_pushRetainPool(state);
1055
1056         {
1057                 IoMessage *m = DATA(proto)->pasteMessage;
1058                 IoSymbol *typeString = IoState_symbolWithCString_(state, (char *)type);
1059                 IoSeq *dataBuffer = IoSeq_newWithData_length_(state, (unsigned char *)data, dataLength);
1060
1061                 IoMessage_setCachedArg_to_(m, 0, typeString);
1062                 IoMessage_setCachedArg_to_(m, 1, dataBuffer);
1063
1064                 IoGLUT_tryCallback(proto, m);
1065         }
1066
1067         IoState_popRetainPool(IoObject_state(proto));
1068 }
1069
1070 void IoGlutDeleteFunc(void)
1071 {
1072         IoState *state = IoObject_state(proto);
1073         IoState_pushRetainPool(state);
1074         IoGLUT_tryCallback(proto, DATA(proto)->deleteMessage);
1075         IoState_popRetainPool(state);
1076 }
1077
1078
1079 // --- Extra Out --------------------------------------------------------------
1080
1081 void IoGLUT_setDragCallback_(IoGLUT *self, DragCallback *func)
1082 {
1083         DATA(self)->dragCallback = func;
1084 }
1085
1086 IoObject *IoGLUT_drag(IoGLUT *self, IoObject *locals, IoMessage *m)
1087 {
1088         int x = IoMessage_locals_intArgAt_(m, locals, 0);
1089         int y = IoMessage_locals_intArgAt_(m, locals, 1);
1090         IoSymbol *type = IoMessage_locals_symbolArgAt_(m, locals, 2);
1091         IoSeq *buffer = IoMessage_locals_mutableSeqArgAt_(m, locals, 3);
1092
1093         if (DATA(self)->dragCallback)
1094         {
1095                 (DATA(self)->dragCallback)(DATA(self)->callbackContext,
1096                                                           x,
1097                                                           y,
1098                                                           CSTRING(type),
1099                                                           IoSeq_rawBytes(buffer),
1100                                                           IoSeq_rawSize(buffer));
1101         }
1102
1103         return IONIL(self);
1104 }
1105
1106 void IoGLUT_setCopyCallback_(IoGLUT *self, CopyCallback *func)
1107 {
1108         DATA(self)->copyCallback = func;
1109 }
1110
1111 IoObject *IoGLUT_copy(IoGLUT *self, IoObject *locals, IoMessage *m)
1112 {
1113         IoSymbol *type = IoMessage_locals_symbolArgAt_(m, locals, 0);
1114         IoSeq *buffer = IoMessage_locals_mutableSeqArgAt_(m, locals, 1);
1115
1116         if (DATA(self)->copyCallback)
1117         {
1118                 (DATA(self)->copyCallback)(DATA(self)->callbackContext,
1119                                                           CSTRING(type),
1120                                                           IoSeq_rawBytes(buffer),
1121                                                           IoSeq_rawSize(buffer));
1122         }
1123
1124         return IONIL(self);
1125 }
1126