home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / spline-patch.tar.gz / spline-patch.tar / patch / demos / demo0.c next >
C/C++ Source or Header  |  1991-11-18  |  8KB  |  300 lines
  1. /*
  2.  *   testpatch.c:
  3.  *
  4.  *     draws three surface patches:  RED   == Bezier
  5.  *                                   BLUE  == B-Spline
  6.  *                                   GREEN == Cardinal
  7.  */
  8.  
  9. #include "gl.h"
  10. #include "device.h"
  11. #include "math.h"
  12. #include "stdio.h"
  13. #include "patch.h"                  /* My stuff */
  14.  
  15. Matrix beziermatrix = { { -1,  3, -3, 1 },
  16.                         {  3, -6,  3, 0 },
  17.                         { -3,  3,  0, 0 },
  18.                         {  1,  0,  0, 0 } };        
  19.  
  20. Matrix cardinalmatrix = { { -0.5,  1.5, -1.5,  0.5 },
  21.                           {  1.0, -2.5,  2.0, -0.5 },
  22.                           { -0.5,  0.0,  0.5,  0.0 },
  23.                           {  0.0,  1.0,  0.0,  0.0 } };        
  24.  
  25. Matrix bsplinematrix = { { -1.0/6.0,  3.0/6.0, -3.0/6.0, 1.0/6.0 },
  26.                          {  3.0/6.0, -6.0/6.0,  3.0/6.0,     0.0 },
  27.                          { -3.0/6.0,      0.0,  3.0/6.0,     0.0 },
  28.                          {  1.0/6.0,  4.0/6.0,  1.0/6.0,     0.0 } };        
  29.  
  30. #define BEZIER 1
  31. #define CARDINAL 2
  32. #define BSPLINE 3
  33.  
  34. #define DIV 8
  35.  
  36. Coord geomx[4][4] = { {   0.0,   0.0,   0.0,   0.0},
  37.                       {   0.0, 100.0, 100.0,   0.0},
  38.                       { 300.0, 200.0, 200.0, 300.0},
  39.                       { 300.0, 300.0, 300.0, 300.0} };        
  40.  
  41. Coord geomy[4][4] = { { 200.0,   0.0, 200.0, 200.0},
  42.                       {   0.0,   0.0, 200.0,   0.0},
  43.                       {   0.0,   0.0, 200.0,   0.0},
  44.                       { 200.0,   0.0, 200.0, 200.0} };        
  45.  
  46. Coord geomz[4][4] = { { 100.0, 200.0, 300.0, 400.0 },
  47.                       { 100.0, 200.0, 300.0, 400.0 },
  48.                       { 100.0, 200.0, 300.0, 400.0 },
  49.                       { 100.0, 200.0, 300.0, 400.0 } };        
  50.  
  51.  
  52. Coord geomxt[4][4] = { {   0.0,   0.0, 200.0, 200.0 },
  53.                    {   0.0,   0.0, 200.0, 200.0 },
  54.                    {  50.0,  50.0, 150.0, 150.0 },
  55.                    {  50.0,  50.0, 150.0, 150.0 } };
  56.  
  57. Coord geomyt[4][4] = { { 200.0, 400.0, 400.0, 200.0},
  58.                    { 200.0, 400.0, 400.0, 200.0},
  59.                    { 200.0, 350.0, 350.0, 200.0},
  60.                    { 200.0, 350.0, 350.0, 200.0} };
  61.  
  62. Coord geomzt[4][4] = { { 200.0, 200.0, 200.0, 200.0 },
  63.                    { 150.0, 150.0, 150.0, 150.0 },
  64.                    { 150.0, 150.0, 150.0, 150.0 },
  65.                    { 200.0, 200.0, 200.0, 200.0 } };
  66.  
  67.  
  68. PatchPtr mypatch[3];
  69.  
  70. /*******************************************************************/
  71.  
  72. main(argc, argv)
  73. int argc; char *argv[];
  74. {
  75.     Device dev;
  76.     short val;
  77.  
  78.     initialize();
  79.  
  80.     while (TRUE) {
  81.  
  82.         if (qtest()) {
  83.        
  84.             dev = qread(&val);
  85.  
  86.             if (dev == ESCKEY) {
  87.                 gexit();
  88.                 exit();
  89.             } else if (dev == REDRAW) {
  90.                 reshapeviewport();
  91.                 drawpatches(argc);
  92.             }
  93.         }
  94.     }
  95. }
  96.  
  97. /*******************************************************************/
  98.  
  99. initialize(which)
  100. int which;
  101. {
  102.     int gid;
  103.  
  104.     prefposition(XMAXSCREEN/4,XMAXSCREEN*3/4,YMAXSCREEN/4,YMAXSCREEN*3/4);
  105.     gid = winopen("patch1");
  106.     winset(gid);
  107.     winattach();
  108.     winconstraints();
  109.  
  110.     qdevice(ESCKEY);
  111.     qdevice(REDRAW);
  112.     qenter(REDRAW,gid);
  113.     perspective(900, 1.0, 1.0, 10000.0 );
  114.     if (which == 1)
  115.        lookat(400.0, 400.0, 0.0, 200.0, 200.0, 250.0,0); 
  116.     else
  117.        lookat(100.0, 300.0, -100.0, 200.0, 200.0, 250.0,0); 
  118.     mypatch[0] = NewPatch();
  119.     mypatch[1] = NewPatch();
  120.     mypatch[2] = NewPatch();
  121.     if (which == 1) {
  122.        DefPatch(mypatch[0], beziermatrix, geomx, geomy, geomz,DIV);
  123.        DefPatch(mypatch[1], cardinalmatrix, geomx, geomy, geomz,DIV);
  124.        DefPatch(mypatch[2], bsplinematrix, geomx, geomy, geomz,DIV);
  125.     } else {
  126.        DefPatch(mypatch[0], beziermatrix, geomxt, geomyt, geomzt,DIV);
  127.        DefPatch(mypatch[1], cardinalmatrix, geomxt, geomyt, geomzt,DIV);
  128.        DefPatch(mypatch[2], bsplinematrix, geomxt, geomyt, geomzt,DIV);
  129.     }
  130. }
  131.  
  132. /*******************************************************************/
  133.  
  134. drawpatches()
  135. {
  136.    int i,j;
  137.    float vert[3];
  138.  
  139.    for (i = 0; i < 3; i++) {
  140.       color(BLACK);
  141.       clear();
  142.       drawaxes();
  143.       color(RED);
  144.       drawpatch(mypatch[i]);
  145.    color(WHITE);
  146.    drawhull(mypatch[i]);
  147.       color(GREEN);
  148.       sleep(10);
  149.    }
  150.  
  151.  
  152. }
  153.  
  154. /***************************************************************************/
  155.  
  156. drawaxes()
  157. {
  158.    float vert[3];
  159.  
  160.    color(RED);
  161.    bgnline(); vert[0]=0 ; vert[1]=0; vert[2]=0; v3f(vert);
  162.               vert[0]=20; vert[1]=0; vert[2]=0; v3f(vert); endline();
  163.    color(GREEN);
  164.    bgnline(); vert[0]=0; vert[1]=0 ; vert[2]=0; v3f(vert);
  165.               vert[0]=0; vert[1]=20; vert[2]=0; v3f(vert); endline();
  166.    color(BLUE);
  167.    bgnline(); vert[0]=0; vert[1]=0; vert[2]=0 ; v3f(vert);
  168.               vert[0]=0; vert[1]=0; vert[2]=20; v3f(vert); endline();
  169. }
  170.  
  171. /***************************************************************************/
  172.  
  173. drawhull(p)
  174. PatchPtr p;
  175. {
  176.    int i, j;
  177.    float vert[3];
  178.    
  179.    for (i = 0; i < 4; i++) {
  180.         bgnline();
  181.     for (j = 0; j <4; j++) {
  182.       vert[0] = p->geomx[j][i];
  183.       vert[1] = p->geomy[j][i];
  184.       vert[2] = p->geomz[j][i];
  185.       v3f(vert);
  186.     }
  187.     endline();
  188.    }    
  189.    for (i = 0; i < 4; i++) {
  190.         bgnline();
  191.     for (j = 0; j <4; j++) {
  192.       vert[0] = p->geomx[i][j];
  193.       vert[1] = p->geomy[i][j];
  194.       vert[2] = p->geomz[i][j];
  195.       v3f(vert);
  196.     }
  197.     endline();
  198.    }
  199. }
  200.  
  201. /***************************************************************************/
  202.  
  203. drawpatch(p)
  204. PatchPtr p;
  205. {
  206.    float U[1][4], V[4][1];              /* u, v vectors */
  207.    float C[4][4];                       /* solution matrix (only [0][0] used) */
  208.    float M2x[4][4], M2y[4][4], M2z[4][4]; /* Intermediate results */
  209.    float u, v;                     /* Parameters */
  210.    float M2xdu[4][4], M2xdv[4][4]; /* Intermed. results for surface normals */
  211.    float M2ydu[4][4], M2ydv[4][4];
  212.    float M2zdu[4][4], M2zdv[4][4];
  213.    VECTOR ddu, ddv, norm;
  214.  
  215.    float vert[3], vert2[3];         /* Screen vertices */
  216.  
  217.    for (v = 0; v <= 1.0; v += 0.2) {
  218.       V[3][0] = 1;
  219.       V[2][0] = v;
  220.       V[1][0] = v * v;
  221.       V[0][0] = V[1][0] * v;
  222.       mmult4x4_4x1 (M2x, p->Mx, V);  /* Calculate intermediate results with v */
  223.       mmult4x4_4x1 (M2y, p->My, V);
  224.       mmult4x4_4x1 (M2z, p->Mz, V);
  225.  
  226.       mmult4x4_4x1 (M2xdu, p->Mxdu, V);
  227.       mmult4x4_4x1 (M2ydu, p->Mydu, V);
  228.       mmult4x4_4x1 (M2zdu, p->Mzdu, V);
  229.       
  230.       mmult4x4_4x1 (M2xdv, p->Mxdv, V);
  231.       mmult4x4_4x1 (M2ydv, p->Mydv, V);
  232.       mmult4x4_4x1 (M2zdv, p->Mzdv, V);
  233.       bgnline();
  234.       for (u = 0; u <= 1.0; u += 0.02) {
  235.         U[0][3] = 1;
  236.         U[0][2] = u;
  237.         U[0][1] = u * u;
  238.         U[0][0] = U[0][1] * u;
  239.         mmult1x4_4x1 (C, U, M2x);
  240.         vert[0] = C[0][0];
  241.         mmult1x4_4x1 (C, U, M2y);
  242.         vert[1] = C[0][0];
  243.         mmult1x4_4x1 (C, U, M2z);
  244.         vert[2] = C[0][0];
  245.         v3f(vert);     
  246.         if (fcmp(u,0.0) || fcmp(u, 0.2) || fcmp(u,0.4) || fcmp(u, 0.6) || 
  247.            fcmp(u, 0.8) || fcmp(u,1.0)) {
  248.            mmult1x4_4x1 (C, U, M2xdu);
  249.            ddu.x = C[0][0];
  250.            mmult1x4_4x1 (C, U, M2ydu);
  251.            ddu.y = C[0][0];
  252.            mmult1x4_4x1 (C, U, M2zdu);
  253.            ddu.z = C[0][0];
  254.            mmult1x4_4x1 (C, V, M2xdv);
  255.            ddv.x = C[0][0];
  256.            mmult1x4_4x1 (C, V, M2ydv);
  257.            ddv.y = C[0][0];
  258.            mmult1x4_4x1 (C, V, M2zdv);
  259.            ddv.z = C[0][0];
  260.            cross_product(&norm, ddu, ddv);
  261.            normalize(&norm); 
  262.            vert2[0] = vert[0] + 20.0 * norm.x;
  263.            vert2[1] = vert[1] + 20.0 * norm.y;
  264.            vert2[2] = vert[2] + 20.0 * norm.z;
  265.            v3f(vert2);
  266.            v3f(vert);
  267.  
  268.         } 
  269.       }
  270.       endline();
  271.    }
  272.  
  273.    for (u = 0; u <= 1.0; u += 0.2) {
  274.       U[0][3] = 1;
  275.       U[0][2] = u;
  276.       U[0][1] = u * u;
  277.       U[0][0] = U[0][1] * u;
  278.       mmult1x4_4x4 (M2x, U, p->Mx);
  279.       mmult1x4_4x4 (M2y, U, p->My);
  280.       mmult1x4_4x4 (M2z, U, p->Mz);
  281.       bgnline();
  282.       for (v = 0; v <= 1.0; v += 0.02) {
  283.         V[3][0] = 1;
  284.         V[2][0] = v;
  285.         V[1][0] = v * v;
  286.         V[0][0] = V[1][0] * v;
  287.         mmult1x4_4x1 (C, M2x, V);
  288.         vert[0] = C[0][0];
  289.         mmult1x4_4x1 (C, M2y, V);
  290.         vert[1] = C[0][0];
  291.         mmult1x4_4x1 (C, M2z, V);
  292.         vert[2] = C[0][0];
  293.         v3f(vert);      
  294.       }
  295.       endline();
  296.    }
  297. }
  298.  
  299. /***************************************************************************/
  300.