home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / GLOVE / OBJGLV.ZIP / SRC / DEMO4B / GLOVEPTR.CPP < prev    next >
C/C++ Source or Header  |  1993-05-11  |  7KB  |  249 lines
  1. // Glove pointer device
  2.  
  3. // Written by Dave Stampe, August 1992
  4.  
  5. // Copyright 1992 by Dave Stampe and Bernie Roehl.
  6. // May be freely used to write software for release into the public domain;
  7. // all commercial endeavours MUST contact Bernie Roehl and Dave Stampe
  8. // for permission to incorporate any part of this software into their
  9. // products!
  10.  
  11.  
  12. #include <stdio.h>
  13. #include <dos.h>
  14. #include <conio.h>
  15.  
  16. #include "rend386.hpp"
  17. #include "segasupp.hpp"
  18. #include "pointer.hpp"
  19. #include "intmath.h"
  20. #include "userint.hpp"
  21. #include "keyboard.hpp"
  22. #include "demo4.hpp"
  23.  
  24. #include <string.h>
  25. #include "smooth.hpp"
  26. #include "ini.hpp"
  27. #include "rendgest.hpp"
  28. #include "gestsys.hpp"
  29.  
  30. // INTERNAL GLOVE SETUP
  31.  
  32. static PDRIVER *glove_device;
  33.  
  34. extern int stereo_type; // required for proper int. initialization
  35.  
  36. #define sub_exit        atexit
  37.  
  38. static rawGlove * g_driver_ptr[2] = {NULL, NULL};
  39.  
  40. void gloveptr_quit()
  41. {
  42.     pointer_quit(glove_device);
  43. }
  44.  
  45. RendGestSet * gestset[2] = {NULL, NULL};
  46. GestureSystem * gestsys[2] = {NULL, NULL};
  47.  
  48. PDRIVER *gloveptr_init(char *gname, int which)
  49. {
  50.     PDRIVER *p;
  51.  
  52.     p = pointer_init(P_IS3DG | P_IS6DG, gname, which); // setup glove device
  53.     if (p==NULL) return NULL;
  54.  
  55.     glove_device = p;
  56.  
  57.     return p;
  58. }
  59.  
  60. void gloveptr_setup(PDRIVER * p, long sx, long sy, long sz, long srx, long sry, long srz)
  61. {
  62.     POINTER x;
  63.  
  64.     init_pointer(&x); // so that defaults are OK
  65.     // use abs. glove motion
  66.     pointer_abscale(p, sx, sy, sz, srx, sry, srz);
  67.     set_mouse_limits(p, screeninfo->xmax, screeninfo->ymax);
  68.     while (!pointer_read(p, &x));
  69.     while (!pointer_read(p, &x)); // save current position
  70.     mouse_read(p, NULL, NULL, NULL);
  71.     return;
  72. }
  73.  
  74.  
  75. // GLOVE POINTER DRIVER
  76.  
  77. pconfig glove_pconfig = {
  78.     5*65536L, 5*65536L, -15*65536L, // position res: mm/tick in <16.16>
  79.     120, 120, 120, -120, -120, -120, // xyz ranges:
  80.     0, -30*65536L, 0,
  81.     0, 0, 0, 120, 11, 120, // some rotation (swing emulation)
  82.     320, 200, // mouse emulation limits (writable)
  83.     P_HASX | P_HASY | P_HASZ | P_HASRY | P_HASSCR |
  84.         P_HASGEST | P_HASFLEX | P_HASKEYS, // databits
  85.     P_CENTER | P_SCREEN, 0xFF, 11, // modes, nullkey, flexnum
  86.     2, 50, 20, // delay, idelay, reads/sec
  87.     P_IS3DG | P_IS3D | P_IS2D, // uses
  88.     "Default Powerglove Driver"
  89. };
  90.  
  91.  
  92. #define DEBOUNCE_TIME 2
  93.  
  94. static fbend[4] = { 127, 90, 40, 0 }; // finger flexions
  95. static tbbend[4] = { 127, 72, 25, 0 };
  96. static ttbend[4] = { 127, 80, 35, 0 };
  97.  
  98. #include "ds_gest.hpp"
  99. InitFile * gloveIni;
  100.  
  101. Boolean keyhit_quit()
  102. {
  103.     if (kbhit()) {
  104.         getch();
  105.         return True;
  106.     }
  107.     return False;
  108. }
  109.  
  110. void setup_gestset(int which)
  111. {
  112.     gestset[which] = new RendGestSet(*gloveIni, which);
  113. }
  114.  
  115. int perform_gestset(int which)
  116. {
  117.     g_driver_ptr[which]->checkGestures();
  118. //    if (which != 1) {
  119.         (gestset[which])->postCheck();
  120. //    }
  121.     return gestset[which]->findGest();
  122. }
  123.  
  124. extern void InitEpsilon(InitFile &ini);
  125.  
  126. pconfig *glove_driver(int op, POINTER *p, int mode, int which)
  127. {
  128.     static char section[] = "1.Smoothing";
  129.     // int type = FP_OFF(p); /* way to get integer arg. */
  130.     int ft, fi, fm, fp;
  131.  
  132.     switch(op)
  133.     {
  134.     case DRIVER_CMD:
  135.     case DRIVER_RESET:
  136.         break;
  137.  
  138.     case DRIVER_INIT:
  139.         if (!which) {
  140.             gloveIni = new InitFile("glove.ini");
  141.             InitEpsilon(*gloveIni);
  142.         }
  143.  
  144. //        init_gestures();
  145.         setup_gestset(which);
  146.         gestsys[which] = new GestureSystem;
  147.         if (gestset[which]) {
  148.             (gestset[which])->turnOn();
  149.             *(gestsys[which]) + gestset[which];
  150.             (gestsys[which])->turnOn();
  151.         }
  152.         section[0] = '1' + char(which);
  153.         if (!strcmp(gloveIni->find(section, "smoothingEnabled", "False"),
  154.              "True"))
  155.             g_driver_ptr[which] = new smoothGlove(*gloveIni, gestsys[which], keyhit_quit,
  156.                 (stereo_type == SWITCHED) ? switch_sega : NULL);
  157.         else
  158.             g_driver_ptr[which] = new rawGlove(*gloveIni, gestsys[which], keyhit_quit,
  159.                 (stereo_type == SWITCHED) ? switch_sega : NULL);
  160.  
  161.         if ((g_driver_ptr[which])->driverStatus() != gloveDriver::EverythingOK) {
  162.             delete g_driver_ptr[which];
  163.             g_driver_ptr[which] = NULL;
  164.         }
  165.         break;
  166.  
  167.     case DRIVER_READ:       // pointer (2DP) read
  168.         if (mode == P_POINTER)
  169.         {
  170.             if (!(g_driver_ptr[which])) return NULL;
  171.             if (((g_driver_ptr[which])->driverStatus())
  172.                 == gloveDriver::PolledModeWorking)
  173.                 (g_driver_ptr[which])->waitForSample();
  174.             else
  175.                 if (!(g_driver_ptr[which])->yield())
  176.                     return NULL;
  177.             p->x = (long)((g_driver_ptr[which])->getX());
  178.             p->y = (long)((g_driver_ptr[which])->getY());
  179.             p->z = (long)((g_driver_ptr[which])->getZ());
  180.             p->rx = 0L;
  181.             p->ry = ((long) ((g_driver_ptr[which])->getRotation())) << 16;
  182.             p->rz = 0L;
  183.             p->buttons = 0;
  184.             p->keys = (unsigned)(g_driver_ptr[which])->getKeys();
  185.  
  186.             // finger joint angles
  187.             ft = ((g_driver_ptr[which])->getThumb());
  188.             fi = ((g_driver_ptr[which])->getIndex());
  189.             fm = ((g_driver_ptr[which])->getMiddle());
  190.             fp = ((g_driver_ptr[which])->getRing());
  191.  
  192.             p->flex[0] = tbbend[ft];
  193.             p->flex[1] = ttbend[ft];
  194.             p->flex[2] = p->flex[3] = fbend[fi];
  195.             p->flex[4] = p->flex[5] = fbend[fm];
  196.             p->flex[6] = p->flex[7] = fbend[fp];
  197.             p->flex[8] = p->flex[9] = fbend[fp];
  198.  
  199.             p->gesture = G_UNKNOWN;
  200. /**
  201.             p->gesture = (gesture_time[which] > DEBOUNCE_TIME) ?
  202.                 gesture_type[which] : G_UNKNOWN;
  203. **/
  204.         }
  205.         else if (mode == P_SCREEN) // mouse read (640x480)
  206.         {
  207.             p->x = scale_16(((long)glove_pconfig.maxsx) << 8, 127, ((long)(g_driver_ptr[which])->getX()));
  208.             p->y = scale_16(((long)glove_pconfig.maxsy) << 8, 127, -((long)(g_driver_ptr[which])->getY()));
  209.             if (p->x < 0) p->x = 0;
  210.             if (p->y < 0) p->y = 0;
  211.             if (p->x > glove_pconfig.maxsx) p->x = glove_pconfig.maxsx;
  212.             if (p->y > glove_pconfig.maxsy) p->y = glove_pconfig.maxsy;
  213.             p->gesture = G_UNKNOWN;
  214. /***
  215.             p->gesture = ((gesture_time[which]) > DEBOUNCE_TIME) ? (gesture_type[which]) : G_UNKNOWN;
  216. ***/
  217.             p->buttons = (p->gesture==G_FIST) ? 1 : 0;
  218.         }
  219.         break;
  220.  
  221.     case DRIVER_CHECK:
  222.         if ((g_driver_ptr[which])->driverStatus() != gloveDriver::EverythingOK) return NULL;
  223.         break;
  224.     case DRIVER_QUIT:
  225.         if ((g_driver_ptr[0])) delete (g_driver_ptr[0]);
  226.         if ((g_driver_ptr[1])) delete (g_driver_ptr[1]);
  227.         break;
  228.     }
  229.     return &glove_pconfig;
  230. }
  231.  
  232. // following only gets called once
  233. void glove_Start()
  234. {
  235.     (g_driver_ptr[0])->Start(strcmp(gloveIni->find(
  236.                 gloveDriver::getTitle(),
  237.                 "PolledOperation", "False"),
  238.                 "True") ? True : False);
  239.     gloveIni->write();
  240.     delete gloveIni;
  241.     InitFile::dealloc();
  242.     sub_exit(gloveptr_quit);
  243. }
  244.  
  245. Boolean glove_Polarity(int which)
  246. {
  247.     return ((g_driver_ptr[which])->getPolarity());
  248. }
  249.