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 / demo1.c < prev    next >
C/C++ Source or Header  |  1991-11-18  |  9KB  |  335 lines
  1. /*
  2.  *   demo1.c:
  3.  *
  4.  *     draws three surface patches:  RED   == Bezier
  5.  *                                   BLUE  == B-Spline
  6.  *                                   GREEN == Cardinal
  7.  *
  8.  * Copyright (c) 1990, by Sean Graves and Texas A&M University
  9.  *
  10.  * Permission is hereby granted for non-commercial reproduction and use of
  11.  * this program, provided that this notice is included in any material copied
  12.  * from it. The author assumes no responsibility for damages resulting from
  13.  * the use of this software, however caused.
  14.  *
  15.  */
  16.  
  17. #include "gl.h"
  18. #include "device.h"
  19. #include "math.h"
  20. #include "stdio.h"
  21. #include "patch.h"                  /* My stuff */
  22.  
  23. MATRIX beziermatrix = { { -1,  3, -3, 1 },
  24.                         {  3, -6,  3, 0 },
  25.                         { -3,  3,  0, 0 },
  26.                         {  1,  0,  0, 0 } };        
  27.  
  28. MATRIX cardinalmatrix = { { -0.5,  1.5, -1.5,  0.5 },
  29.                           {  1.0, -2.5,  2.0, -0.5 },
  30.                           { -0.5,  0.0,  0.5,  0.0 },
  31.                           {  0.0,  1.0,  0.0,  0.0 } };        
  32.  
  33. MATRIX bsplinematrix = { { -1.0/6.0,  3.0/6.0, -3.0/6.0, 1.0/6.0 },
  34.                          {  3.0/6.0, -6.0/6.0,  3.0/6.0,     0.0 },
  35.                          { -3.0/6.0,      0.0,  3.0/6.0,     0.0 },
  36.                          {  1.0/6.0,  4.0/6.0,  1.0/6.0,     0.0 } };        
  37.  
  38. #define BEZIER 1
  39. #define CARDINAL 2
  40. #define BSPLINE 3
  41.  
  42. #define DIV 8
  43.  
  44. MATRIX geomx = { {   0.0,   0.0,   0.0,   0.0},
  45.                  {   0.0, 100.0, 100.0,   0.0},
  46.                  { 300.0, 200.0, 200.0, 300.0},
  47.                  { 300.0, 300.0, 300.0, 300.0} };        
  48.  
  49. MATRIX geomy = { { 200.0,   0.0, 200.0, 200.0},
  50.                  {   0.0,   0.0, 200.0,   0.0},
  51.                  {   0.0,   0.0, 200.0,   0.0},
  52.                  { 200.0,   0.0, 200.0, 200.0} };        
  53.  
  54. MATRIX geomz = { { 100.0, 200.0, 300.0, 400.0 },
  55.                  { 100.0, 200.0, 300.0, 400.0 },
  56.                  { 100.0, 200.0, 300.0, 400.0 },
  57.                  { 100.0, 200.0, 300.0, 400.0 } };        
  58.  
  59.  
  60. PatchPtr mypatch[3];
  61. ListPtr insert_node();
  62.  
  63. /*******************************************************************/
  64.  
  65. main()
  66. {
  67.     Device dev;
  68.     short val;
  69.  
  70.     initialize();
  71.  
  72.     while (TRUE) {
  73.  
  74.         if (qtest()) {
  75.        
  76.             dev = qread(&val);
  77.  
  78.             if (dev == ESCKEY) {
  79.                 gexit();
  80.                 exit();
  81.             } else if (dev == REDRAW) {
  82.                 reshapeviewport();
  83.                 drawpatches();
  84.             }
  85.         }
  86.     }
  87. }
  88.  
  89. /*******************************************************************/
  90.  
  91. initialize()
  92. {
  93.     int gid;
  94.  
  95.     
  96. prefposition(XMAXSCREEN/4,XMAXSCREEN*3/4,YMAXSCREEN/4,YMAXSCREEN*3/4);
  97.     gid = winopen("testpatch");
  98.     winset(gid);
  99.     winattach();
  100.     winconstraints();
  101.  
  102.     qdevice(ESCKEY);
  103.     qdevice(REDRAW);
  104.     qenter(REDRAW,gid);
  105.     perspective(900, 1.0, 1.0, 10000.0 );
  106.     lookat(400.0, 400.0, 0.0, 200.0, 200.0, 250.0,0); 
  107.     mypatch[0] = NewPatch();
  108.     DefPatch(mypatch[0], beziermatrix, geomx, geomy, geomz, DIV);
  109.     mypatch[1] = NewPatch();
  110.     DefPatch(mypatch[1], cardinalmatrix, geomx, geomy, geomz, DIV);
  111.     mypatch[2] = NewPatch();
  112.     DefPatch(mypatch[2], bsplinematrix, geomx, geomy, geomz, DIV);
  113.     srand48(123);
  114. }
  115.  
  116. /*******************************************************************/
  117.  
  118. drawpatches()
  119. {
  120.    TreePtr tree;
  121.    int i,j;
  122.    float vert[3], mag;
  123.    RAY r;
  124.  
  125.    for (i = 0; i < 3; i++) { 
  126.       color(BLACK);
  127.       clear();
  128.       drawaxes();
  129.       color(RED);
  130.       drawpatch(mypatch[i]);
  131.  
  132.       color(GREEN);
  133.       drawboxes(mypatch[i]->tree);
  134.       sleep(1);
  135.   }
  136. }
  137.  
  138. /***************************************************************************/
  139.  
  140. drawaxes()
  141. {
  142.    float vert[3];
  143.  
  144.    color(RED);
  145.    bgnline(); vert[0]=0 ; vert[1]=0; vert[2]=0; v3f(vert);
  146.               vert[0]=20; vert[1]=0; vert[2]=0; v3f(vert); endline();
  147.    color(GREEN);
  148.    bgnline(); vert[0]=0; vert[1]=0 ; vert[2]=0; v3f(vert);
  149.               vert[0]=0; vert[1]=20; vert[2]=0; v3f(vert); endline();
  150.    color(BLUE);
  151.    bgnline(); vert[0]=0; vert[1]=0; vert[2]=0 ; v3f(vert);
  152.               vert[0]=0; vert[1]=0; vert[2]=20; v3f(vert); endline();
  153. }
  154.  
  155. /***************************************************************************/
  156.  
  157. drawhull(p)
  158. PatchPtr p;
  159. {
  160.    int i, j;
  161.    float vert[3];
  162.    
  163.    for (i = 0; i < 4; i++) {
  164.         bgnline();
  165.     for (j = 0; j <4; j++) {
  166.       vert[0] = p->geomx[j][i];
  167.       vert[1] = p->geomy[j][i];
  168.       vert[2] = p->geomz[j][i];
  169.       v3f(vert);
  170.     }
  171.     endline();
  172.    }    
  173.    for (i = 0; i < 4; i++) {
  174.         bgnline();
  175.     for (j = 0; j <4; j++) {
  176.       vert[0] = p->geomx[i][j];
  177.       vert[1] = p->geomy[i][j];
  178.       vert[2] = p->geomz[i][j];
  179.       v3f(vert);
  180.     }
  181.     endline();
  182.    }
  183. }
  184.  
  185. /**********************************************************************/
  186.  
  187. drawpatch(p)
  188. PatchPtr p;
  189. {
  190.    float U[1][4], V[4][1];              /* u, v vectors */
  191.    float C[4][4];                       /* solution matrix (only [0][0] used) */
  192.    float M2x[4][4], M2y[4][4], M2z[4][4]; /* Intermediate results */
  193.    float u, v;                     /* Parameters */
  194.    float M2xdu[4][4], M2xdv[4][4]; /* Intermed. results for surface normals */
  195.    float M2ydu[4][4], M2ydv[4][4];
  196.    float M2zdu[4][4], M2zdv[4][4];
  197.    VECTOR ddu, ddv, norm;
  198.  
  199.    float vert[3], vert2[3];                  /* Screen vertices */
  200.  
  201.    for (v = 0; v <= 1.0; v += 0.2) {
  202.       V[3][0] = 1;
  203.       V[2][0] = v;
  204.       V[1][0] = v * v;
  205.       V[0][0] = V[1][0] * v;
  206.       mmult4x4_4x1 (M2x, p->Mx, V);  /* Calculate intermediate results with v */
  207.       mmult4x4_4x1 (M2y, p->My, V);
  208.       mmult4x4_4x1 (M2z, p->Mz, V);
  209.  
  210.       mmult4x4_4x1 (M2xdu, p->Mxdu, V);
  211.       mmult4x4_4x1 (M2ydu, p->Mydu, V);
  212.       mmult4x4_4x1 (M2zdu, p->Mzdu, V);
  213.       
  214.       mmult4x4_4x1 (M2xdv, p->Mxdv, V);
  215.       mmult4x4_4x1 (M2ydv, p->Mydv, V);
  216.       mmult4x4_4x1 (M2zdv, p->Mzdv, V);
  217.       bgnline();
  218.       for (u = 0; u <= 1.0; u += 0.02) {
  219.         U[0][3] = 1;
  220.         U[0][2] = u;
  221.         U[0][1] = u * u;
  222.         U[0][0] = U[0][1] * u;
  223.         mmult1x4_4x1 (C, U, M2x);
  224.         vert[0] = C[0][0];
  225.         mmult1x4_4x1 (C, U, M2y);
  226.         vert[1] = C[0][0];
  227.         mmult1x4_4x1 (C, U, M2z);
  228.         vert[2] = C[0][0];
  229.         v3f(vert);     
  230.         if (fcmp(u,0.0) || fcmp(u, 0.2) || fcmp(u,0.4) || fcmp(u, 0.6) || 
  231.            fcmp(u, 0.8) || fcmp(u,1.0)) {
  232.            mmult1x4_4x1 (C, U, M2xdu);
  233.            ddu.x = C[0][0];
  234.            mmult1x4_4x1 (C, U, M2ydu);
  235.            ddu.y = C[0][0];
  236.            mmult1x4_4x1 (C, U, M2zdu);
  237.            ddu.z = C[0][0];
  238.            mmult1x4_4x1 (C, V, M2xdv);
  239.            ddv.x = C[0][0];
  240.            mmult1x4_4x1 (C, V, M2ydv);
  241.            ddv.y = C[0][0];
  242.            mmult1x4_4x1 (C, V, M2zdv);
  243.            ddv.z = C[0][0];
  244.            cross_product(&norm, ddu, ddv);
  245.            normalize(&norm); 
  246.            vert2[0] = vert[0] + 20.0 * norm.x;
  247.            vert2[1] = vert[1] + 20.0 * norm.y;
  248.            vert2[2] = vert[2] + 20.0 * norm.z;
  249.            v3f(vert2);
  250.            v3f(vert);      
  251.         } 
  252.       }
  253.       endline();
  254.    }
  255.  
  256.    for (u = 0; u <= 1.0; u += 0.2) {
  257.       U[0][3] = 1;
  258.       U[0][2] = u;
  259.       U[0][1] = u * u;
  260.       U[0][0] = U[0][1] * u;
  261.       mmult1x4_4x4 (M2x, U, p->Mx);
  262.       mmult1x4_4x4 (M2y, U, p->My);
  263.       mmult1x4_4x4 (M2z, U, p->Mz);
  264.       bgnline();
  265.       for (v = 0; v <= 1.0; v += 0.02) {
  266.         V[3][0] = 1;
  267.         V[2][0] = v;
  268.         V[1][0] = v * v;
  269.         V[0][0] = V[1][0] * v;
  270.         mmult1x4_4x1 (C, M2x, V);
  271.         vert[0] = C[0][0];
  272.         mmult1x4_4x1 (C, M2y, V);
  273.         vert[1] = C[0][0];
  274.         mmult1x4_4x1 (C, M2z, V);
  275.         vert[2] = C[0][0];
  276.         v3f(vert);      
  277.       }
  278.       endline();
  279.    }
  280. }
  281.  
  282. /*********************************************************************** ****/
  283.  
  284. drawbox(min, max)
  285. POINT min, max;
  286. {
  287.    float vert[8][3];
  288.  
  289.    bgnline();
  290.    vert[0][0] = min.x; vert[0][1] = min.y; vert[0][2] = min.z;
  291.    vert[1][0] = max.x; vert[1][1] = min.y; vert[1][2] = min.z;
  292.    vert[2][0] = max.x; vert[2][1] = max.y; vert[2][2] = min.z;
  293.    vert[3][0] = min.x; vert[3][1] = max.y; vert[3][2] = min.z;
  294.    vert[4][0] = min.x; vert[4][1] = min.y; vert[4][2] = max.z;
  295.    vert[5][0] = max.x; vert[5][1] = min.y; vert[5][2] = max.z;
  296.    vert[6][0] = max.x; vert[6][1] = max.y; vert[6][2] = max.z;
  297.    vert[7][0] = min.x; vert[7][1] = max.y; vert[7][2] = max.z;
  298.  
  299.    v3f(vert[0]);
  300.    v3f(vert[1]);
  301.    v3f(vert[2]);
  302.    v3f(vert[3]);
  303.    v3f(vert[0]);
  304.    v3f(vert[3]);
  305.    v3f(vert[7]);
  306.    v3f(vert[4]);
  307.    v3f(vert[0]);
  308.    v3f(vert[4]);
  309.    v3f(vert[5]);
  310.    v3f(vert[6]);
  311.    v3f(vert[7]);
  312.    v3f(vert[6]);
  313.    v3f(vert[2]);
  314.    v3f(vert[1]);
  315.    v3f(vert[5]);
  316.    endline();
  317. }
  318.    
  319. /*****************************************************************/
  320.  
  321. drawboxes(tree)
  322. TreePtr tree;
  323. {
  324.    int i;
  325.    Isectrec irec;
  326.  
  327.    if (tree->child[0]) {
  328.       for (i = 0; i < 4; i++)
  329.          drawboxes(tree->child[i]);
  330.    } else {
  331.       drawbox(tree->box_min, tree->box_max); 
  332.       sleep(1);
  333.    }
  334. }
  335.