home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / voglw.zip / vcalls.c < prev    next >
C/C++ Source or Header  |  1997-02-13  |  5KB  |  311 lines
  1. #include "vogl.h"
  2.  
  3. /*
  4.  * Handles all the v4f v3f v2f calls
  5.  */
  6.  
  7.  
  8. /*
  9.  *  vcall
  10.  *
  11.  *    Specify a generic point.
  12.  */
  13. void
  14. vcall(vector, len)
  15.     float    vector[];
  16.     int    len;
  17. {
  18.     Vector    vec;
  19.     static    Coord    tmesh[2][3];    /* 2 vectr register for triangular mesh */
  20.         static    Coord    qstrip[3][3];    /* 3 vectr register for quad mesh */
  21.         int    sjm;            /* temporary variable */
  22.  
  23.     vec[0] = vector[0];
  24.     vec[1] = vector[1];
  25.     vec[2] = 0.0;
  26.     vec[3] = 1.0;
  27.  
  28.     if (len == 3) {
  29.         vec[2] = vector[2];
  30.         vec[3] = 1.0;
  31.     } else if (len == 4) {
  32.         vec[2] = vector[2];
  33.         vec[3] = vector[3];
  34.     }
  35.  
  36.     if (vdevice.save) {
  37.         vdevice.savex = vec[V_X];
  38.         vdevice.savey = vec[V_Y];
  39.         vdevice.savez = vec[V_Z];
  40.     } 
  41.     
  42.     switch (vdevice.bgnmode) {
  43.     case VLINE:
  44.         if (vdevice.save) {
  45.             vdevice.save = 0;
  46.             move(vec[V_X], vec[V_Y], vec[V_Z]);
  47.             break;
  48.         }
  49.  
  50.         draw(vec[V_X], vec[V_Y], vec[V_Z]);
  51.         break;
  52.     case VPNT:
  53.         pnt(vec[V_X], vec[V_Y], vec[V_Z]);
  54.         break;
  55.     case VCLINE:
  56.         if (vdevice.save) {
  57.             vdevice.save = 0;
  58.             move(vec[V_X], vec[V_Y], vec[V_Z]);
  59.             break;
  60.         }
  61.             
  62.         draw(vec[V_X], vec[V_Y], vec[V_Z]);
  63.         break;
  64.     case VPOLY:
  65.         if (vdevice.save) {
  66.             vdevice.save = 0;
  67.             pmv(vec[V_X], vec[V_Y], vec[V_Z]);
  68.             break;
  69.         } 
  70.  
  71.         pdr(vec[V_X], vec[V_Y], vec[V_Z]);
  72.         break;
  73.  
  74.     case VTMESH:
  75.         if( vdevice.save < 2 ) {  /* save the first two calls */
  76.             tmesh[vdevice.save][V_X] = vec[V_X];
  77.             tmesh[vdevice.save][V_Y] = vec[V_Y];
  78.             tmesh[vdevice.save][V_Z] = vec[V_Z];
  79.         } else {  /* plot triangle */
  80.             pmv(tmesh[0][V_X], tmesh[0][V_Y], tmesh[0][V_Z]);
  81.             pdr(tmesh[1][V_X], tmesh[1][V_Y], tmesh[1][V_Z]);
  82.             pdr(     vec[V_X],      vec[V_Y],      vec[V_Z]);
  83.             pclos();
  84.             sjm = vdevice.save % 2;     /* save new point */
  85.             tmesh[sjm][V_X] = vec[V_X];
  86.             tmesh[sjm][V_Y] = vec[V_Y];
  87.             tmesh[sjm][V_Z] = vec[V_Z];
  88.         }
  89.         vdevice.save++;
  90.         break;
  91.     case VQSTRIP:
  92.         if( vdevice.save < 3 ) {  /* save the first three calls */
  93.             qstrip[vdevice.save][V_X] = vec[V_X];
  94.             qstrip[vdevice.save][V_Y] = vec[V_Y];
  95.             qstrip[vdevice.save][V_Z] = vec[V_Z];
  96.         } else { 
  97.             sjm = vdevice.save % 2;
  98.             if (sjm) { /* sjm !=0; plot quadralateral */
  99.                 pmv(qstrip[0][V_X], qstrip[0][V_Y], qstrip[0][V_Z]);
  100.                 pdr(qstrip[1][V_X], qstrip[1][V_Y], qstrip[1][V_Z]);
  101.                 pdr(      vec[V_X],       vec[V_Y],       vec[V_Z]);
  102.                 pdr(qstrip[2][V_X], qstrip[2][V_Y], qstrip[2][V_Z]);
  103.                 pclos();
  104.                 /* save 2 newest points over 2 oldest */
  105.                 qstrip[0][V_X] = qstrip[2][V_X]; 
  106.                 qstrip[0][V_Y] = qstrip[2][V_Y];
  107.                 qstrip[0][V_Z] = qstrip[2][V_Z];
  108.                 qstrip[1][V_X] = vec[V_X];
  109.                 qstrip[1][V_Y] = vec[V_Y];
  110.                 qstrip[1][V_Z] = vec[V_Z];
  111.             } else {  /* sjm == 0; save vec in register 2 */
  112.                 qstrip[2][V_X] = vec[V_X];
  113.                 qstrip[2][V_Y] = vec[V_Y];
  114.                 qstrip[2][V_Z] = vec[V_Z];
  115.             }
  116.         }
  117.         vdevice.save++;
  118.         break;
  119.     default:
  120.         move(vec[V_X], vec[V_Y], vec[V_Z]);
  121.     }
  122. }
  123.         
  124. /*
  125.  * v4f    
  126.  *     Adds a 4D point to our fake point buffer
  127.  */
  128. void
  129. v4f(vec)
  130.     float    vec[4];
  131. {
  132.     vcall(vec, 4);
  133. }
  134.  
  135. /*
  136.  * v3f    
  137.  *     Adds a 3D point to our fake point buffer
  138.  */
  139. void
  140. v3f(vec)
  141.     float    vec[3];
  142. {
  143.     vcall(vec, 3);
  144. }
  145.  
  146. /*
  147.  * v2f    
  148.  *     Adds a 2D point to our fake point buffer
  149.  */
  150. void
  151. v2f(vec)
  152.     float    vec[2];
  153. {
  154.     vcall(vec, 2);
  155. }
  156.  
  157.  
  158. /*
  159.  * v4d    
  160.  *     Adds a 4D point to our fake point buffer
  161.  */
  162. void
  163. v4d(vec)
  164.     double    vec[4];
  165. {
  166.     float    v[4];
  167.  
  168.     v[0] = vec[0];
  169.     v[1] = vec[1];
  170.     v[2] = vec[2];
  171.     v[3] = vec[3];
  172.  
  173.     vcall(v, 4);
  174. }
  175.  
  176. /*
  177.  * v3d    
  178.  *     Adds a 3D point to our fake point buffer
  179.  */
  180. void
  181. v3d(vec)
  182.     double    vec[3];
  183. {
  184.     float    v[3];
  185.  
  186.     v[0] = vec[0];
  187.     v[1] = vec[1];
  188.     v[2] = vec[2];
  189.  
  190.     vcall(v, 3);
  191. }
  192.  
  193. /*
  194.  * v2d    
  195.  *     Adds a 2D point to our fake point buffer
  196.  */
  197. void
  198. v2d(vec)
  199.     double    vec[2];
  200. {
  201.     float    v[2];
  202.  
  203.     v[0] = vec[0];
  204.     v[1] = vec[1];
  205.  
  206.     vcall(v, 2);
  207. }
  208.  
  209.  
  210.  
  211. /*
  212.  * v4i    
  213.  *     Adds a 4D point to our fake point buffer
  214.  */
  215. void
  216. v4i(vec)
  217.     long    vec[4];
  218. {
  219.     float    v[4];
  220.  
  221.     v[0] = vec[0];
  222.     v[1] = vec[1];
  223.     v[2] = vec[2];
  224.     v[3] = vec[3];
  225.  
  226.     vcall(v, 4);
  227. }
  228.  
  229. /*
  230.  * v3i    
  231.  *     Adds a 3D point to our fake point buffer
  232.  */
  233. void
  234. v3i(vec)
  235.     long    vec[3];
  236. {
  237.     float    v[3];
  238.  
  239.     v[0] = vec[0];
  240.     v[1] = vec[1];
  241.     v[2] = vec[2];
  242.  
  243.     vcall(v, 3);
  244. }
  245.  
  246. /*
  247.  * v2i    
  248.  *     Adds a 2D point to our fake point buffer
  249.  */
  250. void
  251. v2i(vec)
  252.     long    vec[2];
  253. {
  254.     float    v[2];
  255.  
  256.     v[0] = vec[0];
  257.     v[1] = vec[1];
  258.  
  259.     vcall(v, 2);
  260. }
  261. /*
  262.  * v4s    
  263.  *     Adds a 4D point to our fake point buffer
  264.  */
  265. void
  266. v4s(vec)
  267.     short    vec[4];
  268. {
  269.     float    v[4];
  270.  
  271.     v[0] = vec[0];
  272.     v[1] = vec[1];
  273.     v[2] = vec[2];
  274.     v[3] = vec[3];
  275.  
  276.     vcall(v, 4);
  277. }
  278.  
  279. /*
  280.  * v3s    
  281.  *     Adds a 3D point to our fake point buffer
  282.  */
  283. void
  284. v3s(vec)
  285.     short    vec[3];
  286. {
  287.     float    v[3];
  288.  
  289.     v[0] = vec[0];
  290.     v[1] = vec[1];
  291.     v[2] = vec[2];
  292.  
  293.     vcall(v, 3);
  294. }
  295.  
  296. /*
  297.  * v2s    
  298.  *     Adds a 2D point to our fake point buffer
  299.  */
  300. void
  301. v2s(vec)
  302.     short    vec[2];
  303. {
  304.     float    v[2];
  305.  
  306.     v[0] = vec[0];
  307.     v[1] = vec[1];
  308.  
  309.     vcall(v, 2);
  310. }
  311.