home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / GLOVE / OBJGLV.ZIP / SRC / DEMO4B / SUPP / POINTER.CPP < prev    next >
C/C++ Source or Header  |  1993-03-22  |  8KB  |  313 lines
  1. /* Pointer device driver interface routines */
  2.  
  3. /* Written by Dave Stampe, Aug. 1992 */
  4.  
  5. /* Copyright 1992 by 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 <alloc.h>
  15. #include <string.h>
  16. #include "rend386.hpp"  /* for MATRIX definition */
  17. #include "pointer.hpp"
  18. #include "inputptr.hpp"
  19.  
  20. extern long scale_16(long s, long a, long x); /* used to do scaling */
  21.                                               /* (x+a)*s            */
  22.  
  23. extern long calc_scale_16(long a, long b, long s); /* computes scaling factor */
  24.                                                    /* (a+b)/2/s          */
  25.  
  26. //extern pconfig *mouse_driver();
  27. //extern pconfig *glove_driver();
  28. extern void *load_driver(char *m);
  29.  
  30. typedef pconfig*(*pd_func)(int, POINTER *, int, int);
  31.  
  32. PDRIVER *pointer_init(int type, char *drfile, int which)
  33. {
  34.     pd_func pd;
  35.     pdrblock *p;
  36.     pconfig *d;
  37.     if (drfile == NULL) return NULL;
  38.  
  39.     if (!stricmp(drfile, "mouse"))
  40.     {
  41.         p = (pdrblock *)malloc(sizeof(pdrblock));
  42.         if (p == NULL) return NULL;
  43.         d = mouse_driver(DRIVER_INIT, (POINTER *)type, 0);
  44.         p->driver_pointer = mouse_driver;
  45.     }
  46.     else if (!stricmp(drfile, "pglove"))
  47.     {
  48.             p = (pdrblock *)malloc(sizeof(pdrblock));
  49.             if (p == NULL) return NULL;
  50.             d = glove_driver(DRIVER_INIT, (POINTER *)type, 0, which);
  51.             p->driver_pointer = glove_driver;
  52.     }
  53.     else
  54.         {
  55.         pd = (pd_func)load_driver(drfile);
  56.         if (pd == NULL) return NULL;
  57.         p = (pdrblock *)malloc(sizeof(pdrblock));
  58.         if (p == NULL) return NULL;
  59.         p->driver_pointer = pd =
  60.             (pd_func)MK_FP(FP_SEG(pd), 16+FP_OFF(pd)); /* entry point */
  61.         d = pd(DRIVER_INIT, (POINTER *)type, 0, 0);
  62.         if (d == NULL) return NULL;
  63.     }
  64.  
  65.     p->pdata = d;
  66.     p->xmult = p->ymult = p->zmult = 65536L;
  67.     p->xadd = p->yadd = p->zadd = 0;
  68.     p->xrmult = p->yrmult = p->zrmult = 65536L;
  69.     p->xradd = p->yradd = p->zradd = 0;
  70.     return p;
  71. }
  72.  
  73. /* makes sure device is available, OK */
  74. /* returns *pconfig or NULL           */
  75.  
  76. pconfig *pointer_check(PDRIVER *p, int which)
  77. {
  78.     if (p)
  79.         return (((pdrblock *)p)->driver_pointer) (DRIVER_CHECK, NULL, 0, which);
  80.     else
  81.         return NULL;
  82. }
  83.  
  84. /* recenters, recalibrates, etc */
  85. void pointer_reset(PDRIVER *p)
  86. {
  87.     if (p == NULL) return;
  88.     (((pdrblock *)p)->driver_pointer) (DRIVER_RESET, NULL, 0, 0);
  89. }
  90.  
  91. /* reads pointer, scales data and        */
  92. /* returns bitwise OR of the following:  */
  93. int pointer_read(PDRIVER *p, POINTER *pt, int which)
  94. {
  95.     POINTER *op = &((pdrblock *)p)->oldp;
  96.     pdrblock *pd = (pdrblock *)p;
  97.     int has = pd->pdata->databits;
  98.     int changed = 0;
  99.     int sx, sy;
  100.  
  101.     if (p == NULL || pt == NULL) return 0;
  102.     if ((p->driver_pointer) (DRIVER_READ, pt, P_POINTER, which) == NULL)
  103.     {
  104.         memcpy( pt, op, sizeof(POINTER) ); /* handle no new data */
  105.         pt->wpos_valid = 0;
  106.         pt->changed = 0;
  107.         op->changed = 0;
  108.         return 0;
  109.     }
  110.  
  111.     if (has & P_HASX)
  112.     {
  113.         pt->x = scale_16(pd->xmult, pd->xadd, pt->x);
  114.         if ((pt->dx = pt->x - op->x) != 0) changed |= PNEW_POS;
  115.     }
  116.     else pt->x = 0;
  117.     if (has & P_HASY)
  118.     {
  119.         pt->y = scale_16(pd->ymult, pd->yadd, pt->y);
  120.         if ((pt->dy = pt->y - op->y) != 0) changed |= PNEW_POS;
  121.     }
  122.     else pt->y = 0;
  123.     if (has & P_HASZ)
  124.     {
  125.         pt->z = scale_16(pd->zmult, pd->zadd, pt->z);
  126.         if ((pt->dz = pt->z - op->z) != 0) changed |= PNEW_POS;
  127.     }
  128.     else pt->z = 0;
  129.  
  130.     if (has & P_HASRX)
  131.     {
  132.         pt->rx = scale_16(pd->xrmult, pd->xradd, pt->rx);
  133.         if ((pt->drx = pt->rx - op->rx) != 0) changed |= PNEW_ROT;
  134.     }
  135.     else pt->rx = 0;
  136.     if (has & P_HASRY)
  137.     {
  138.         pt->ry = scale_16(pd->yrmult, pd->yradd, pt->ry);
  139.         if ((pt->dry = pt->ry - op->ry) != 0) changed |= PNEW_ROT;
  140.     }
  141.     else pt->ry = 0;
  142.     if (has & P_HASRZ)
  143.     {
  144.         pt->rz = scale_16(pd->zrmult, pd->zradd, pt->rz);
  145.         if ((pt->drz = pt->rz - op->rz) != 0) changed |= PNEW_ROT;
  146.     }
  147.     else pt->rz = 0;
  148.  
  149.     pt->buttons &= has&0x0007 ;
  150.     if ((has&0x0007) && pt->buttons != op->buttons) changed |= PNEW_BUT;
  151.  
  152.     if ((has&P_HASGEST) && pt->gesture != op->gesture) changed |= PNEW_GEST;
  153.  
  154.     if ((has&P_HASKEYS) && pt->keys != op->keys) changed |= PNEW_KEY;
  155.  
  156.     if (has & P_HASFLEX)
  157.     {
  158.         int i;
  159.         int n = pd->pdata->flexnum;
  160.  
  161.         for (i = 0; i < n; i++)
  162.             if (pt->flex[i] != op->flex[i])
  163.             {
  164.                 changed |= PNEW_FLEX;
  165.                 break;
  166.             }
  167.     }
  168.     if (changed)
  169.     {
  170.         memcpy(op, pt, sizeof(POINTER));
  171.         pt->wpos_valid = 0;
  172.     }
  173.     pt->changed = changed;
  174.     op->changed = changed;
  175.     return changed;
  176. }
  177.  
  178.  
  179. int mouse_read(PDRIVER *p, int *xp, int *yp, unsigned *bp)
  180. {
  181.     POINTER pt;
  182.     POINTER *opt = &(p->oldp);
  183.     int c = 0;
  184.  
  185.     if (p == NULL) return 0;
  186.     if (!(p->pdata->databits & P_HASSCR)) return 0;
  187.  
  188.     (p->driver_pointer) (DRIVER_READ, &pt, P_SCREEN, 0);
  189.  
  190.     if (p->oldsx != pt.x || p->oldsy != pt.y)
  191.         c |= PNEW_POS;
  192.     if (opt->buttons != pt.buttons)
  193.         c |= PNEW_BUT;
  194.  
  195.     p->oldsx = pt.x;
  196.     p->oldsy = pt.y;
  197.     opt->buttons = pt.buttons ;
  198.  
  199.     if (xp) *xp = pt.x;
  200.     if (yp) *yp = pt.y;
  201.     if (bp) *bp = pt.buttons;
  202.  
  203.     opt->changed = c;
  204.  
  205.     return c;
  206. }
  207.  
  208.  
  209. int mouse_last(PDRIVER *p, int *xp, int *yp, int *bp)
  210. {
  211.     if (p == NULL) return 0;
  212.  
  213.     if (xp) *xp = p->oldsx;
  214.     if (yp) *yp = p->oldsy;
  215.     if (bp) *bp = (&(p->oldp))->buttons;
  216.     return (&(p->oldp))->changed;
  217. }
  218.  
  219. void set_mouse_limits(PDRIVER *p, int maxx, int maxy)
  220. {
  221.     if (p == NULL) return; /* NOTE: MODIFIES DRIVER */
  222.     p->pdata->maxsx = maxx;
  223.     p->pdata->maxsy = maxy;
  224.     (p->driver_pointer) (DRIVER_CMD, (POINTER *)(P_SCREEN | P_CENTER), 0, 0);
  225.     mouse_read(p, NULL, NULL, NULL);
  226. }
  227.  
  228. /* disconnects driver */
  229. void pointer_quit(PDRIVER *p)
  230. {
  231.     if (p == NULL) return;
  232.     (((pdrblock *)p)->driver_pointer) (DRIVER_QUIT, NULL, 0, 0);
  233. }
  234.  
  235. /* changes device mode */
  236. pconfig *device_command(PDRIVER *p, int command)
  237. {
  238.     pconfig *pc;
  239.  
  240.     if (p == NULL) return NULL;
  241.     pc = (((pdrblock *)p)->driver_pointer) (DRIVER_CMD, (POINTER *)command, 0, 0);
  242.     p->pdata = pc;
  243.     return pc;
  244. }
  245.  
  246. /* sets scaling (+/- given value, centered at 0) */
  247.  
  248. void pointer_tscale(PDRIVER *p, long x, long y, long z)
  249. {
  250.     long mx = p->pdata->maxx;
  251.     long mn = p->pdata->minx;
  252.     p->xmult = calc_scale_16(mx, mn, x);
  253.     p->xadd = (mn-mx)/2;
  254.  
  255.     mx = p->pdata->maxy;
  256.     mn = p->pdata->miny;
  257.     p->ymult = calc_scale_16(mx, mn, y);
  258.     p->yadd = (mn-mx)/2;
  259.  
  260.     if (p->pdata->type != P_IS2DP) /* use y scaling for pseudo-z axis */
  261.     {
  262.         mx = p->pdata->maxz;
  263.         mn = p->pdata->minz;
  264.     }
  265.     p->zmult = calc_scale_16(mx, mn, z);
  266.     p->zadd = (mn-mx)/2;
  267. }
  268.  
  269.  
  270. void pointer_rscale(PDRIVER *p, long rx, long ry, long rz)
  271. {
  272.     long mx = p->pdata->maxxr;
  273.     long mn = p->pdata->minxr;
  274.     p->xrmult = calc_scale_16(mx, mn, rx);
  275.     p->xradd = (mn-mx)/2;
  276.  
  277.     mx = p->pdata->maxyr;
  278.     mn = p->pdata->minyr;
  279.     p->yrmult = calc_scale_16(mx, mn, ry);
  280.     p->yradd = (mn-mx)/2;
  281.  
  282.     mx = p->pdata->maxzr;
  283.     mn = p->pdata->minzr;
  284.     p->zrmult = calc_scale_16(mx, mn, rz);
  285.     p->zradd = (mn-mx)/2;
  286. }
  287.  
  288. void pointer_abscale(PDRIVER *p, long xs, long ys, long zs,
  289.     long xrs, long yrs, long zrs)
  290. {
  291.     p->xmult = scale_16(xs, 0, p->pdata->xres); /* set up to scale tick resolution */
  292.     p->ymult = scale_16(ys, 0, p->pdata->yres);
  293.     p->zmult = scale_16(zs, 0, p->pdata->zres);
  294.     p->xrmult = scale_16(xrs, 0, p->pdata->xrres); /* some weirdness with rot. scaling */
  295.     p->yrmult = scale_16(yrs, 0, p->pdata->yrres); /* as tick res. not really expressible */
  296.     p->zrmult = scale_16(zrs, 0, p->pdata->zrres); /* in <16.16>: so set tickres>>16 or so */
  297.     p->xadd = p->yadd = p->zadd = 0; /* look at PG y-rot for example */
  298.     p->xradd = p->yradd = p->zradd = 0;
  299. }
  300.  
  301.  
  302. void init_pointer(POINTER *p) /* initialize pointer structure */
  303. {
  304.     memset( p, 0, sizeof(POINTER));
  305.     p->wpos[0][0] = p->wpos[1][1] = p->wpos[2][2] = 536870912L;
  306. }
  307.  
  308. int last_pointer(PDRIVER *d, POINTER *p) /* copy of last read value */
  309. {
  310.     memcpy(p, &(d->oldp), sizeof(POINTER));
  311.     return(p->changed);
  312. }
  313.