home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / PGHAND2 / PGHAND2.C < prev    next >
C/C++ Source or Header  |  1995-02-27  |  38KB  |  1,592 lines
  1. /* This code is copyrighted by VRing Software Development */
  2. /* Any commercial use is stricted prohibited unless permission is */
  3. /* granted otherwise. */
  4.  
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <graphics.h>
  9. #include <math.h>
  10. #include <conio.h>
  11. #include <dos.h>
  12. #include <glove.h>
  13.  
  14.  
  15. #define to_radians 0.017453292
  16. #define rho 5000
  17. #define theta 90.0
  18. #define phi 180.0
  19. #define screendist 1000.0
  20.  
  21. int screen_x = 640,
  22.     screen_y = 480;
  23.  
  24. int screen_x2 = 320;
  25. int screen_y2 = 240;
  26.  
  27. int va,vb,ve,vf,vg,vi,vj,vk,vl;
  28.  
  29.  
  30.  
  31. /* This is a basic point on the 3D screen */
  32. struct my_point
  33.        {
  34.     int          x, y, z;
  35.     int          oldx, oldy, oldz;
  36.     int          ax, ay;
  37.     struct my_point *next;
  38.        };
  39.  
  40.  
  41. /* This structure defines the four points that make up the polygon
  42.    for the palm of the hand */
  43. struct polygon
  44.        {
  45.     struct my_point   *points;
  46.     struct polygon *next;
  47.     int            color;
  48.     int            line;
  49.        };
  50.  
  51. struct object
  52.     {
  53.       struct polygon *polygons;
  54.       int            number;
  55.     };
  56.  
  57. struct matrix
  58.     {
  59.       int m[4][4];
  60.     };
  61.  
  62.  
  63. void identity ( struct matrix *m )
  64. {
  65.  
  66.   int i,j;
  67.  
  68.   for (i=0;i<4;i++ )
  69.   {
  70.     for (j=0;j<4;j++)
  71.     {
  72.       m->m[i][j] = 0.0;
  73.     }
  74.   }
  75.  
  76.   m->m[0][0] = 1.0;
  77.   m->m[1][1] = 1.0;
  78.   m->m[2][2] = 1.0;
  79.   m->m[3][3] = 1.0;
  80.  
  81. }
  82.  
  83.  
  84. /* Theta = 90.0,
  85.    phi = 180.0,
  86.    rho = 5000 */
  87.  
  88.  
  89. void create_view_transformation()
  90. {
  91.   float sintheta, costheta, sinphi, cosphi;
  92.  
  93.   sintheta = sin(theta*to_radians);  /* 1 */
  94.   costheta = cos(theta*to_radians);  /* 0 */
  95.   sinphi = sin(phi*to_radians);      /* 0 */
  96.   cosphi = cos(phi*to_radians);      /* -1 */
  97.  
  98.   va = -sintheta;           /*-1*/
  99.   vb = costheta;            /*0*/
  100.   ve = -costheta*cosphi;    /*0*/
  101.   vf = -sintheta*cosphi;    /*1*/
  102.   vg = sinphi;              /*0*/
  103.   vi = -costheta*sinphi;    /*0*/
  104.   vj = -sintheta*sinphi;    /*0*/
  105.   vk = -cosphi;             /*1*/
  106.   vl = rho;                 /*5000*/
  107. }
  108.  
  109.  
  110.  
  111. struct object * create_object ( struct object *obj )
  112. {
  113.  
  114.   obj = (struct object *)malloc(sizeof (struct object));
  115.   obj->polygons = NULL;
  116.   obj->number   = 0;
  117.  
  118.   return (obj);
  119.  
  120. }
  121.  
  122.  
  123. void release_object ( struct object *obj )
  124. {
  125.   struct polygon *p;
  126.   struct my_point   *d;
  127.  
  128.   if ( obj->number > 0 )
  129.   {
  130.     while ( obj->polygons != NULL )
  131.     {
  132.       p = obj->polygons;
  133.       obj->polygons = obj->polygons->next;
  134.       while ( p->points != NULL )
  135.       {
  136.     d = p->points;
  137.     p->points = p->points->next;
  138.     free (d);
  139.       }
  140.       free (p);
  141.     }
  142.   }
  143.  
  144.   free (obj);
  145.  
  146. }
  147.  
  148.  
  149.  
  150. struct polygon * add_polygon ( struct object *obj, struct polygon *p, int line )
  151. {
  152.  
  153.   p = (struct polygon *)malloc(sizeof(struct polygon));
  154.   p->next = NULL;
  155.   p->points = NULL;
  156.   p->line = line;
  157.  
  158.   if ( obj->polygons == NULL )
  159.   {
  160.     obj->polygons = p;
  161.   }
  162.   else
  163.   {
  164.     p->next = obj->polygons;
  165.     obj->polygons = p;
  166.   }
  167.  
  168.   obj->number++;
  169.   return ( p );
  170. }
  171.  
  172.  
  173. void proj ( struct my_point *p, int *sx, int *sy, struct matrix *mat )
  174. {
  175.  
  176.    int   xt, yt, zt,
  177.      xe, ye, ze,
  178.      xw, yw, zw;
  179.  
  180.    /* Apply current global Matrix (mat) */
  181.    xt = p->x*mat->m[0][0] +
  182.     p->y*mat->m[1][0] +
  183.     p->z*mat->m[2][0] +
  184.          mat->m[3][0];
  185.  
  186.    yt = p->x*mat->m[0][1] +
  187.     p->y*mat->m[1][1] +
  188.     p->z*mat->m[2][1] +
  189.          mat->m[3][1];
  190.  
  191.    zt = p->x*mat->m[0][2] +
  192.     p->y*mat->m[1][2] +
  193.     p->z*mat->m[2][2] +
  194.          mat->m[3][2];
  195.  
  196.    xw = xt;
  197.    yw = yt;
  198.    zw = zt;
  199.  
  200.  
  201.    /* Translate to view */
  202.    xe = va*xw;                /* + vb*yw; */
  203.    ye = /* ve*xw + vf* */      yw;       /*+ vg*zw; */
  204.    ze = /* vi*xw + vj*yw + vk* */ zw + vl;
  205.  
  206.    /* Translate to perpective view */
  207.    *sx = screendist * xe / ze;
  208.    *sy = screendist * ye / ze;
  209. }
  210.  
  211.  
  212. void mini_proj ( struct my_point *p, int *sx, int *sy, int *sz, struct matrix *mat )
  213. {
  214.  
  215.    int   xt, yt, zt,
  216.      xe, ye, ze,
  217.      xw, yw, zw;
  218.  
  219.    /* Apply current global Matrix (mat) */
  220.    *sx = p->x*mat->m[0][0] +
  221.     p->y*mat->m[1][0] +
  222.     p->z*mat->m[2][0] +
  223.          mat->m[3][0];
  224.  
  225.    *sy = p->x*mat->m[0][1] +
  226.     p->y*mat->m[1][1] +
  227.     p->z*mat->m[2][1] +
  228.          mat->m[3][1];
  229.  
  230.    *sz = p->x*mat->m[0][2] +
  231.     p->y*mat->m[1][2] +
  232.     p->z*mat->m[2][2] +
  233.          mat->m[3][2];
  234.  
  235. }
  236.  
  237.  
  238. void draw_object ( struct object *obj, struct matrix *mat, int color )
  239. {
  240.  
  241.   struct polygon  *p;
  242.   struct my_point *d;
  243.   int x, y, x2, y2, *sx, *sy, *sx2, *sy2, svx, svy;
  244.  
  245.   setcolor ( color );
  246.   sx = &x;
  247.   sy = &y;
  248.   sx2 = &x2;
  249.   sy2 = &y2;
  250.  
  251.     p = obj->polygons;
  252.     while ( p != NULL )
  253.     {
  254.  
  255.       d = p->points;
  256.       proj ( d, sx, sy, mat );
  257.       svx = d->ax = x;                /* Save actual points for erase */
  258.       svy = d->ay = y;
  259.       d = d->next;
  260.  
  261.       while ( d != NULL )
  262.       {
  263.     proj(d, sx2, sy2, mat );
  264.     d->ax = x2;            /* Save actual points for erase */
  265.     d->ay = y2;
  266.     line (screen_x2-x, screen_y2-y, screen_x2- x2, screen_y2 - y2 );
  267.  
  268.     d = d->next;
  269.     x = x2;
  270.     y = y2;
  271.       }
  272.       if ( p->line == 0 )
  273.       {
  274.     line ( screen_x2-x, screen_y2-y, screen_x2-svx, screen_y2-svy );
  275.       }
  276.       p = p->next;
  277.     }
  278. }
  279.  
  280.  
  281. void erase_object ( struct object *obj )
  282. {
  283.  
  284.   struct polygon  *p;
  285.   struct my_point *d;
  286.   int svx, svy, x, y;
  287.  
  288.   setcolor ( BLACK );
  289.   p = obj->polygons;
  290.   while ( p != NULL )
  291.     {
  292.       d = p->points;
  293.       x = svx = d->ax;
  294.       y = svy = d->ay;
  295.  
  296.       d = d->next;
  297.       while ( d != NULL )
  298.       {
  299.     line ( screen_x2-x, screen_y2-y, screen_x2-d->ax, screen_y2-d->ay );
  300.     x = d->ax;
  301.     y = d->ay;
  302.     d = d->next;
  303.       }
  304.       if ( p->line == 0 )
  305.       {
  306.     line ( screen_x2-x, screen_y2-y, screen_x2-svx, screen_y2-svy );
  307.       }
  308.       p = p->next;
  309.     }
  310. }
  311.  
  312.  
  313. void add_vertex ( struct polygon *p, int x, int y, int z )
  314. {
  315.   struct my_point   *d, *temp;
  316.  
  317.   temp = p->points;
  318.   if ( temp != NULL )
  319.   {
  320.     while ( temp->next != NULL )
  321.     { temp = temp->next; }
  322.   }
  323.  
  324.   d = (struct my_point *)malloc(sizeof(struct my_point));
  325.   d->x = x;
  326.   d->y = y;
  327.   d->z = z;
  328.   d->oldx = x;
  329.   d->oldy = y;
  330.   d->oldz = z;
  331.   d->next = NULL;
  332.  
  333.   if ( p->points == NULL )
  334.   {
  335.     p->points = d;
  336.   }
  337.   else
  338.   {
  339.     temp->next = d;
  340.   }
  341. }
  342.  
  343.  
  344. struct object * make_plane_object ( struct object *obj )
  345. {
  346.  
  347.   struct polygon *p;
  348.  
  349.   obj = create_object ( obj );
  350.  
  351.  
  352. /* Plane */
  353.    p = add_polygon ( obj, p, 0 );
  354.    add_vertex ( p, -1600,-1000,0 );
  355.    add_vertex ( p, -1600,-1000,6000 );
  356.    add_vertex ( p, 1600,-1000,6000 );
  357.    add_vertex ( p, 1600,-1000,0 );
  358.  
  359. /* Vertical Marks */
  360.    p = add_polygon ( obj, p, 1 );
  361.    add_vertex ( p, -1400, -1000, 0 );
  362.    add_vertex ( p, -1400, -1000, 6000 );
  363.  
  364.    p = add_polygon ( obj, p, 1 );
  365.    add_vertex ( p, -1200, -1000, 0 );
  366.    add_vertex ( p, -1200, -1000, 6000 );
  367.  
  368.    p = add_polygon ( obj, p, 1 );
  369.    add_vertex ( p, -1000, -1000, 0 );
  370.    add_vertex ( p, -1000, -1000, 6000 );
  371.  
  372.    p = add_polygon ( obj, p, 1 );
  373.    add_vertex ( p, -800, -1000, 0 );
  374.    add_vertex ( p, -800, -1000, 6000 );
  375.  
  376.    p = add_polygon ( obj, p, 1 );
  377.    add_vertex ( p, -600, -1000, 0 );
  378.    add_vertex ( p, -600, -1000, 6000 );
  379.  
  380.    p = add_polygon ( obj, p,1 );
  381.    add_vertex ( p, -400, -1000, 0 );
  382.    add_vertex ( p, -400, -1000, 6000 );
  383.  
  384.    p = add_polygon ( obj, p,1 );
  385.    add_vertex ( p, -200, -1000, 0 );
  386.    add_vertex ( p, -200, -1000, 6000 );
  387.  
  388.    p = add_polygon ( obj, p,1 );
  389.    add_vertex ( p, 0, -1000, 0 );
  390.    add_vertex ( p, 0, -1000, 6000 );
  391.  
  392.    p = add_polygon ( obj, p,1 );
  393.    add_vertex ( p, 200, -1000, 0 );
  394.    add_vertex ( p, 200, -1000, 6000 );
  395.  
  396.    p = add_polygon ( obj, p,1 );
  397.    add_vertex ( p, 400, -1000, 0 );
  398.    add_vertex ( p, 400, -1000, 6000 );
  399.  
  400.    p = add_polygon ( obj, p,1 );
  401.    add_vertex ( p, 600, -1000, 0 );
  402.    add_vertex ( p, 600, -1000, 6000 );
  403.  
  404.    p = add_polygon ( obj, p,1 );
  405.    add_vertex ( p, 800, -1000, 0 );
  406.    add_vertex ( p, 800, -1000, 6000 );
  407.  
  408.    p = add_polygon ( obj, p,1 );
  409.    add_vertex ( p, 1000, -1000, 0 );
  410.    add_vertex ( p, 1000, -1000, 6000 );
  411.  
  412.    p = add_polygon ( obj, p,1 );
  413.    add_vertex ( p, 1200, -1000, 0 );
  414.    add_vertex ( p, 1200, -1000, 6000 );
  415.  
  416.    p = add_polygon ( obj, p,1 );
  417.    add_vertex ( p, 1400, -1000, 0 );
  418.    add_vertex ( p, 1400, -1000, 6000 );
  419.  
  420.  
  421.  
  422. /* Horizontal marks */
  423.    p = add_polygon ( obj, p,1 );
  424.    add_vertex ( p, -1600,-1000, 500 );
  425.    add_vertex ( p, 1600, -1000, 500 );
  426.  
  427.    p = add_polygon ( obj, p,1 );
  428.    add_vertex ( p, -1600, -1000, 1000 );
  429.    add_vertex ( p, 1600, -1000, 1000 );
  430.  
  431.    p = add_polygon ( obj, p,1 );
  432.    add_vertex ( p, -1600,-1000, 1500 );
  433.    add_vertex ( p, 1600, -1000, 1500 );
  434.  
  435.    p = add_polygon ( obj, p,1 );
  436.    add_vertex ( p, -1600, -1000, 2000 );
  437.    add_vertex ( p, 1600, -1000, 2000 );
  438.  
  439.    p = add_polygon ( obj, p,1 );
  440.    add_vertex ( p, -1600,-1000, 2500 );
  441.    add_vertex ( p, 1600, -1000, 2500 );
  442.  
  443.    p = add_polygon ( obj, p,1 );
  444.    add_vertex ( p, -1600, -1000, 3000 );
  445.    add_vertex ( p, 1600, -1000, 3000 );
  446.  
  447.    p = add_polygon ( obj, p,1 );
  448.    add_vertex ( p, -1600,-1000, 3500 );
  449.    add_vertex ( p, 1600, -1000, 3500 );
  450.  
  451.    p = add_polygon ( obj, p,1 );
  452.    add_vertex ( p, -1600, -1000, 4000 );
  453.    add_vertex ( p, 1600, -1000, 4000 );
  454.  
  455.    p = add_polygon ( obj, p,1 );
  456.    add_vertex ( p, -1600,-1000, 4500 );
  457.    add_vertex ( p, 1600, -1000, 4500 );
  458.  
  459.    p = add_polygon ( obj, p,1 );
  460.    add_vertex ( p, -1600, -1000, 5000 );
  461.    add_vertex ( p, 1600, -1000, 5000 );
  462.  
  463.    p = add_polygon ( obj, p,1 );
  464.    add_vertex ( p, -1600, -1000, 5500 );
  465.    add_vertex ( p, 1600, -1000, 5500 );
  466.  
  467.    return ( obj );
  468.  
  469. }
  470.  
  471.  
  472. struct object * make_hand_object ( struct object *hand )
  473. {
  474.  
  475.   struct polygon *p;
  476.  
  477.   hand = create_object ( hand );
  478.  
  479.   p = add_polygon ( hand, p, 0 );
  480.   add_vertex ( p, 400,0,1000 );
  481.   add_vertex ( p, 400,400,1000 );
  482.   add_vertex ( p, 400,400,300 );
  483.   add_vertex ( p, 400,0,300 );
  484.  
  485.   p = add_polygon ( hand, p, 0 );
  486.   add_vertex ( p, 450, 0, 1000 );
  487.   add_vertex ( p, 450, 400, 1000 );
  488.   add_vertex ( p, 450, 400, 300 );
  489.   add_vertex ( p, 450, 0, 300 );
  490.  
  491.   p = add_polygon ( hand, p, 1 );
  492.   add_vertex ( p, 400, 0, 1000 );
  493.   add_vertex ( p, 450, 0, 1000 );
  494.  
  495.   p = add_polygon ( hand, p, 1 );
  496.   add_vertex ( p, 400, 400, 1000 );
  497.   add_vertex ( p, 450, 400, 1000 );
  498.  
  499.   p = add_polygon ( hand, p, 1 );
  500.   add_vertex ( p, 400, 400, 300 );
  501.   add_vertex ( p, 450, 400, 300 );
  502.  
  503.   p = add_polygon ( hand, p, 1 );
  504.   add_vertex ( p, 400, 0, 300 );
  505.   add_vertex ( p, 450, 0, 300 );
  506.  
  507.  
  508.   return ( hand );
  509.  
  510. }
  511.  
  512. struct object * make_finger1_object ( struct object *f )
  513. {
  514.  
  515.   struct polygon *p;
  516.  
  517.   f = create_object ( f );
  518.  
  519. /*  p = add_polygon ( f, p,1 );
  520.   add_vertex ( p, 400,400,1000 );
  521.   add_vertex ( p, 400,400,1300 );
  522.   add_vertex ( p, 400,400,1500 );
  523.   add_vertex ( p, 400,400,1600 );  */
  524.  
  525. /* First segment of finger - front */
  526.   p = add_polygon ( f, p, 0 );
  527.   add_vertex ( p,400, 400, 1300 );
  528.   add_vertex ( p,400, 400, 1000 );
  529.   add_vertex ( p,400, 343, 1000 );
  530.   add_vertex ( p,400, 343, 1300 );
  531.  
  532. /* First segment of finger - back */
  533.   p = add_polygon ( f, p, 0 );
  534.   add_vertex ( p,450, 400, 1300 );
  535.   add_vertex ( p,450, 400, 1000 );
  536.   add_vertex ( p,450, 343, 1000 );
  537.   add_vertex ( p,450, 343, 1300 );
  538.  
  539. /* Line for first segment */
  540.   p = add_polygon ( f, p, 1 );
  541.   add_vertex ( p,400, 400, 1300 );
  542.   add_vertex ( p,450, 400, 1300 );
  543.  
  544.   p = add_polygon ( f, p, 1 );
  545.   add_vertex ( p,400, 343, 1000 );
  546.   add_vertex ( p,450, 343, 1000 );
  547.  
  548.   p = add_polygon ( f, p, 1 );
  549.   add_vertex ( p,400, 343, 1300 );
  550.   add_vertex ( p,450, 343, 1300 );
  551.  
  552.  
  553.   return ( f );
  554.  
  555. }
  556.  
  557.  
  558. struct object * make_finger12_object ( struct object *f )
  559. {
  560.  
  561.   struct polygon *p;
  562.  
  563.   f = create_object ( f );
  564.  
  565. /* Second segment of finger - front */
  566.   p = add_polygon ( f, p, 0 );
  567.   add_vertex ( p,400, 400, 1500 );
  568.   add_vertex ( p,400, 400, 1300 );
  569.   add_vertex ( p,400, 343, 1300 );
  570.   add_vertex ( p,400, 343, 1500 );
  571.  
  572. /* Second segment of finger - back */
  573.   p = add_polygon ( f, p, 0 );
  574.   add_vertex ( p,450, 400, 1500 );
  575.   add_vertex ( p,450, 400, 1300 );
  576.   add_vertex ( p,450, 343, 1300 );
  577.   add_vertex ( p,450, 343, 1500 );
  578.  
  579. /* Lines for second segment */
  580.   p = add_polygon ( f, p, 1 );
  581.   add_vertex ( p,400, 400, 1500 );
  582.   add_vertex ( p,450, 400, 1500 );
  583.  
  584.   p = add_polygon ( f, p, 1 );
  585.   add_vertex ( p,400, 343, 1500 );
  586.   add_vertex ( p,450, 343, 1500 );
  587.  
  588.   return ( f );
  589.  
  590. }
  591.  
  592.  
  593. struct object * make_finger13_object ( struct object *f )
  594. {
  595.  
  596.   struct polygon *p;
  597.  
  598.   f = create_object ( f );
  599.  
  600.  
  601. /* Third segment of finger - front */
  602.   p = add_polygon ( f, p, 0 );
  603.   add_vertex ( p,400, 400, 1600 );
  604.   add_vertex ( p,400, 400, 1500 );
  605.   add_vertex ( p,400, 343, 1500 );
  606.   add_vertex ( p,400, 343, 1600 );
  607.  
  608. /* Third segment of finger - back */
  609.   p = add_polygon ( f, p, 0 );
  610.   add_vertex ( p,450, 400, 1600 );
  611.   add_vertex ( p,450, 400, 1500 );
  612.   add_vertex ( p,450, 343, 1500 );
  613.   add_vertex ( p,450, 343, 1600 );
  614.  
  615. /* Lindes for third segment */
  616.   p = add_polygon ( f, p, 1 );
  617.   add_vertex ( p, 400, 400, 1600 );
  618.   add_vertex ( p, 450, 400, 1600 );
  619.  
  620.   p = add_polygon ( f, p, 1 );
  621.   add_vertex ( p, 400, 343, 1600 );
  622.   add_vertex ( p, 450, 343, 1600 );
  623.  
  624.  
  625.   return ( f );
  626.  
  627. }
  628.  
  629.  
  630. struct object * make_finger2_object ( struct object *f )
  631. {
  632.  
  633.   struct polygon *p;
  634.  
  635.   f = create_object ( f );
  636.  
  637. /* First segment of finger - front */
  638.   p = add_polygon ( f, p, 0 );
  639.   add_vertex ( p,400, 285, 1300 );
  640.   add_vertex ( p,400, 285, 1000 );
  641.   add_vertex ( p,400, 228, 1000 );
  642.   add_vertex ( p,400, 228, 1300 );
  643.  
  644. /* First segment of finger - back */
  645.   p = add_polygon ( f, p, 0 );
  646.   add_vertex ( p,450, 285, 1300 );
  647.   add_vertex ( p,450, 285, 1000 );
  648.   add_vertex ( p,450, 228, 1000 );
  649.   add_vertex ( p,450, 228, 1300 );
  650.  
  651. /* Line for first segment */
  652.   p = add_polygon ( f, p, 1 );
  653.   add_vertex ( p,400, 285, 1300 );
  654.   add_vertex ( p,450, 285, 1300 );
  655.  
  656.   p = add_polygon ( f, p, 1 );
  657.   add_vertex ( p,400, 228, 1000 );
  658.   add_vertex ( p,450, 228, 1000 );
  659.  
  660.   p = add_polygon ( f, p, 1 );
  661.   add_vertex ( p,400, 228, 1300 );
  662.   add_vertex ( p,450, 228, 1300 );
  663.  
  664.   return ( f );
  665.  
  666. }
  667.  
  668.  
  669. struct object * make_finger22_object ( struct object *f )
  670. {
  671.  
  672.   struct polygon *p;
  673.  
  674.   f = create_object ( f );
  675.  
  676.  
  677. /* Second segment of finger - front */
  678.   p = add_polygon ( f, p, 0 );
  679.   add_vertex ( p,400, 285, 1500 );
  680.   add_vertex ( p,400, 285, 1300 );
  681.   add_vertex ( p,400, 228, 1300 );
  682.   add_vertex ( p,400, 228, 1500 );
  683.  
  684. /* Second segment of finger - back */
  685.   p = add_polygon ( f, p, 0 );
  686.   add_vertex ( p,450, 285, 1500 );
  687.   add_vertex ( p,450, 285, 1300 );
  688.   add_vertex ( p,450, 228, 1300 );
  689.   add_vertex ( p,450, 228, 1500 );
  690.  
  691. /* Lines for second segment */
  692.   p = add_polygon ( f, p, 1 );
  693.   add_vertex ( p,400, 285, 1500 );
  694.   add_vertex ( p,450, 285, 1500 );
  695.  
  696.   p = add_polygon ( f, p, 1 );
  697.   add_vertex ( p,400, 228, 1500 );
  698.   add_vertex ( p,450, 228, 1500 );
  699.  
  700.  
  701.   return ( f );
  702.  
  703. }
  704.  
  705.  
  706. struct object * make_finger23_object ( struct object *f )
  707. {
  708.  
  709.   struct polygon *p;
  710.  
  711.   f = create_object ( f );
  712.  
  713.  
  714. /* Third segment of finger - front */
  715.   p = add_polygon ( f, p, 0 );
  716.   add_vertex ( p,400, 285, 1600 );
  717.   add_vertex ( p,400, 285, 1500 );
  718.   add_vertex ( p,400, 228, 1500 );
  719.   add_vertex ( p,400, 228, 1600 );
  720.  
  721. /* Third segment of finger - back */
  722.   p = add_polygon ( f, p, 0 );
  723.   add_vertex ( p,450, 285, 1600 );
  724.   add_vertex ( p,450, 285, 1500 );
  725.   add_vertex ( p,450, 228, 1500 );
  726.   add_vertex ( p,450, 228, 1600 );
  727.  
  728. /* Lindes for third segment */
  729.   p = add_polygon ( f, p, 1 );
  730.   add_vertex ( p, 400, 285, 1600 );
  731.   add_vertex ( p, 450, 285, 1600 );
  732.  
  733.   p = add_polygon ( f, p, 1 );
  734.   add_vertex ( p, 400, 228, 1600 );
  735.   add_vertex ( p, 450, 228, 1600 );
  736.  
  737.  
  738.   return ( f );
  739.  
  740. }
  741.  
  742. struct object * make_finger3_object ( struct object *f )
  743. {
  744.  
  745.   struct polygon *p;
  746.  
  747.   f = create_object ( f );
  748. /*
  749.   p = add_polygon ( f, p,1 );
  750.   add_vertex ( p, 400,120,1000 );
  751.   add_vertex ( p, 400,120,1300 );
  752.   add_vertex ( p, 400,120,1500 );
  753.   add_vertex ( p, 400,120,1600 );
  754. */
  755.  
  756.  
  757. /* First segment of finger - front */
  758.   p = add_polygon ( f, p, 0 );
  759.   add_vertex ( p,400, 171, 1300 );
  760.   add_vertex ( p,400, 171, 1000 );
  761.   add_vertex ( p,400, 114, 1000 );
  762.   add_vertex ( p,400, 114, 1300 );
  763.  
  764. /* First segment of finger - back */
  765.   p = add_polygon ( f, p, 0 );
  766.   add_vertex ( p,450, 171, 1300 );
  767.   add_vertex ( p,450, 171, 1000 );
  768.   add_vertex ( p,450, 114, 1000 );
  769.   add_vertex ( p,450, 114, 1300 );
  770.  
  771. /* Line for first segment */
  772.   p = add_polygon ( f, p, 1 );
  773.   add_vertex ( p,400, 171, 1300 );
  774.   add_vertex ( p,450, 171, 1300 );
  775.  
  776.   p = add_polygon ( f, p, 1 );
  777.   add_vertex ( p,400, 114, 1000 );
  778.   add_vertex ( p,450, 114, 1000 );
  779.  
  780.   p = add_polygon ( f, p, 1 );
  781.   add_vertex ( p,400, 114, 1300 );
  782.   add_vertex ( p,450, 114, 1300 );
  783.  
  784.  
  785.   return ( f );
  786.  
  787. }
  788.  
  789. struct object * make_finger32_object ( struct object *f )
  790. {
  791.  
  792.   struct polygon *p;
  793.  
  794.   f = create_object ( f );
  795.  
  796.  
  797. /* Second segment of finger - front */
  798.   p = add_polygon ( f, p, 0 );
  799.   add_vertex ( p,400, 171, 1500 );
  800.   add_vertex ( p,400, 171, 1300 );
  801.   add_vertex ( p,400, 114, 1300 );
  802.   add_vertex ( p,400, 114, 1500 );
  803.  
  804. /* Second segment of finger - back */
  805.   p = add_polygon ( f, p, 0 );
  806.   add_vertex ( p,450, 171, 1500 );
  807.   add_vertex ( p,450, 171, 1300 );
  808.   add_vertex ( p,450, 114, 1300 );
  809.   add_vertex ( p,450, 114, 1500 );
  810.  
  811. /* Lines for second segment */
  812.   p = add_polygon ( f, p, 1 );
  813.   add_vertex ( p,400, 171, 1500 );
  814.   add_vertex ( p,450, 171, 1500 );
  815.  
  816.   p = add_polygon ( f, p, 1 );
  817.   add_vertex ( p,400, 114, 1500 );
  818.   add_vertex ( p,450, 114, 1500 );
  819.  
  820.  
  821.   return ( f );
  822.  
  823. }
  824.  
  825. struct object * make_finger33_object ( struct object *f )
  826. {
  827.  
  828.   struct polygon *p;
  829.  
  830.   f = create_object ( f );
  831.  
  832. /* Third segment of finger - front */
  833.   p = add_polygon ( f, p, 0 );
  834.   add_vertex ( p,400, 171, 1600 );
  835.   add_vertex ( p,400, 171, 1500 );
  836.   add_vertex ( p,400, 114, 1500 );
  837.   add_vertex ( p,400, 114, 1600 );
  838.  
  839. /* Third segment of finger - back */
  840.   p = add_polygon ( f, p, 0 );
  841.   add_vertex ( p,450, 171, 1600 );
  842.   add_vertex ( p,450, 171, 1500 );
  843.   add_vertex ( p,450, 114, 1500 );
  844.   add_vertex ( p,450, 114, 1600 );
  845.  
  846. /* Lindes for third segment */
  847.   p = add_polygon ( f, p, 1 );
  848.   add_vertex ( p, 400, 171, 1600 );
  849.   add_vertex ( p, 450, 171, 1600 );
  850.  
  851.   p = add_polygon ( f, p, 1 );
  852.   add_vertex ( p, 400, 114, 1600 );
  853.   add_vertex ( p, 450, 114, 1600 );
  854.  
  855.  
  856.   return ( f );
  857.  
  858. }
  859.  
  860. struct object * make_finger4_object ( struct object *f )
  861. {
  862.  
  863.   struct polygon *p;
  864.  
  865.   f = create_object ( f );
  866. /*
  867.   p = add_polygon ( f, p,1 );
  868.   add_vertex ( p, 400,0,1000 );
  869.   add_vertex ( p, 400,0,1300 );
  870.   add_vertex ( p, 400,0,1500 );
  871.   add_vertex ( p, 400,0,1600 );
  872. */
  873.  
  874. /* First segment of finger - front */
  875.   p = add_polygon ( f, p, 0 );
  876.   add_vertex ( p,400, 57, 1300 );
  877.   add_vertex ( p,400, 57, 1000 );
  878.   add_vertex ( p,400, 0, 1000 );
  879.   add_vertex ( p,400, 0, 1300 );
  880.  
  881. /* First segment of finger - back */
  882.   p = add_polygon ( f, p, 0 );
  883.   add_vertex ( p,450, 57, 1300 );
  884.   add_vertex ( p,450, 57, 1000 );
  885.   add_vertex ( p,450, 0, 1000 );
  886.   add_vertex ( p,450, 0, 1300 );
  887.  
  888. /* Line for first segment */
  889.   p = add_polygon ( f, p, 1 );
  890.   add_vertex ( p,400, 57, 1300 );
  891.   add_vertex ( p,450, 57, 1300 );
  892.  
  893.   p = add_polygon ( f, p, 1 );
  894.   add_vertex ( p,400, 0, 1000 );
  895.   add_vertex ( p,450, 0, 1000 );
  896.  
  897.   p = add_polygon ( f, p, 1 );
  898.   add_vertex ( p,400, 0, 1300 );
  899.   add_vertex ( p,450, 0, 1300 );
  900.  
  901.   return ( f );
  902.  
  903. }
  904.  
  905. struct object * make_finger42_object ( struct object *f )
  906. {
  907.  
  908.   struct polygon *p;
  909.  
  910.   f = create_object ( f );
  911.  
  912. /* Second segment of finger - front */
  913.   p = add_polygon ( f, p, 0 );
  914.   add_vertex ( p,400, 57, 1500 );
  915.   add_vertex ( p,400, 57, 1300 );
  916.   add_vertex ( p,400, 0, 1300 );
  917.   add_vertex ( p,400, 0, 1500 );
  918.  
  919. /* Second segment of finger - back */
  920.   p = add_polygon ( f, p, 0 );
  921.   add_vertex ( p,450, 57, 1500 );
  922.   add_vertex ( p,450, 57, 1300 );
  923.   add_vertex ( p,450, 0, 1300 );
  924.   add_vertex ( p,450, 0, 1500 );
  925.  
  926. /* Lines for second segment */
  927.   p = add_polygon ( f, p, 1 );
  928.   add_vertex ( p,400, 57, 1500 );
  929.   add_vertex ( p,450, 57, 1500 );
  930.  
  931.   p = add_polygon ( f, p, 1 );
  932.   add_vertex ( p,400, 0, 1500 );
  933.   add_vertex ( p,450, 0, 1500 );
  934.  
  935.  
  936.   return ( f );
  937.  
  938. }
  939.  
  940. struct object * make_finger43_object ( struct object *f )
  941. {
  942.  
  943.   struct polygon *p;
  944.  
  945.   f = create_object ( f );
  946.  
  947. /* Third segment of finger - front */
  948.   p = add_polygon ( f, p, 0 );
  949.   add_vertex ( p,400, 57, 1600 );
  950.   add_vertex ( p,400, 57, 1500 );
  951.   add_vertex ( p,400, 0, 1500 );
  952.   add_vertex ( p,400, 0, 1600 );
  953.  
  954. /* Third segment of finger - back */
  955.   p = add_polygon ( f, p, 0 );
  956.   add_vertex ( p,450, 57, 1600 );
  957.   add_vertex ( p,450, 57, 1500 );
  958.   add_vertex ( p,450, 0, 1500 );
  959.   add_vertex ( p,450, 0, 1600 );
  960.  
  961. /* Lindes for third segment */
  962.   p = add_polygon ( f, p, 1 );
  963.   add_vertex ( p, 400, 57, 1600 );
  964.   add_vertex ( p, 450, 57, 1600 );
  965.  
  966.   p = add_polygon ( f, p, 1 );
  967.   add_vertex ( p, 400, 0, 1600 );
  968.   add_vertex ( p, 450, 0, 1600 );
  969.  
  970.  
  971.   return ( f );
  972.  
  973. }
  974.  
  975. struct object * make_cube ( struct object *c )
  976. {
  977.  
  978.   struct polygon *p;
  979.   c = create_object ( c );
  980.  
  981.   p = add_polygon ( c, p, 0 );
  982.   add_vertex ( p, -100, -800, 3000 );
  983.   add_vertex ( p, -100, -700, 3000 );
  984.   add_vertex ( p,  100, -700, 3000 );
  985.   add_vertex ( p,  100, -800, 3000 );
  986.  
  987.   p = add_polygon ( c, p, 0 );
  988.   add_vertex ( p, -200, -800, 4000 );
  989.   add_vertex ( p, -200, -700, 4000 );
  990.   add_vertex ( p,    0, -700, 4000 );
  991.   add_vertex ( p,    0, -800, 4000 );
  992.  
  993.  
  994.   p = add_polygon ( c, p, 1 );
  995.   add_vertex ( p, -200, -800, 4000 );
  996.   add_vertex ( p, -100, -800, 3000 );
  997.  
  998.   p = add_polygon ( c, p, 1 );
  999.   add_vertex ( p, -200, -700, 4000 );
  1000.   add_vertex ( p, -100, -700, 4000 );
  1001.  
  1002.   p = add_polygon ( c, p, 1 );
  1003.   add_vertex ( p, 0, -700, 4000 );
  1004.   add_vertex ( p, 100, -700, 3000 );
  1005.  
  1006.   p = add_polygon ( c, p, 1 );
  1007.   add_vertex ( p, 0, -800, 4000 );
  1008.   add_vertex ( p, 100, -800, 3000 );
  1009.  
  1010.   return ( c );
  1011.  
  1012. }
  1013.  
  1014.  
  1015.  
  1016.  
  1017. struct matrix * matrixmult ( struct matrix *a, struct matrix *b )
  1018. {
  1019.   int i, j, k;
  1020.   float t;
  1021.   struct matrix *c;
  1022.  
  1023.   c = (struct matrix *)malloc(sizeof(struct matrix));
  1024.  
  1025.   for (i=0;i<4;i++)
  1026.   {
  1027.    for (j=0;j<4;j++)
  1028.    {
  1029.     t = 0.0;
  1030.     for (k=0;k<4;k++)
  1031.     {
  1032.      t = t + a->m[i][k] * b->m[k][j];
  1033.     }
  1034.     c->m[i][j] = t;
  1035.    }
  1036.   }
  1037.  
  1038.   return ( c );
  1039. }
  1040.  
  1041.  
  1042. struct matrix * object_translate ( struct matrix *mat, int transx, int transy, int transz )
  1043. {
  1044.   struct matrix *b, *c;
  1045.   b = (struct matrix *)malloc(sizeof(struct matrix));
  1046.  
  1047.   identity ( b );
  1048.   b->m[3][0] = transx;
  1049.   b->m[3][1] = transy;
  1050.   b->m[3][2] = transz;
  1051.   c = matrixmult ( mat, b );
  1052.   free ( mat );
  1053.   free (b);
  1054.  
  1055.   return ( c );
  1056. }
  1057.  
  1058.  
  1059.  
  1060. struct matrix * object_scale ( struct matrix *mat, float scale )
  1061. {
  1062.   struct matrix *b, *c;
  1063.   b = (struct matrix *)malloc(sizeof(struct matrix));
  1064.  
  1065.   identity ( b );
  1066.   b->m[0][0] *= scale;
  1067.   b->m[1][1] *= scale;
  1068.   b->m[2][2] *= scale;
  1069.   c = matrixmult ( mat, b );
  1070.   free ( mat );
  1071.   free(b);
  1072.  
  1073.   return ( c );
  1074. }
  1075.  
  1076.  
  1077. struct matrix * object_xrot ( struct matrix *mat, float deg )
  1078. {
  1079.   float thecos, thesin;
  1080.   struct matrix *b, *c;
  1081.  
  1082.   thecos = cos ( deg*to_radians );
  1083.   thesin = sin ( deg*to_radians );
  1084.   b = (struct matrix *)malloc(sizeof(struct matrix));
  1085.  
  1086.   identity ( b );
  1087.   b->m[1][1] = thecos;
  1088.   b->m[1][2] = thesin;
  1089.   b->m[2][1] = -thesin;
  1090.   b->m[2][2] = thecos;
  1091.   c = matrixmult ( mat, b );
  1092.   free ( mat );
  1093.   free ( b );
  1094.  
  1095.   return ( c );
  1096. }
  1097.  
  1098.  
  1099. struct matrix * object_yrot ( struct matrix *mat, float deg )
  1100. {
  1101.   float thecos, thesin;
  1102.   struct matrix *b, *c;
  1103.  
  1104.   thecos = cos ( deg*to_radians );
  1105.   thesin = sin ( deg*to_radians );
  1106.   b = (struct matrix *)malloc(sizeof(struct matrix));
  1107.  
  1108.   identity ( b );
  1109.   b->m[0][0] = thecos;
  1110.   b->m[0][2] = -thesin;
  1111.   b->m[2][0] = thesin;
  1112.   b->m[2][2] = thecos;
  1113.   c = matrixmult ( mat,b );
  1114.   free ( mat );
  1115.   free ( b );
  1116.  
  1117.   return ( c );
  1118. }
  1119.  
  1120.  
  1121.  
  1122. struct matrix * object_zrot ( struct matrix *mat, float deg )
  1123. {
  1124.   float thecos, thesin;
  1125.   struct matrix *b, *c;
  1126.  
  1127.   thecos = cos ( deg*to_radians );
  1128.   thesin = sin ( deg*to_radians );
  1129.   b = (struct matrix *)malloc(sizeof(struct matrix));
  1130.  
  1131.   identity ( b );
  1132.   b->m[0][0] = thecos;
  1133.   b->m[0][1] = thesin;
  1134.   b->m[1][0] = -thesin;
  1135.   b->m[1][1] = thecos;
  1136.   c = matrixmult ( mat, b );
  1137.   free ( mat );
  1138.   free ( b );
  1139.  
  1140.   return ( c );
  1141. }
  1142.  
  1143.  
  1144. void change_finger_joint_one ( float deg, struct my_point *d )
  1145. {
  1146.  
  1147.   int x, y, z, ox, oy, oz, i;
  1148.   float thesin, thecos;
  1149.   struct matrix *m, *n, *o, *old;
  1150.   struct my_point *e;
  1151.  
  1152.   n = (struct matrix *)malloc(sizeof(struct matrix));
  1153.   o = (struct matrix *)malloc(sizeof(struct matrix));
  1154.  
  1155.   identity ( n );
  1156.   identity ( o );
  1157.  
  1158.   thecos = cos ( deg * to_radians );         /* set up rotation matrix */
  1159.   thesin = sin ( deg * to_radians );
  1160.  
  1161.   o->m[0][0] = thecos;
  1162.   o->m[2][0] = thesin;
  1163.   o->m[0][2] = -thesin;
  1164.   o->m[2][2] = thecos;
  1165.  
  1166.  
  1167.   ox = d->oldx;
  1168.   oy = d->oldy;
  1169.   oz = d->oldz;
  1170.  
  1171.     n->m[3][0] = -ox;             /* setup translation matrix to origin */
  1172.     n->m[3][1] = -oy;
  1173.     n->m[3][2] = -oz;
  1174.     m = matrixmult ( n, o );         /* multiply these */
  1175.  
  1176.  
  1177.     e = d;
  1178.     d = d->next;
  1179.     n->m[3][0] = e->x;             /* Previous point translation back */
  1180.     n->m[3][1] = e->y;
  1181.     n->m[3][2] = e->z;
  1182.  
  1183.     old = m;
  1184.     m = matrixmult ( old, n );                  /* Final matrix */
  1185.     free ( old );
  1186.  
  1187.     ox = d->x;
  1188.     oy = d->y;
  1189.     oz = d->z;
  1190.  
  1191.     x = d->x * m->m[0][0] +
  1192.     d->y * m->m[1][0] +
  1193.     d->z * m->m[2][0] +
  1194.            m->m[3][0];
  1195.  
  1196.     y = d->x * m->m[0][1] +
  1197.     d->y * m->m[1][1] +
  1198.     d->z * m->m[2][1] +
  1199.            m->m[3][1];
  1200.  
  1201.     z = d->x * m->m[0][2] +
  1202.     d->y * m->m[1][2] +
  1203.     d->z * m->m[2][2] +
  1204.            m->m[3][2];
  1205.  
  1206.     d->oldx = d->x;
  1207.     d->oldy = d->y;
  1208.     d->oldz = d->z;
  1209.  
  1210.     d->x = x;
  1211.     d->y = y;
  1212.     d->z = z;
  1213.  
  1214.   free ( n );
  1215.   free ( o );
  1216.   free ( m );
  1217.  
  1218. }
  1219.  
  1220.  
  1221. void main()
  1222. {
  1223.  
  1224.   char ch;
  1225.   int graphmode, graphdriver, i, x, y, z;
  1226.   struct my_point joint_one, joint_two, joint_three;
  1227.   int    glovex=0, glovey=0, glovez=0, gloveroll=0, close=0, change=0;
  1228.  
  1229.  
  1230.   struct object  *hand,
  1231.  
  1232.                  *finger1,
  1233.                  *finger2,
  1234.                  *finger3,
  1235.                  *finger4,
  1236.  
  1237.                  *finger1_2,
  1238.                  *finger2_2,
  1239.                  *finger3_2,
  1240.                  *finger4_2,
  1241.  
  1242.                  *finger1_3,
  1243.                  *finger2_3,
  1244.                  *finger3_3,
  1245.                  *finger4_3;
  1246.  
  1247.   struct matrix *hand_matrix,
  1248.                 *finger1_matrix,
  1249.                 *finger2_matrix,
  1250.                 *finger3_matrix;
  1251.  
  1252.   glove_data    glov;
  1253.   
  1254.   joint_one.x = 450; joint_one.y = 400; joint_one.z = 1000;
  1255.   joint_two.x = 450; joint_two.y = 400; joint_two.z = 1300;
  1256.   joint_three.x = 450; joint_three.y = 400; joint_three.z = 1500;
  1257.  
  1258.  
  1259.   graphmode = VGAHI;
  1260.   graphdriver = VGA;
  1261.   initgraph ( &graphdriver, &graphmode, "c:\tc" );
  1262.  
  1263.   hand_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  1264.   finger1_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  1265.   finger2_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  1266.   finger3_matrix = (struct matrix *)malloc(sizeof(struct matrix));
  1267.  
  1268.   identity ( hand_matrix );
  1269.   identity ( finger1_matrix );
  1270.   identity ( finger2_matrix );
  1271.   identity ( finger3_matrix );
  1272.  
  1273.  
  1274.   glove_init ( HIRES, NULL );
  1275.   printf ( "Exercise the glove and then Press any key!!\n" );
  1276.   getch();
  1277.  
  1278.  
  1279.   create_view_transformation();
  1280.   cleardevice();
  1281.  
  1282.  
  1283.  
  1284.   hand = make_hand_object ( hand );
  1285.   finger1 = make_finger1_object ( finger1 );
  1286.   finger2 = make_finger2_object ( finger2 );
  1287.   finger3 = make_finger3_object ( finger3 );
  1288.   finger4 = make_finger4_object ( finger4 );
  1289.  
  1290.   finger1_2 = make_finger12_object ( finger1 );
  1291.   finger2_2 = make_finger22_object ( finger2 );
  1292.   finger3_2 = make_finger32_object ( finger3 );
  1293.   finger4_2 = make_finger42_object ( finger4 );
  1294.  
  1295.   finger1_3 = make_finger13_object ( finger1 );
  1296.   finger2_3 = make_finger23_object ( finger2 );
  1297.   finger3_3 = make_finger33_object ( finger3 );
  1298.   finger4_3 = make_finger43_object ( finger4 );
  1299.  
  1300.   x = hand->polygons->points->x;
  1301.   y = hand->polygons->points->y;
  1302.   z = hand->polygons->points->z;
  1303.   hand_matrix    = object_translate ( hand_matrix, -x, -y, -z );
  1304.   hand_matrix    = object_zrot ( hand_matrix, 90 );
  1305.   hand_matrix    = object_translate ( hand_matrix, x, y, z );
  1306.   finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  1307.   finger1_matrix = object_zrot ( finger1_matrix, 90 );
  1308.   finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  1309.  
  1310.   finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  1311.   finger2_matrix = object_zrot ( finger2_matrix, 90 );
  1312.   finger2_matrix = object_translate ( finger2_matrix, x, y, z );
  1313.  
  1314.   finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  1315.   finger3_matrix = object_zrot ( finger3_matrix, 90 );
  1316.   finger3_matrix = object_translate ( finger3_matrix, x, y, z );
  1317.  
  1318.   draw_object ( hand, hand_matrix, RED );
  1319.   draw_object ( finger1, finger1_matrix, RED );
  1320.   draw_object ( finger2, finger1_matrix, RED );
  1321.   draw_object ( finger3, finger1_matrix, RED );
  1322.   draw_object ( finger4, finger1_matrix, RED );
  1323.  
  1324.   draw_object ( finger1_2, finger2_matrix, RED );
  1325.   draw_object ( finger2_2, finger2_matrix, RED );
  1326.   draw_object ( finger3_2, finger2_matrix, RED );
  1327.   draw_object ( finger4_2, finger2_matrix, RED );
  1328.  
  1329.   draw_object ( finger1_3, finger3_matrix, RED );
  1330.   draw_object ( finger2_3, finger3_matrix, RED );
  1331.   draw_object ( finger3_3, finger3_matrix, RED );
  1332.   draw_object ( finger4_3, finger3_matrix, RED );
  1333.  
  1334.  
  1335.   while ( ch != 'q' )
  1336.   {
  1337.  
  1338.  
  1339.     while (!glove_ready()) glove_delay();
  1340.     glove_read(&glov);
  1341.     x = y = z = 0;
  1342.  
  1343.     if ( glov.x != glovex )
  1344.     {
  1345.       change = 2;
  1346.       if ( glov.x > glovex )
  1347.     x = abs(glov.x-glovex) * 25;
  1348.       else
  1349.     x = abs(glov.x-glovex) * -25;
  1350.       glovex = glov.x;
  1351.     }
  1352.  
  1353.  
  1354.     if ( glov.y != glovey  )
  1355.     {
  1356.       change = 2;
  1357.       if ( glov.y > glovey )
  1358.     y = abs(glov.y-glovey) * 25;
  1359.       else
  1360.     y = abs(glov.y-glovey) * -25;
  1361.       glovey = glov.y;
  1362.     }
  1363.  
  1364.     if ( glov.z != glovez )
  1365.     {
  1366.       change = 2;
  1367.       if ( glov.z > glovez )
  1368.     z = abs(glov.z-glovez) * -200;
  1369.       else
  1370.     z = abs(glov.z-glovez) * 200;
  1371.       glovez = glov.z;
  1372.     }
  1373.  
  1374.  
  1375.  
  1376.     if ( change == 2 )
  1377.     {
  1378.       hand_matrix = object_translate ( hand_matrix, x,y,z );
  1379.       finger1_matrix = object_translate ( finger1_matrix, x,y,z  );
  1380.       finger2_matrix = object_translate ( finger2_matrix, x,y,z  );
  1381.       finger3_matrix = object_translate ( finger3_matrix, x,y,z  );
  1382.     }
  1383.  
  1384.     if ( change == 2 )
  1385.     {
  1386.      erase_object ( hand );
  1387.      erase_object ( finger1 );
  1388.      erase_object ( finger2 );
  1389.      erase_object ( finger3 );
  1390.      erase_object ( finger4 );
  1391.      erase_object ( finger1_2 );
  1392.      erase_object ( finger2_2 );
  1393.      erase_object ( finger3_2 );
  1394.      erase_object ( finger4_2 );
  1395.      erase_object ( finger1_3 );
  1396.      erase_object ( finger2_3 );
  1397.      erase_object ( finger3_3 );
  1398.      erase_object ( finger4_3 );
  1399.      change = 1;
  1400.     }
  1401.  
  1402.  
  1403.  
  1404.     if ( (glov.keys & 0xff) <= 0xA0 )
  1405.     {
  1406.       ch = 'q';
  1407.     }
  1408.  
  1409.  
  1410.  
  1411.     if (((glov.fingers & 0xff ) <= 0x80 ) && ( close == 1 ) )
  1412.     {
  1413.  
  1414.     
  1415.          mini_proj ( &joint_one, &x, &y, &z, finger1_matrix );
  1416.          finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  1417.          if ( gloveroll == 1 )
  1418.            finger1_matrix = object_yrot ( finger1_matrix, 90 );
  1419.          else
  1420.            finger1_matrix = object_xrot ( finger1_matrix, -90 );
  1421.          finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  1422.  
  1423.  
  1424.          mini_proj ( &joint_two, &x, &y, &z, finger2_matrix );
  1425.          finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  1426.          if ( gloveroll == 1 )
  1427.          {
  1428.            finger2_matrix = object_yrot ( finger2_matrix, 180 );
  1429.            finger2_matrix = object_translate ( finger2_matrix, x+300, y, z+358 );
  1430.          }
  1431.          else
  1432.          {
  1433.            finger2_matrix = object_xrot ( finger2_matrix, 180 );
  1434.            finger2_matrix = object_translate ( finger2_matrix, x, y+300, z+358 );
  1435.          }
  1436.  
  1437.  
  1438.          mini_proj ( &joint_three, &x, &y, &z, finger3_matrix );
  1439.          finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  1440.          if ( gloveroll == 1 )
  1441.          {
  1442.            finger3_matrix = object_yrot ( finger3_matrix, 270 );
  1443.            finger3_matrix = object_translate ( finger3_matrix, x+250, y, z+760 );
  1444.          }
  1445.          else
  1446.          {
  1447.            finger3_matrix = object_xrot ( finger3_matrix, 90 );
  1448.            finger3_matrix = object_translate ( finger3_matrix, x, y+250, z+760 );
  1449.          }
  1450.       close = 0;
  1451.  
  1452.     }
  1453.  
  1454.     if (((glov.fingers & 0xff ) > 0x80 ) && ( close == 0 ))
  1455.     {
  1456.  
  1457.  
  1458.          mini_proj ( &joint_one, &x, &y, &z, finger1_matrix );
  1459.          finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  1460.          if ( gloveroll == 1 )
  1461.            finger1_matrix = object_yrot ( finger1_matrix, -90 );
  1462.          else
  1463.            finger1_matrix = object_xrot ( finger1_matrix, 90 );
  1464.          finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  1465.  
  1466.  
  1467.          mini_proj ( &joint_two, &x, &y, &z, finger2_matrix );
  1468.          finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  1469.          if ( gloveroll == 1 )
  1470.          {
  1471.            finger2_matrix = object_yrot ( finger2_matrix, 180 );
  1472.            finger2_matrix = object_translate ( finger2_matrix, x-300, y, z-358 );
  1473.          }
  1474.          else
  1475.          {
  1476.            finger2_matrix = object_xrot ( finger2_matrix, 180 );
  1477.            finger2_matrix = object_translate ( finger2_matrix, x, y-300, z-358 );
  1478.          }
  1479.  
  1480.  
  1481.          mini_proj ( &joint_three, &x, &y, &z, finger3_matrix );
  1482.          finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  1483.          if ( gloveroll == 1 )
  1484.          {
  1485.            finger3_matrix = object_yrot ( finger3_matrix, 90 );
  1486.            finger3_matrix = object_translate ( finger3_matrix, x-250, y, z-760 );
  1487.          }
  1488.          else
  1489.          {
  1490.            finger3_matrix = object_xrot ( finger3_matrix, -90 );
  1491.            finger3_matrix = object_translate ( finger3_matrix, x, y-250, z-760 );
  1492.          }
  1493.  
  1494.      close = 1;
  1495.  
  1496.     }
  1497.  
  1498.     if (( glov.rot >= 3 ) && (glov.rot <=10 ) && ( gloveroll == 0))
  1499.     {
  1500.  
  1501.      mini_proj ( hand->polygons->points, &x, &y, &z, hand_matrix );
  1502.  
  1503.      hand_matrix = object_translate ( hand_matrix, -x, -y, -z );
  1504.      hand_matrix = object_zrot ( hand_matrix, -90 );
  1505.      hand_matrix = object_translate ( hand_matrix, x, y, z );
  1506.  
  1507.      finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  1508.      finger1_matrix = object_zrot ( finger1_matrix, -90 );
  1509.      finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  1510.  
  1511.      finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  1512.      finger2_matrix = object_zrot ( finger2_matrix, -90 );
  1513.      finger2_matrix = object_translate ( finger2_matrix, x, y, z );
  1514.  
  1515.      finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  1516.      finger3_matrix = object_zrot ( finger3_matrix, -90 );
  1517.      finger3_matrix = object_translate ( finger3_matrix, x, y, z );
  1518.      gloveroll = 1;
  1519.     }
  1520.  
  1521.  
  1522.     if ((glov.rot < 2 )  && ( gloveroll == 1 ))
  1523.     {
  1524.      gloveroll = 0;
  1525.  
  1526.      mini_proj ( hand->polygons->points, &x, &y, &z, hand_matrix );
  1527.  
  1528.      hand_matrix = object_translate ( hand_matrix, -x, -y, -z );
  1529.      hand_matrix = object_zrot ( hand_matrix, 90 );
  1530.      hand_matrix = object_translate ( hand_matrix, x, y, z );
  1531.  
  1532.      finger1_matrix = object_translate ( finger1_matrix, -x, -y, -z );
  1533.      finger1_matrix = object_zrot ( finger1_matrix, 90 );
  1534.      finger1_matrix = object_translate ( finger1_matrix, x, y, z );
  1535.  
  1536.      finger2_matrix = object_translate ( finger2_matrix, -x, -y, -z );
  1537.      finger2_matrix = object_zrot ( finger2_matrix, 90 );
  1538.      finger2_matrix = object_translate ( finger2_matrix, x, y, z );
  1539.  
  1540.      finger3_matrix = object_translate ( finger3_matrix, -x, -y, -z );
  1541.      finger3_matrix = object_zrot ( finger3_matrix, 90 );
  1542.      finger3_matrix = object_translate ( finger3_matrix, x, y, z );
  1543.      }
  1544.  
  1545.  
  1546.      if ( change == 1 )
  1547.      {
  1548.       draw_object ( hand, hand_matrix, RED );
  1549.       draw_object ( finger1, finger1_matrix, RED );
  1550.       draw_object ( finger2, finger1_matrix, RED );
  1551.       draw_object ( finger3, finger1_matrix, RED );
  1552.       draw_object ( finger4, finger1_matrix, RED );
  1553.  
  1554.       draw_object ( finger1_2, finger2_matrix, RED );
  1555.       draw_object ( finger2_2, finger2_matrix, RED );
  1556.       draw_object ( finger3_2, finger2_matrix, RED );
  1557.       draw_object ( finger4_2, finger2_matrix, RED );
  1558.  
  1559.       draw_object ( finger1_3, finger3_matrix, RED );
  1560.       draw_object ( finger2_3, finger3_matrix, RED );
  1561.       draw_object ( finger3_3, finger3_matrix, RED );
  1562.       draw_object ( finger4_3, finger3_matrix, RED );
  1563.       change = 0;
  1564.      }
  1565.  
  1566.   }
  1567.  
  1568.  
  1569.   release_object ( hand );
  1570.   release_object ( finger1 );
  1571.   release_object ( finger2 );
  1572.   release_object ( finger3 );
  1573.   release_object ( finger4 );
  1574.  
  1575.   release_object ( finger1_2 );
  1576.   release_object ( finger2_2 );
  1577.   release_object ( finger3_2 );
  1578.   release_object ( finger4_2 );
  1579.  
  1580.   release_object ( finger1_3 );
  1581.   release_object ( finger2_3 );
  1582.   release_object ( finger3_3 );
  1583.   release_object ( finger4_3 );
  1584.  
  1585.   free ( hand_matrix );
  1586.   free ( finger1_matrix );
  1587.   free ( finger2_matrix );
  1588.   free ( finger3_matrix );
  1589.  
  1590.   closegraph();
  1591. }
  1592.