C   64

Process Cube

Guest on 20th June 2022 06:10:33 AM

  1. struct node
  2. {
  3.         float x, y, z;          /* location                             */
  4.         float nx, ny, nz;       /* surface normals                      */
  5.         float s;                /* scalar value                         */
  6. };
  7.  
  8. typedef struct node Node;
  9.  
  10.  
  11.  
  12. void    ProcessCube( Node *, Node *, Node *, Node *, Node *, Node *, Node *, Node * );
  13. int     ProcessCubeEdge( Node *, Node *, int );
  14. void    ProcessCubeQuad( Node *, Node *, Node *, Node *, int, int, int, int );
  15. void    DrawCubeTriangles();
  16.  
  17. int     FoundEdgeIntersection[12];              /* TRUE means edge has an S* intersection */
  18. Node    EdgeIntersection[12];                   /* where cube edge intersection occured */
  19.  
  20. int     FoundEdgeConnection[12][12];            /* TRUE means edges are connected       */
  21.  
  22.  
  23.  
  24. . . .
  25.  
  26.         /* compute the normals:                                         */
  27.  
  28.         for( i=0; i <= NSTEPS; i++ )
  29.         {
  30.                 for( j=0; j <= NSTEPS; j++ )
  31.                 {
  32.                         for( k=0; k <= NSTEPS; k++ )
  33.                         {
  34.                                 np = &Nodes[i][j][k];
  35.  
  36.                                 if( i == 0 )
  37.                                         np->nx = ( Nodes[1][j][k].s - np->s ) / DX;
  38.                                 else
  39.                                         if( i == NSTEPS )
  40.                                                 np->nx = ( np->s - Nodes[NSTEPS-1][j][k].s ) / DX;
  41.                                         else
  42.                                                 np->nx = ( Nodes[i+1][j][k].s - Nodes[i-1][j][k].s ) / ( 2.*DX );
  43.  
  44.                                 ?????
  45.  
  46.                                 Unitize( &np->nx );
  47.                         }
  48.                 }
  49.         }
  50.  
  51.  
  52.  
  53.         . . .
  54.  
  55.  
  56.  
  57. void
  58. ProcessCube(    Node *p0, Node *p1, Node *p2, Node *p3,
  59.                 Node *p4, Node *p5, Node *p6, Node *p7 )
  60. {
  61.         int i;          /* counter                              */
  62.         int n;          /* # edges intersected in this cube     */
  63.  
  64.  
  65.         /* set all edge intersections to "no intersection":     */
  66.  
  67.         for( i = 0; i < 12; i++ )
  68.                 FoundEdgeIntersection[i] = FALSE;
  69.  
  70.  
  71.         /* produce all edge intersections and count them up:    */
  72.  
  73.         n = 0;
  74.         n += ProcessCubeEdge( p0, p1,  0 );
  75.         n += ProcessCubeEdge( p1, p2,  1 );
  76.         n += ProcessCubeEdge( p2, p3,  2 );
  77.         n += ProcessCubeEdge( p3, p0,  3 );
  78.         n += ProcessCubeEdge( p4, p5,  4 );
  79.         n += ProcessCubeEdge( p5, p6,  5 );
  80.         n += ProcessCubeEdge( p6, p7,  6 );
  81.         n += ProcessCubeEdge( p7, p4,  7 );
  82.         n += ProcessCubeEdge( p0, p4,  8 );
  83.         n += ProcessCubeEdge( p1, p5,  9 );
  84.         n += ProcessCubeEdge( p2, p6, 10 );
  85.         n += ProcessCubeEdge( p3, p7, 11 );
  86.  
  87.  
  88.         /* get out if found no intersections:                   */
  89.  
  90.         if( n == 0 )
  91.                 return;
  92.  
  93.  
  94.         /* process each quad's intersections into edges:        */
  95.  
  96.         ProcessCubeQuad( p0, p3, p7, p4,  3, 11,  7,  8 );
  97.         ProcessCubeQuad( p1, p2, p6, p5,  1, 10,  5,  9 );
  98.  
  99.         ProcessCubeQuad( p0, p1, p5, p4,  0,  9,  4,  8 );
  100.         ProcessCubeQuad( p2, p3, p7, p6,  2, 11,  6, 10 );
  101.  
  102.         ProcessCubeQuad( p0, p1, p2, p3,  0,  1,  2,  3 );
  103.         ProcessCubeQuad( p4, p5, p6, p7,  4,  5,  6,  7 );
  104.  
  105.  
  106.         /* process the cube's edges into triangles:             */
  107.  
  108.         DrawCubeTriangles();
  109. }
  110.  
  111.  
  112.  
  113.  
  114. int
  115. ProcessCubeEdge( Node *pa, Node *pb, int edge )
  116. {
  117.         float num, den, tstar;          /* parametric intersection      */
  118.  
  119.         ?????
  120.  
  121.  
  122.         EdgeIntersection[edge].x  = pa->x   +  tstar * ( pb->x -  pa->x  );
  123.         EdgeIntersection[edge].y  = pa->y   +  tstar * ( pb->y -  pa->y  );
  124.         EdgeIntersection[edge].z  = pa->z   +  tstar * ( pb->z -  pa->z  );
  125.         EdgeIntersection[edge].nx = pa->nx  +  tstar * ( pb->nx - pa->nx );
  126.         EdgeIntersection[edge].ny = pa->ny  +  tstar * ( pb->ny - pa->ny );
  127.         EdgeIntersection[edge].nz = pa->nz  +  tstar * ( pb->nz - pa->nz );
  128.         Unitize( &EdgeIntersection[edge].nx );
  129.  
  130.         return 1;
  131. }
  132.  
  133.  
  134.  
  135. void
  136. ProcessCubeQuad(        Node *pa, Node *pb, Node *pc, Node *pd,
  137.                         int eab, int ebc, int ecd, int eda )
  138. {
  139.         int n;          /* # of intersections                   */
  140.         int nfound;     /* how many intersections found so far  */
  141.         int e[4];       /* found intersections                  */
  142.         float smid;     /* s at the quad midpoint               */
  143.  
  144.  
  145.         /* count the number of intersections in this quad:      */
  146.  
  147.         nfound = 0;
  148.  
  149.         if( FoundEdgeIntersection[eab] )
  150.         {
  151.                 e[nfound] = eab;
  152.                 nfound++;
  153.         }
  154.  
  155.         if( FoundEdgeIntersection[ebc] )
  156.         {
  157.                 e[nfound] = ebc;
  158.                 nfound++;
  159.         }
  160.  
  161.         if( FoundEdgeIntersection[ecd] )
  162.         {
  163.                 e[nfound] = ecd;
  164.                 nfound++;
  165.         }
  166.  
  167.         if( FoundEdgeIntersection[eda] )
  168.         {
  169.                 e[nfound] = eda;
  170.                 nfound++;
  171.         }
  172.  
  173.  
  174.  
  175.         /* nfound is the number of intersections in this quad:  */
  176.  
  177.         switch( nfound )
  178.         {
  179.                 case 0:
  180.                         return;
  181.  
  182.                 case 1:
  183.                 case 3:
  184.                         fprintf( stderr, "ProcessCubeQuad found %d intersections\n", n );
  185.                         return;
  186.  
  187.                 case 2:
  188.                         ?????
  189.                         break;
  190.  
  191.                 case 4:
  192.                         ?????
  193.                         return;
  194.         }
  195. }
  196.  
  197.  
  198.  
  199. void
  200. DrawCubeTriangles()
  201. {
  202.         int found;              /* TRUE means found an edge pair to start with */
  203.         int ea, eb, ec;         /* 3 edges of the triangle      */
  204.  
  205.  
  206.         /* loop until all edges have been used up:              */
  207.  
  208.         for( ; ; )
  209.         {
  210.                 found = FALSE;
  211.                 for( ea = 0; ea < 12; ea++ )
  212.                 {
  213.                         for( eb = 0; eb < 12; eb++ )
  214.                         {
  215.                                 if( FoundEdgeConnection[ea][eb] == TRUE )
  216.                                 {
  217.                                         found = TRUE;
  218.                                         break;
  219.                                 }
  220.                         }
  221.  
  222.                         if( found == TRUE )
  223.                                 break;          /* short cut out        */
  224.                 }
  225.  
  226.  
  227.                 /* if found nothing, then all connections have been used:*/
  228.  
  229.                 if( found == FALSE )
  230.                         break;
  231.  
  232.  
  233.                 /* have a connection from edge #ea to edge #eb:         */
  234.                 /* find an edge #ec connected to edge #eb:              */
  235.  
  236.                 for( ec = 0; ec < 12; ec++ )
  237.                 {
  238.                         if( ec == ea )
  239.                                 continue;
  240.  
  241.                         if( FoundEdgeConnection[eb][ec] == TRUE )
  242.                                 break;
  243.                 }
  244.  
  245.  
  246.                 /* if didn't find a third edge, something is wrong:     */
  247.  
  248.                 if( ec >= 12 )
  249.                 {
  250.                         fprintf( stderr, "Could not find a 3rd edge in DrawCubeTriangles()\n" );
  251.                         return;
  252.                 }
  253.  
  254.  
  255.                 /* draw the triangle from ea to eb to ec:               */
  256.  
  257.                 ?????
  258.  
  259.  
  260.                 /* don't need connections between ea-eb and eb-ec anymore: */
  261.  
  262.                 FoundEdgeConnection[ea][eb] = FALSE;
  263.                 FoundEdgeConnection[eb][ea] = FALSE;
  264.  
  265.                 FoundEdgeConnection[eb][ec] = FALSE;
  266.                 FoundEdgeConnection[ec][eb] = FALSE;
  267.  
  268.  
  269.                 /* *toggle* connection between ec and ea:               */
  270.                 /* if it was there before, we don't need it anymore:    */
  271.                 /* if it was not there, we have just invented it,       */
  272.                 /*      and will need it again:                         */
  273.  
  274.                 FoundEdgeConnection[ec][ea] = ! FoundEdgeConnection[ec][ea];
  275.                 FoundEdgeConnection[ea][ec] = ! FoundEdgeConnection[ea][ec];
  276.         }
  277. }

Raw Paste


Login or Register to edit or fork this paste. It's free.