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;              /* TRUE means edge has an S* intersection */
18. Node    EdgeIntersection;                   /* where cube edge intersection occured */
19.
20. int     FoundEdgeConnection;            /* 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[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;       /* 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. }