home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / HANDSRC / HAND.C < prev    next >
C/C++ Source or Header  |  1995-02-15  |  25KB  |  1,053 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <graphics.h>
  4. #include <math.h>
  5. #include <conio.h>
  6. #include <dos.h>
  7. #include "glove.h"
  8.  
  9. #define to_radians 0.017453292
  10. #define rho 5000
  11. #define theta 90.0
  12. #define phi 180.0
  13. #define screendist 1000.0
  14.  
  15. int screen_x = 640,
  16.     screen_y = 480;
  17.  
  18. int screen_x2 = 320;
  19. int screen_y2 = 240;
  20.  
  21.  
  22.  
  23. int va,vb,ve,vf,vg,vi,vj,vk,vl;
  24.  
  25.  
  26.  
  27. /* This is a basic point on the 3D screen */
  28. struct point
  29.        {
  30.     int          x, y, z;
  31.     int          oldx, oldy, oldz;
  32.     int          ax, ay;
  33.     struct point *next;
  34.        };
  35.  
  36.  
  37. /* This structure defines the four points that make up the polygon
  38.    for the palm of the hand */
  39. struct polygon
  40.        {
  41.     struct point   *points;
  42.     struct polygon *next;
  43.     int            color;
  44.     int            line;
  45.        };
  46.  
  47. struct object
  48.     {
  49.       struct polygon *polygons;
  50.       int            number;
  51.     };
  52.  
  53. struct matrix
  54.     {
  55.       int m[4][4];
  56.     };
  57.  
  58.  
  59. struct matrix * identity ( struct matrix *m )
  60. {
  61.  
  62.   int i,j;
  63.  
  64.   for (i=0;i<4;i++ )
  65.   {
  66.     for (j=0;j<4;j++)
  67.     {
  68.       m->m[i][j] = 0.0;
  69.     }
  70.   }
  71.  
  72.   m->m[0][0] = 1.0;
  73.   m->m[1][1] = 1.0;
  74.   m->m[2][2] = 1.0;
  75.   m->m[3][3] = 1.0;
  76.  
  77.   return ( m );
  78.  
  79. }
  80.  
  81.  
  82.  
  83.  
  84.  
  85. void create_view_transformation()
  86. {
  87.   float sintheta, costheta, sinphi, cosphi;
  88.  
  89.   sintheta = sin(theta*to_radians);
  90.   costheta = cos(theta*to_radians);
  91.   sinphi = sin(phi*to_radians);
  92.   cosphi = cos(phi*to_radians);
  93.  
  94.   va = -sintheta;
  95.   vb = costheta;
  96.   ve = -costheta*cosphi;
  97.   vf = -sintheta*cosphi;
  98.   vg = sinphi;
  99.   vi = -costheta*sinphi;
  100.   vj = -sintheta*sinphi;
  101.   vk = -cosphi;
  102.   vl = rho;
  103. }
  104.  
  105.  
  106.  
  107. struct object * create_object ( struct object *obj )
  108. {
  109.  
  110.   obj = (struct object *)malloc(sizeof (struct object));
  111.   obj->polygons = NULL;
  112.   obj->number   = 0;
  113.  
  114.   return (obj);
  115.  
  116. }
  117.  
  118.  
  119. void release_object ( struct object *obj )
  120. {
  121.   struct polygon *p;
  122.   struct point   *d;
  123.  
  124.   if ( obj->number > 0 )
  125.   {
  126.     while ( obj->polygons != NULL )
  127.     {
  128.       p = obj->polygons;
  129.       obj->polygons = obj->polygons->next;
  130.       while ( p->points != NULL )
  131.       {
  132.     d = p->points;
  133.     p->points = p->points->next;
  134.     free (d);
  135.       }
  136.       free (p);
  137.     }
  138.   }
  139.  
  140.   free (obj);
  141.  
  142. }
  143.  
  144.  
  145.  
  146. struct polygon * add_polygon ( struct object *obj, struct polygon *p, int line )
  147. {
  148.  
  149.   p = (struct polygon *)malloc(sizeof(struct polygon));
  150.   p->next = NULL;
  151.   p->points = NULL;
  152.   p->line = line;
  153.  
  154.   if ( obj->polygons == NULL )
  155.   {
  156.     obj->polygons = p;
  157.   }
  158.   else
  159.   {
  160.     p->next = obj->polygons;
  161.     obj->polygons = p;
  162.   }
  163.  
  164.   obj->number++;
  165.   return ( p );
  166. }
  167.  
  168.  
  169. void proj ( struct point *p, int *sx, int *sy, struct matrix *mat )
  170. {
  171.  
  172.    int xt, yt, zt,
  173.      xe, ye, ze,
  174.      xw, yw, zw;
  175.  
  176.    /* Apply current global Matrix (mat) */
  177.    xt = p->x*mat->m[0][0] +
  178.     p->y*mat->m[1][0] +
  179.     p->z*mat->m[2][0] +
  180.          mat->m[3][0];
  181.  
  182.    yt = p->x*mat->m[0][1] +
  183.     p->y*mat->m[1][1] +
  184.     p->z*mat->m[2][1] +
  185.          mat->m[3][1];
  186.  
  187.    zt = p->x*mat->m[0][2] +
  188.     p->y*mat->m[1][2] +
  189.     p->z*mat->m[2][2] +
  190.          mat->m[3][2];
  191.  
  192.    xw = xt;
  193.    yw = yt;
  194.    zw = zt;
  195.  
  196.    /* Translate to view */
  197.    xe = va*xw;                /* + vb*yw; */
  198.    ye = /* ve*xw + vf* */      yw;       /*+ vg*zw; */
  199.    ze = /* vi*xw + vj*yw + vk* */ zw + vl;
  200.  
  201.    /* Translate to perpective view */
  202.    *sx = screendist * xe / ze;
  203.    *sy = screendist * ye / ze;
  204.  
  205. }
  206.  
  207.  
  208.  
  209. void draw_object ( struct object *obj, struct matrix *mat, int color )
  210. {
  211.  
  212.   struct polygon  *p;
  213.   struct point *d;
  214.   int x, y, x2, y2, *sx, *sy, *sx2, *sy2, svx, svy;
  215.  
  216.   setcolor ( color );
  217.   sx = &x;
  218.   sy = &y;
  219.   sx2 = &x2;
  220.   sy2 = &y2;
  221.  
  222.     p = obj->polygons;
  223.     while ( p != NULL )
  224.     {
  225.  
  226.       d = p->points;
  227.       proj ( d, sx, sy, mat );
  228.       svx = d->ax = x;                /* Save actual points for erase */
  229.       svy = d->ay = y;
  230.       d = d->next;
  231.  
  232.       while ( d != NULL )
  233.       {
  234.     proj(d, sx2, sy2, mat );
  235.     d->ax = x2;            /* Save actual points for erase */
  236.     d->ay = y2;
  237.     line (screen_x2-x, screen_y2-y, screen_x2- x2, screen_y2 - y2 );
  238.  
  239.     d = d->next;
  240.     x = x2;
  241.     y = y2;
  242.       }
  243.       if ( p->line == 0 )
  244.       {
  245.     line ( screen_x2-x, screen_y2-y, screen_x2-svx, screen_y2-svy );
  246.       }
  247.       p = p->next;
  248.     }
  249. }
  250.  
  251.  
  252.  
  253.  
  254. void erase_object ( struct object *obj )
  255. {
  256.  
  257.   struct polygon  *p;
  258.   struct point *d;
  259.   int svx, svy, x, y;
  260.  
  261.   setcolor ( BLACK );
  262.   p = obj->polygons;
  263.   while ( p != NULL )
  264.     {
  265.       d = p->points;
  266.       x = svx = d->ax;
  267.       y = svy = d->ay;
  268.  
  269.       d = d->next;
  270.       while ( d != NULL )
  271.       {
  272.     line ( screen_x2-x, screen_y2-y, screen_x2-d->ax, screen_y2-d->ay );
  273.     x = d->ax;
  274.     y = d->ay;
  275.     d = d->next;
  276.       }
  277.       if ( p->line == 0 )
  278.       {
  279.     line ( screen_x2-x, screen_y2-y, screen_x2-svx, screen_y2-svy );
  280.       }
  281.       p = p->next;
  282.     }
  283. }
  284.  
  285.  
  286.  
  287.  
  288. void add_vertex ( struct polygon *p, int x, int y, int z )
  289. {
  290.   struct point   *d, *temp;
  291.  
  292.   temp = p->points;
  293.   if ( temp != NULL )
  294.   {
  295.     while ( temp->next != NULL )
  296.     { temp = temp->next; }
  297.   }
  298.  
  299.   d = (struct point *)malloc(sizeof(struct point));
  300.   d->x = x;
  301.   d->y = y;
  302.   d->z = z;
  303.   d->oldx = x;
  304.   d->oldy = y;
  305.   d->oldz = z;
  306.   d->next = NULL;
  307.  
  308.   if ( p->points == NULL )
  309.   {
  310.     p->points = d;
  311.   }
  312.   else
  313.   {
  314.     temp->next = d;
  315.   }
  316. }
  317.  
  318.  
  319. struct object * make_plane_object ( struct object *obj )
  320. {
  321.  
  322.   struct polygon *p;
  323.  
  324.   obj = create_object ( obj );
  325.  
  326.  
  327. /* Plane */
  328.    p = add_polygon ( obj, p, 0 );
  329.    add_vertex ( p, -1600,-1000,0 );
  330.    add_vertex ( p, -1600,-1000,6000 );
  331.    add_vertex ( p, 1600,-1000,6000 );
  332.    add_vertex ( p, 1600,-1000,0 );
  333.  
  334. /* Vertical Marks */
  335.    p = add_polygon ( obj, p, 1 );
  336.    add_vertex ( p, -1400, -1000, 0 );
  337.    add_vertex ( p, -1400, -1000, 6000 );
  338.  
  339.    p = add_polygon ( obj, p, 1 );
  340.    add_vertex ( p, -1200, -1000, 0 );
  341.    add_vertex ( p, -1200, -1000, 6000 );
  342.  
  343.    p = add_polygon ( obj, p, 1 );
  344.    add_vertex ( p, -1000, -1000, 0 );
  345.    add_vertex ( p, -1000, -1000, 6000 );
  346.  
  347.    p = add_polygon ( obj, p, 1 );
  348.    add_vertex ( p, -800, -1000, 0 );
  349.    add_vertex ( p, -800, -1000, 6000 );
  350.  
  351.    p = add_polygon ( obj, p, 1 );
  352.    add_vertex ( p, -600, -1000, 0 );
  353.    add_vertex ( p, -600, -1000, 6000 );
  354.  
  355.    p = add_polygon ( obj, p,1 );
  356.    add_vertex ( p, -400, -1000, 0 );
  357.    add_vertex ( p, -400, -1000, 6000 );
  358.  
  359.    p = add_polygon ( obj, p,1 );
  360.    add_vertex ( p, -200, -1000, 0 );
  361.    add_vertex ( p, -200, -1000, 6000 );
  362.  
  363.    p = add_polygon ( obj, p,1 );
  364.    add_vertex ( p, 0, -1000, 0 );
  365.    add_vertex ( p, 0, -1000, 6000 );
  366.  
  367.    p = add_polygon ( obj, p,1 );
  368.    add_vertex ( p, 200, -1000, 0 );
  369.    add_vertex ( p, 200, -1000, 6000 );
  370.  
  371.    p = add_polygon ( obj, p,1 );
  372.    add_vertex ( p, 400, -1000, 0 );
  373.    add_vertex ( p, 400, -1000, 6000 );
  374.  
  375.    p = add_polygon ( obj, p,1 );
  376.    add_vertex ( p, 600, -1000, 0 );
  377.    add_vertex ( p, 600, -1000, 6000 );
  378.  
  379.    p = add_polygon ( obj, p,1 );
  380.    add_vertex ( p, 800, -1000, 0 );
  381.    add_vertex ( p, 800, -1000, 6000 );
  382.  
  383.    p = add_polygon ( obj, p,1 );
  384.    add_vertex ( p, 1000, -1000, 0 );
  385.    add_vertex ( p, 1000, -1000, 6000 );
  386.  
  387.    p = add_polygon ( obj, p,1 );
  388.    add_vertex ( p, 1200, -1000, 0 );
  389.    add_vertex ( p, 1200, -1000, 6000 );
  390.  
  391.    p = add_polygon ( obj, p,1 );
  392.    add_vertex ( p, 1400, -1000, 0 );
  393.    add_vertex ( p, 1400, -1000, 6000 );
  394.  
  395.  
  396.  
  397. /* Horizontal marks */
  398.    p = add_polygon ( obj, p,1 );
  399.    add_vertex ( p, -1600,-1000, 500 );
  400.    add_vertex ( p, 1600, -1000, 500 );
  401.  
  402.    p = add_polygon ( obj, p,1 );
  403.    add_vertex ( p, -1600, -1000, 1000 );
  404.    add_vertex ( p, 1600, -1000, 1000 );
  405.  
  406.    p = add_polygon ( obj, p,1 );
  407.    add_vertex ( p, -1600,-1000, 1500 );
  408.    add_vertex ( p, 1600, -1000, 1500 );
  409.  
  410.    p = add_polygon ( obj, p,1 );
  411.    add_vertex ( p, -1600, -1000, 2000 );
  412.    add_vertex ( p, 1600, -1000, 2000 );
  413.  
  414.    p = add_polygon ( obj, p,1 );
  415.    add_vertex ( p, -1600,-1000, 2500 );
  416.    add_vertex ( p, 1600, -1000, 2500 );
  417.  
  418.    p = add_polygon ( obj, p,1 );
  419.    add_vertex ( p, -1600, -1000, 3000 );
  420.    add_vertex ( p, 1600, -1000, 3000 );
  421.  
  422.    p = add_polygon ( obj, p,1 );
  423.    add_vertex ( p, -1600,-1000, 3500 );
  424.    add_vertex ( p, 1600, -1000, 3500 );
  425.  
  426.    p = add_polygon ( obj, p,1 );
  427.    add_vertex ( p, -1600, -1000, 4000 );
  428.    add_vertex ( p, 1600, -1000, 4000 );
  429.  
  430.    p = add_polygon ( obj, p,1 );
  431.    add_vertex ( p, -1600,-1000, 4500 );
  432.    add_vertex ( p, 1600, -1000, 4500 );
  433.  
  434.    p = add_polygon ( obj, p,1 );
  435.    add_vertex ( p, -1600, -1000, 5000 );
  436.    add_vertex ( p, 1600, -1000, 5000 );
  437.  
  438.    p = add_polygon ( obj, p,1 );
  439.    add_vertex ( p, -1600, -1000, 5500 );
  440.    add_vertex ( p, 1600, -1000, 5500 );
  441.  
  442.    return ( obj );
  443.  
  444. }
  445.  
  446.  
  447.  
  448. struct object * make_hand_object ( struct object *hand )
  449. {
  450.  
  451.   struct polygon *p;
  452.  
  453.   hand = create_object ( hand );
  454.  
  455.   p = add_polygon ( hand, p,0 );
  456.   add_vertex ( p, 400,0,1000 );
  457.   add_vertex ( p, 400,400,1000 );
  458.   add_vertex ( p, 400,400,300 );
  459.   add_vertex ( p, 400,0,300 );
  460.  
  461. /*  p = add_polygon ( hand, p );
  462.   add_vertex ( p, 440,0,1000 );
  463.   add_vertex ( p, 440,400,1000 );
  464.   add_vertex ( p, 440,400,300 );
  465.   add_vertex ( p, 440,0,300 );
  466.  
  467.   p = add_polygon ( hand, p );
  468.   add_vertex ( p, 400,400,300 );
  469.   add_vertex ( p, 440,400,300 );
  470.  
  471.   p = add_polygon ( hand, p );
  472.   add_vertex ( p, 400,0,300 );
  473.   add_vertex ( p, 440,0,300 );
  474.  
  475.   p = add_polygon ( hand, p );
  476.   add_vertex ( p, 400,400,1000 );
  477.   add_vertex ( p, 440,400,1000 );
  478.  
  479.   p = add_polygon ( hand, p );
  480.   add_vertex ( p, 400,0,1000 );
  481.   add_vertex ( p, 440,0,1000 ); */
  482.  
  483.   return ( hand );
  484.  
  485. }
  486.  
  487. struct object * make_finger1_object ( struct object *f )
  488. {
  489.  
  490.   struct polygon *p;
  491.  
  492.   f = create_object ( f );
  493.  
  494.   p = add_polygon ( f, p,1 );
  495.   add_vertex ( p, 400,400,1000 );
  496.   add_vertex ( p, 400,400,1300 );
  497.   add_vertex ( p, 400,400,1500 );
  498.   add_vertex ( p, 400,400,1600 );
  499.  
  500.   return ( f );
  501.  
  502. }
  503.  
  504.  
  505. struct object * make_finger2_object ( struct object *f )
  506. {
  507.  
  508.   struct polygon *p;
  509.  
  510.   f = create_object ( f );
  511.  
  512.   p = add_polygon ( f, p,1 );
  513.   add_vertex ( p, 400,240,1000 );
  514.   add_vertex ( p, 400,240,1300 );
  515.   add_vertex ( p, 400,240,1500 );
  516.   add_vertex ( p, 400,240,1600 );
  517.  
  518.   return ( f );
  519.  
  520. }
  521.  
  522. struct object * make_finger3_object ( struct object *f )
  523. {
  524.  
  525.   struct polygon *p;
  526.  
  527.   f = create_object ( f );
  528.  
  529.   p = add_polygon ( f, p,1 );
  530.   add_vertex ( p, 400,120,1000 );
  531.   add_vertex ( p, 400,120,1300 );
  532.   add_vertex ( p, 400,120,1500 );
  533.   add_vertex ( p, 400,120,1600 );
  534.  
  535.   return ( f );
  536.  
  537. }
  538.  
  539. struct object * make_finger4_object ( struct object *f )
  540. {
  541.  
  542.   struct polygon *p;
  543.  
  544.   f = create_object ( f );
  545.  
  546.   p = add_polygon ( f, p,1 );
  547.   add_vertex ( p, 400,0,1000 );
  548.   add_vertex ( p, 400,0,1300 );
  549.   add_vertex ( p, 400,0,1500 );
  550.   add_vertex ( p, 400,0,1600 );
  551.  
  552.   return ( f );
  553.  
  554. }
  555.  
  556.  
  557.  
  558. struct matrix * matrixmult ( struct matrix *a, struct matrix *b )
  559. {
  560.   int i, j, k;
  561.   int t;
  562.   struct matrix *c;
  563.  
  564.   c = (struct matrix *)malloc(sizeof(struct matrix));
  565.  
  566.   for (i=0;i<4;i++)
  567.   {
  568.    for (j=0;j<4;j++)
  569.    {
  570.     t = 0.0;
  571.     for (k=0;k<4;k++)
  572.     {
  573.      t = t + a->m[i][k] * b->m[k][j];
  574.     }
  575.     c->m[i][j] = t;
  576.    }
  577.   }
  578.  
  579.   return ( c );
  580. }
  581.  
  582.  
  583. struct matrix * object_translate ( struct matrix *mat, int transx, int transy, int transz )
  584. {
  585.   struct matrix *b, *c;
  586.   b = (struct matrix *)malloc(sizeof(struct matrix));
  587.  
  588.   b = identity ( b );
  589.   b->m[3][0] = transx;
  590.   b->m[3][1] = transy;
  591.   b->m[3][2] = transz;
  592.   c = matrixmult ( mat, b );
  593.   free ( mat );
  594.   free (b);
  595.  
  596.   return ( c );
  597. }
  598.  
  599.  
  600.  
  601. struct matrix * object_scale ( struct matrix *mat, float scale )
  602. {
  603.   struct matrix *b, *c;
  604.   b = (struct matrix *)malloc(sizeof(struct matrix));
  605.  
  606.   b = identity ( b );
  607.   b->m[0][0] *= scale;
  608.   b->m[1][1] *= scale;
  609.   b->m[2][2] *= scale;
  610.   c = matrixmult ( mat, b );
  611.   free ( mat );
  612.   free(b);
  613.  
  614.   return ( c );
  615. }
  616.  
  617.  
  618. struct matrix * object_xrot ( struct matrix *mat, float deg )
  619. {
  620.   float thecos, thesin;
  621.   struct matrix *b, *c;
  622.  
  623.   thecos = cos ( deg*to_radians );
  624.   thesin = sin ( deg*to_radians );
  625.   b = (struct matrix *)malloc(sizeof(struct matrix));
  626.  
  627.   b = identity ( b );
  628.   b->m[1][1] = thecos;
  629.   b->m[1][2] = thesin;
  630.   b->m[2][1] = -thesin;
  631.   b->m[2][2] = thecos;
  632.   c = matrixmult ( mat, b );
  633.   free ( mat );
  634.   free ( b );
  635.  
  636.   return ( c );
  637. }
  638.  
  639.  
  640. struct matrix * object_yrot ( struct matrix *mat, float deg )
  641. {
  642.   float thecos, thesin;
  643.   struct matrix *b, *c;
  644.  
  645.   thecos = cos ( deg*to_radians );
  646.   thesin = sin ( deg*to_radians );
  647.   b = (struct matrix *)malloc(sizeof(struct matrix));
  648.  
  649.   b = identity ( b );
  650.   b->m[0][0] = thecos;
  651.   b->m[0][2] = -thesin;
  652.   b->m[2][0] = thesin;
  653.   b->m[2][2] = thecos;
  654.   c = matrixmult ( mat,b );
  655.   free ( mat );
  656.   free ( b );
  657.  
  658.   return ( c );
  659. }
  660.  
  661.  
  662.  
  663. struct matrix * object_zrot ( struct matrix *mat, float deg )
  664. {
  665.   float thecos, thesin;
  666.   struct matrix *b, *c;
  667.  
  668.   thecos = cos ( deg*to_radians );
  669.   thesin = sin ( deg*to_radians );
  670.   b = (struct matrix *)malloc(sizeof(struct matrix));
  671.  
  672.   b = identity ( b );
  673.   b->m[0][0] = thecos;
  674.   b->m[0][1] = thesin;
  675.   b->m[1][0] = -thesin;
  676.   b->m[1][1] = thecos;
  677.   c = matrixmult ( mat, b );
  678.   free ( mat );
  679.   free ( b );
  680.  
  681.   return ( c );
  682. }
  683.  
  684.  
  685. void change_finger_joint_one ( float deg, struct point *d )
  686. {
  687.  
  688.   int x, y, z, ox, oy, oz, i;
  689.   float thesin, thecos;
  690.   struct matrix *m, *n, *o, *old;
  691.   struct point *e;
  692.  
  693.   n = (struct matrix *)malloc(sizeof(struct matrix));
  694.   o = (struct matrix *)malloc(sizeof(struct matrix));
  695.  
  696.   n = identity ( n );
  697.   o = identity ( o );
  698.  
  699.   thecos = cos ( deg * to_radians );         /* set up rotation matrix */
  700.   thesin = sin ( deg * to_radians );
  701.  
  702.   o->m[0][0] = thecos;
  703.   o->m[2][0] = thesin;
  704.   o->m[0][2] = -thesin;
  705.   o->m[2][2] = thecos;
  706.  
  707.  
  708.   ox = d->oldx;
  709.   oy = d->oldy;
  710.   oz = d->oldz;
  711.  
  712.     n->m[3][0] = -ox;             /* setup translation matrix to origin */
  713.     n->m[3][1] = -oy;
  714.     n->m[3][2] = -oz;
  715.     m = matrixmult ( n, o );         /* multiply these */
  716.  
  717.  
  718.     e = d;
  719.     d = d->next;
  720.     n->m[3][0] = e->x;             /* Previous point translation back */
  721.     n->m[3][1] = e->y;
  722.     n->m[3][2] = e->z;
  723.  
  724.     old = m;
  725.     m = matrixmult ( old, n );                  /* Final matrix */
  726.     free ( old );
  727.  
  728.     ox = d->x;
  729.     oy = d->y;
  730.     oz = d->z;
  731.  
  732.     x = d->x * m->m[0][0] +
  733.     d->y * m->m[1][0] +
  734.     d->z * m->m[2][0] +
  735.            m->m[3][0];
  736.  
  737.     y = d->x * m->m[0][1] +
  738.     d->y * m->m[1][1] +
  739.     d->z * m->m[2][1] +
  740.            m->m[3][1];
  741.  
  742.     z = d->x * m->m[0][2] +
  743.     d->y * m->m[1][2] +
  744.     d->z * m->m[2][2] +
  745.            m->m[3][2];
  746.  
  747.     d->oldx = d->x;
  748.     d->oldy = d->y;
  749.     d->oldz = d->z;
  750.  
  751.     d->x = x;
  752.     d->y = y;
  753.     d->z = z;
  754.  
  755.   free ( n );
  756.   free ( o );
  757.   free ( m );
  758.  
  759. }
  760.  
  761.  
  762. void main()
  763. {
  764.  
  765.   char ch;
  766.   int change=0, close = 0, good = 0;
  767.   int graphmode, graphdriver, i, x, y, z,
  768.       glovex=0, glovey=0, glovez=0, gloveroll=0;
  769.   struct object *hand, *ball, *finger1, *finger2, *finger3, *finger4,
  770.         *plane;
  771.   struct matrix *hand_matrix, *ball_matrix,
  772.         *finger1_matrix,
  773.         *finger2_matrix,
  774.         *finger3_matrix,
  775.         *finger4_matrix,
  776.         *plane_matrix;
  777.  
  778.   glove_data    glov;
  779.  
  780.  
  781.  
  782.   glove_init ( HIRES, NULL );
  783.   printf ( "Exercise the glove and then Press any key!!\n" );
  784.   getch();
  785.  
  786.   graphmode = VGAHI;
  787.   graphdriver = VGA;
  788.   initgraph ( &graphdriver, &graphmode, "" );
  789.   setbkcolor ( BLACK );
  790.   cleardevice();
  791.  
  792.   plane_matrix   = (struct matrix *)malloc(sizeof(struct matrix));
  793.   hand_matrix    = (struct matrix *)malloc(sizeof(struct matrix));
  794.   finger1_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  795.   finger2_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  796.   finger3_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  797.   finger4_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  798.  
  799.   plane_matrix   = identity ( plane_matrix );
  800.   hand_matrix    = identity ( hand_matrix );
  801.   finger1_matrix = identity ( finger1_matrix );
  802.   finger2_matrix = identity ( finger2_matrix );
  803.   finger3_matrix = identity ( finger3_matrix );
  804.   finger4_matrix = identity ( finger4_matrix );
  805.  
  806.   create_view_transformation();
  807.  
  808.   plane   = make_plane_object ( plane );
  809.   hand    = make_hand_object ( hand );
  810.   finger1 = make_finger1_object ( finger1 );
  811.   finger2 = make_finger2_object ( finger2 );
  812.   finger3 = make_finger3_object ( finger3 );
  813.   finger4 = make_finger4_object ( finger4 );
  814.  
  815.   x = hand->polygons->points->x;
  816.   y = hand->polygons->points->y;
  817.   z = hand->polygons->points->z;
  818.  
  819.   hand_matrix    = object_translate ( hand_matrix, -x, -y, -z );
  820.   hand_matrix    = object_zrot ( hand_matrix, 90 );
  821.   hand_matrix    = object_translate ( hand_matrix, x, y, z );
  822.   finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  823.   finger1_matrix = object_zrot ( finger1_matrix, 90 );
  824.   finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  825.   finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  826.   finger2_matrix = object_zrot ( finger2_matrix, 90 );
  827.   finger2_matrix = object_translate ( finger2_matrix, x, y, z );
  828.   finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  829.   finger3_matrix = object_zrot ( finger3_matrix, 90 );
  830.  
  831.   finger3_matrix = object_translate ( finger3_matrix, x, y, z );
  832.   finger4_matrix = object_translate ( finger4_matrix, -x, -y, -z );
  833.   finger4_matrix = object_zrot ( finger4_matrix, 90 );
  834.   finger4_matrix = object_translate ( finger4_matrix, x, y, z );
  835.  
  836.  
  837.   draw_object ( plane, plane_matrix, BLUE );
  838.   draw_object ( hand, hand_matrix, RED );
  839.   draw_object ( finger1, finger1_matrix, RED );
  840.   draw_object ( finger3, finger3_matrix, RED );
  841.   draw_object ( finger4, finger4_matrix, RED );
  842.  
  843.   ch = 0;
  844.   while ( ch != 'q' )
  845.   {
  846.  
  847.     while (!glove_ready()) glove_delay();
  848.     glove_read(&glov);
  849.     x = y = z = 0;
  850.  
  851.     if ( glov.x != glovex )
  852.     {
  853.       change = 2;
  854.       if ( glov.x > glovex )
  855.     x = abs(glov.x-glovex) * 25;
  856.       else
  857.     x = abs(glov.x-glovex) * -25;
  858.       glovex = glov.x;
  859.     }
  860.  
  861.  
  862.     if ( glov.y != glovey  )
  863.     {
  864.       change = 2;
  865.       if ( glov.y > glovey )
  866.     y = abs(glov.y-glovey) * 25;
  867.       else
  868.     y = abs(glov.y-glovey) * -25;
  869.       glovey = glov.y;
  870.     }
  871.  
  872.     if ( glov.z != glovez )
  873.     {
  874.       change = 2;
  875.       if ( glov.z > glovez )
  876.     z = abs(glov.z-glovez) * -200;
  877.       else
  878.     z = abs(glov.z-glovez) * 200;
  879.       glovez = glov.z;
  880.     }
  881.  
  882.  
  883.  
  884.     if ( change == 2 )
  885.     {
  886.       hand_matrix = object_translate ( hand_matrix, x,y,z );
  887.       finger1_matrix = object_translate ( finger1_matrix, x,y,z  );
  888.       finger2_matrix = object_translate ( finger2_matrix, x,y,z  );
  889.       finger3_matrix = object_translate ( finger3_matrix, x,y,z  );
  890.       finger4_matrix = object_translate ( finger4_matrix, x,y,z  );
  891.     }
  892.  
  893.     if ( change == 2 )
  894.     {
  895.     erase_object ( hand );
  896.     erase_object ( finger1 );
  897.     erase_object ( finger2 );
  898.     erase_object ( finger3 );
  899.     erase_object ( finger4 );
  900.     change = 1;
  901.     }
  902.  
  903.  
  904.  
  905.     if ( (glov.keys & 0xff) <= 0xA0 )
  906.     {
  907.       ch = 'q';
  908.     }
  909.  
  910.  
  911.  
  912.     if (((glov.fingers & 0xff ) <= 0x80 ) && ( close == 1 ) )
  913.     {
  914.       x =  -270;
  915.       y =  180;
  916.       z =  270;
  917.  
  918. /*      cleardevice(); */
  919.       change_finger_joint_one ( x, finger1->polygons->points  );
  920.       change_finger_joint_one ( y, finger1->polygons->points->next  );
  921.       change_finger_joint_one ( z, finger1->polygons->points->next->next );
  922.  
  923.       change_finger_joint_one ( x, finger2->polygons->points  );
  924.       change_finger_joint_one ( y, finger2->polygons->points->next  );
  925.       change_finger_joint_one ( z, finger2->polygons->points->next->next );
  926.  
  927.       change_finger_joint_one ( x, finger3->polygons->points  );
  928.       change_finger_joint_one ( y, finger3->polygons->points->next  );
  929.       change_finger_joint_one ( z, finger3->polygons->points->next->next );
  930.  
  931.       change_finger_joint_one ( x, finger4->polygons->points  );
  932.       change_finger_joint_one ( y, finger4->polygons->points->next  );
  933.       change_finger_joint_one ( z, finger4->polygons->points->next->next );
  934.       close = 0;
  935.     }
  936.  
  937.     if (((glov.fingers & 0xff ) > 0x80 ) && ( close == 0 ))
  938.     {
  939.       x = -90;
  940.       y = 180;
  941.       z =  90;
  942.  
  943. /*      cleardevice(); */
  944.       change_finger_joint_one ( x, finger1->polygons->points  );
  945.       change_finger_joint_one ( y, finger1->polygons->points->next  );
  946.       change_finger_joint_one ( z, finger1->polygons->points->next->next );
  947.  
  948.       change_finger_joint_one ( x, finger2->polygons->points  );
  949.       change_finger_joint_one ( y, finger2->polygons->points->next  );
  950.       change_finger_joint_one ( z, finger2->polygons->points->next->next );
  951.  
  952.       change_finger_joint_one ( x, finger3->polygons->points  );
  953.       change_finger_joint_one ( y, finger3->polygons->points->next  );
  954.       change_finger_joint_one ( z, finger3->polygons->points->next->next );
  955.  
  956.       change_finger_joint_one ( x, finger4->polygons->points  );
  957.       change_finger_joint_one ( y, finger4->polygons->points->next  );
  958.       change_finger_joint_one ( z, finger4->polygons->points->next->next );
  959.       close = 1;
  960.  
  961.     }
  962.  
  963.     if (( glov.rot >= 3 ) && (glov.rot <=10 ) && ( gloveroll == 0))
  964.     {
  965.       x = hand->polygons->points->x;
  966.       y = hand->polygons->points->y;
  967.       z = hand->polygons->points->z;
  968.  
  969.  
  970.       hand_matrix = object_translate ( hand_matrix, -x, -y, -z );
  971.       hand_matrix = object_zrot ( hand_matrix, -90 );
  972.       hand_matrix = object_translate ( hand_matrix, x, y, z );
  973.  
  974.       finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  975.       finger1_matrix = object_zrot ( finger1_matrix, -90 );
  976.       finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  977.  
  978.       finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  979.       finger2_matrix = object_zrot ( finger2_matrix, -90 );
  980.       finger2_matrix = object_translate ( finger2_matrix, x, y, z );
  981.  
  982.       finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  983.       finger3_matrix = object_zrot ( finger3_matrix, -90 );
  984.       finger3_matrix = object_translate ( finger3_matrix, x, y, z );
  985.  
  986.       finger4_matrix = object_translate ( finger4_matrix, -x, -y, -z );
  987.       finger4_matrix = object_zrot ( finger4_matrix, -90 );
  988.       finger4_matrix = object_translate ( finger4_matrix, x, y, z );
  989.       gloveroll = 1;
  990.     }
  991.  
  992.  
  993.     if ((glov.rot < 2 )  && ( gloveroll == 1 ))
  994.     {
  995.       gloveroll = 0;
  996.       x = hand->polygons->points->x;
  997.       y = hand->polygons->points->y;
  998.       z = hand->polygons->points->z;
  999.  
  1000.  
  1001.       hand_matrix = object_translate ( hand_matrix, -x, -y, -z );
  1002.       hand_matrix = object_zrot ( hand_matrix, 90 );
  1003.       hand_matrix = object_translate ( hand_matrix, x, y, z );
  1004.  
  1005.       finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  1006.       finger1_matrix = object_zrot ( finger1_matrix, 90 );
  1007.       finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  1008.  
  1009.       finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  1010.       finger2_matrix = object_zrot ( finger2_matrix, 90 );
  1011.       finger2_matrix = object_translate ( finger2_matrix, x, y, z );
  1012.  
  1013.       finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  1014.       finger3_matrix = object_zrot ( finger3_matrix, 90 );
  1015.       finger3_matrix = object_translate ( finger3_matrix, x, y, z );
  1016.  
  1017.       finger4_matrix = object_translate ( finger4_matrix, -x, -y, -z );
  1018.       finger4_matrix = object_zrot ( finger4_matrix, 90);
  1019.       finger4_matrix = object_translate ( finger4_matrix, x, y, z );
  1020.     }
  1021.  
  1022.  
  1023.      if ( change == 1 )
  1024.      {
  1025.       draw_object ( hand, hand_matrix, RED );
  1026.       draw_object ( finger1, finger1_matrix, RED );
  1027.       draw_object ( finger2, finger2_matrix, RED );
  1028.       draw_object ( finger3, finger3_matrix, RED );
  1029.       draw_object ( finger4, finger4_matrix, RED );
  1030.       change = 0;
  1031.      }
  1032.  
  1033.   }
  1034.  
  1035.   getch();
  1036.   release_object ( hand );
  1037.   release_object ( finger1 );
  1038.   release_object ( finger2 );
  1039.   release_object ( finger3 );
  1040.   release_object ( finger4 );
  1041.   release_object ( plane );
  1042.  
  1043.   free ( hand_matrix );
  1044.   free ( finger1_matrix );
  1045.   free ( finger2_matrix );
  1046.   free ( finger3_matrix );
  1047.   free ( finger4_matrix );
  1048.   free ( plane_matrix );
  1049.   closegraph();
  1050.   glove_quit();
  1051.  
  1052. }
  1053.