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