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