GteMarchingCubes.cpp
Go to the documentation of this file.
1 // David Eberly, Geometric Tools, Redmond WA 98052
2 // Copyright (c) 1998-2017
3 // Distributed under the Boost Software License, Version 1.0.
4 // http://www.boost.org/LICENSE_1_0.txt
5 // http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
6 // File Version: 3.0.0 (2016/06/19)
7 
8 #include <GTEnginePCH.h>
9 #include <LowLevel/GteWrapper.h>
10 #include <Imagics/GteMarchingCubes.h>
11 #include <algorithm>
12 using namespace gte;
13 
14 MarchingCubes::~MarchingCubes()
15 {
16 }
17 
18 MarchingCubes::MarchingCubes()
19 {
20  // Create the lookup table.
21  for (mEntry = 0; mEntry < 256; ++mEntry)
22  {
23  (this->*msConfiguration[mEntry].F)(msConfiguration[mEntry].index);
24  }
25 }
26 
27 std::string MarchingCubes::GetConfigurationType(int entry)
28 {
29  if (0 <= entry && entry < 256)
30  {
31  return msConfigurationString[msConfiguration[entry].type];
32  }
33  return "";
34 }
35 
36 void MarchingCubes::SetTable(int numV, int const* vpair, int numT, int const* itriple)
37 {
38  // The item is already zeroed in the constructor.
39  Topology& topology = mTable[mEntry];
40  topology.numVertices = numV;
41  topology.numTriangles = numT;
42 
43  // Store vertex pairs with minimum index occurring first.
44  for (int i = 0; i < numV; ++i, vpair += 2)
45  {
46  topology.vpair[i][0] = std::min(vpair[0], vpair[1]);
47  topology.vpair[i][1] = std::max(vpair[0], vpair[1]);
48  }
49 
50  // Store triangle triples as is.
51  for (int i = 0; i < numT; ++i, itriple += 3)
52  {
53  topology.itriple[i] = { itriple[0], itriple[1], itriple[2] };
54  }
55 }
56 
57 void MarchingCubes::Bits0(int[8])
58 {
59  SetTable(0, nullptr, 0, nullptr);
60 }
61 
62 void MarchingCubes::Bits1(int index[8])
63 {
64  int const numV = 3;
65  int vpair[2 * numV] =
66  {
67  index[1], index[0],
68  index[4], index[0],
69  index[2], index[0]
70  };
71 
72  int const numT = 1;
73  int itriple[3 * numT] =
74  {
75  0, 1, 2
76  };
77 
78  SetTable(numV, vpair, numT, itriple);
79 }
80 
81 void MarchingCubes::Bits7(int index[8])
82 {
83  int const numV = 3;
84  int vpair[2 * numV] =
85  {
86  index[1], index[0],
87  index[4], index[0],
88  index[2], index[0]
89  };
90 
91  int const numT = 1;
92  int itriple[3 * numT] =
93  {
94  0, 2, 1
95  };
96 
97  SetTable(numV, vpair, numT, itriple);
98 }
99 
100 void MarchingCubes::Bits2Edge(int index[8])
101 {
102  int const numV = 4;
103  int vpair[2 * numV] =
104  {
105  index[4], index[0],
106  index[2], index[0],
107  index[3], index[1],
108  index[5], index[1]
109  };
110 
111  int const numT = 2;
112  int itriple[3 * numT] =
113  {
114  0, 1, 2,
115  0, 2, 3
116  };
117 
118  SetTable(numV, vpair, numT, itriple);
119 }
120 
121 void MarchingCubes::Bits6Edge(int index[8])
122 {
123  int const numV = 4;
124  int vpair[2 * numV] =
125  {
126  index[4], index[0],
127  index[2], index[0],
128  index[3], index[1],
129  index[5], index[1]
130  };
131 
132  int const numT = 2;
133  int itriple[3 * numT] =
134  {
135  0, 2, 1,
136  0, 3, 2
137  };
138 
139  SetTable(numV, vpair, numT, itriple);
140 }
141 
142 void MarchingCubes::Bits2FaceDiag(int index[8])
143 {
144  int const numV = 6;
145  int vpair[2 * numV] =
146  {
147  index[1], index[0],
148  index[4], index[0],
149  index[2], index[0],
150  index[2], index[3],
151  index[7], index[3],
152  index[1], index[3]
153  };
154 
155  int const numT = 2;
156  int itriple[3 * numT] =
157  {
158  0, 1, 2,
159  3, 4, 5
160  };
161 
162  SetTable(numV, vpair, numT, itriple);
163 }
164 
165 void MarchingCubes::Bits6FaceDiag(int index[8])
166 {
167  int const numV = 6;
168  int vpair[2 * numV] =
169  {
170  index[1], index[0],
171  index[4], index[0],
172  index[2], index[0],
173  index[2], index[3],
174  index[7], index[3],
175  index[1], index[3]
176  };
177 
178  // Not the reverse ordering from Bit2FaceDiag due to ambiguous face
179  // handling.
180  int const numT = 4;
181  int itriple[3 * numT] =
182  {
183  1, 0, 5,
184  1, 5, 4,
185  1, 4, 3,
186  1, 3, 2
187  };
188 
189  SetTable(numV, vpair, numT, itriple);
190 }
191 
192 void MarchingCubes::Bits2BoxDiag(int index[8])
193 {
194  int const numV = 6;
195  int vpair[2 * numV] =
196  {
197  index[1], index[0],
198  index[4], index[0],
199  index[2], index[0],
200  index[3], index[7],
201  index[6], index[7],
202  index[5], index[7]
203  };
204 
205  int const numT = 2;
206  int itriple[3 * numT] =
207  {
208  0, 1, 2,
209  3, 4, 5
210  };
211 
212  SetTable(numV, vpair, numT, itriple);
213 }
214 
215 void MarchingCubes::Bits6BoxDiag(int index[8])
216 {
217  int const numV = 6;
218  int vpair[2 * numV] =
219  {
220  index[1], index[0],
221  index[4], index[0],
222  index[2], index[0],
223  index[3], index[7],
224  index[6], index[7],
225  index[5], index[7]
226  };
227 
228  int const numT = 2;
229  int itriple[3 * numT] =
230  {
231  0, 2, 1,
232  3, 5, 4
233  };
234 
235  SetTable(numV, vpair, numT, itriple);
236 }
237 
238 void MarchingCubes::Bits3SameFace(int index[8])
239 {
240  int const numV = 5;
241  int vpair[2 * numV] =
242  {
243  index[4], index[0],
244  index[2], index[6],
245  index[2], index[3],
246  index[1], index[3],
247  index[1], index[5]
248  };
249 
250  int const numT = 3;
251  int itriple[3 * numT] =
252  {
253  0, 1, 2,
254  0, 2, 3,
255  0, 3, 4
256  };
257 
258  SetTable(numV, vpair, numT, itriple);
259 }
260 
261 void MarchingCubes::Bits5SameFace(int index[8])
262 {
263  int const numV = 5;
264  int vpair[2 * numV] =
265  {
266  index[4], index[0],
267  index[2], index[6],
268  index[2], index[3],
269  index[1], index[3],
270  index[1], index[5]
271  };
272 
273  int const numT = 3;
274  int itriple[3 * numT] =
275  {
276  0, 2, 1,
277  0, 3, 2,
278  0, 4, 3
279  };
280 
281  SetTable(numV, vpair, numT, itriple);
282 }
283 
284 void MarchingCubes::Bits3EdgeFaceDiag(int index[8])
285 {
286  int const numV = 7;
287  int vpair[2 * numV] =
288  {
289  index[0], index[1],
290  index[4], index[5],
291  index[4], index[6],
292  index[0], index[2],
293  index[2], index[3],
294  index[3], index[7],
295  index[1], index[3]
296  };
297 
298  int const numT = 3;
299  int itriple[3 * numT] =
300  {
301  0, 1, 2,
302  0, 2, 3,
303  4, 5, 6
304  };
305 
306  SetTable(numV, vpair, numT, itriple);
307 }
308 
309 void MarchingCubes::Bits5EdgeFaceDiag(int index[8])
310 {
311  int const numV = 7;
312  int vpair[2 * numV] =
313  {
314  index[0], index[1],
315  index[4], index[5],
316  index[4], index[6],
317  index[0], index[2],
318  index[2], index[3],
319  index[3], index[7],
320  index[1], index[3]
321  };
322 
323  // Not the reverse ordering from Bit3EdgeFaceDiag due to ambiguous face
324  // handling.
325  int const numT = 5;
326  int itriple[3 * numT] =
327  {
328  5, 0, 6,
329  5, 1, 0,
330  5, 2, 1,
331  5, 3, 2,
332  5, 4, 3
333  };
334 
335  SetTable(numV, vpair, numT, itriple);
336 }
337 
338 void MarchingCubes::Bits3FaceDiagFaceDiag(int index[8])
339 {
340  int const numV = 9;
341  int vpair[2 * numV] =
342  {
343  index[0], index[1],
344  index[0], index[4],
345  index[0], index[2],
346  index[2], index[3],
347  index[3], index[7],
348  index[1], index[3],
349  index[1], index[5],
350  index[5], index[7],
351  index[4], index[5]
352  };
353 
354  int const numT = 3;
355  int itriple[3 * numT] =
356  {
357  0, 1, 2,
358  3, 4, 5,
359  6, 7, 8
360  };
361 
362  SetTable(numV, vpair, numT, itriple);
363 }
364 
365 void MarchingCubes::Bits5FaceDiagFaceDiag(int index[8])
366 {
367  int const numV = 9;
368  int vpair[2 * numV] =
369  {
370  index[0], index[1],
371  index[0], index[4],
372  index[0], index[2],
373  index[2], index[3],
374  index[3], index[7],
375  index[1], index[3],
376  index[1], index[5],
377  index[5], index[7],
378  index[4], index[5]
379  };
380 
381  // Not the reverse ordering from Bit3FaceDiagFaceDiag due to ambiguous face
382  // handling.
383  int const numT = 5;
384  int itriple[3 * numT] =
385  {
386  1, 3, 2,
387  1, 4, 3,
388  1, 7, 4,
389  1, 8, 7,
390  0, 5, 6
391  };
392 
393  SetTable(numV, vpair, numT, itriple);
394 }
395 
396 void MarchingCubes::Bits4SameFace(int index[8])
397 {
398  int const numV = 4;
399  int vpair[2 * numV] =
400  {
401  index[0], index[4],
402  index[2], index[6],
403  index[3], index[7],
404  index[1], index[5]
405  };
406 
407  int const numT = 2;
408  int itriple[3 * numT] =
409  {
410  0, 1, 2,
411  0, 2, 3
412  };
413 
414  SetTable(numV, vpair, numT, itriple);
415 }
416 
417 void MarchingCubes::Bits4FaceEdge(int index[8])
418 {
419  int const numV = 6;
420  int vpair[2 * numV] =
421  {
422  index[4], index[5],
423  index[4], index[6],
424  index[2], index[6],
425  index[2], index[3],
426  index[1], index[3],
427  index[1], index[5]
428  };
429 
430  int const numT = 4;
431  int itriple[3 * numT] =
432  {
433  0, 1, 2,
434  0, 2, 3,
435  0, 3, 4,
436  0, 4, 5
437  };
438 
439  SetTable(numV, vpair, numT, itriple);
440 }
441 
442 void MarchingCubes::Bits4FaceFaceDiagL(int index[8])
443 {
444  int const numV = 6;
445  int vpair[2 * numV] =
446  {
447  index[4], index[5],
448  index[0], index[4],
449  index[2], index[6],
450  index[2], index[3],
451  index[1], index[3],
452  index[5], index[7]
453  };
454 
455  int const numT = 4;
456  int itriple[3 * numT] =
457  {
458  0, 1, 2,
459  0, 2, 3,
460  0, 3, 4,
461  0, 4, 5
462  };
463 
464  SetTable(numV, vpair, numT, itriple);
465 }
466 
467 void MarchingCubes::Bits4FaceFaceDiagR(int index[8])
468 {
469  int const numV = 6;
470  int vpair[2 * numV] =
471  {
472  index[4], index[6],
473  index[6], index[7],
474  index[2], index[3],
475  index[1], index[3],
476  index[1], index[5],
477  index[0], index[4]
478  };
479 
480  int const numT = 4;
481  int itriple[3 * numT] =
482  {
483  0, 1, 2,
484  0, 2, 3,
485  0, 3, 4,
486  0, 4, 5
487  };
488 
489  SetTable(numV, vpair, numT, itriple);
490 }
491 
492 void MarchingCubes::Bits4FaceBoxDiag(int index[8])
493 {
494  int const numV = 8;
495  int vpair[2 * numV] =
496  {
497  index[0], index[4],
498  index[2], index[6],
499  index[2], index[3],
500  index[1], index[3],
501  index[1], index[5],
502  index[6], index[7],
503  index[5], index[7],
504  index[3], index[7]
505  };
506 
507  int const numT = 4;
508  int itriple[3 * numT] =
509  {
510  0, 1, 2,
511  0, 2, 3,
512  0, 3, 4,
513  5, 6, 7
514  };
515 
516  SetTable(numV, vpair, numT, itriple);
517 }
518 
519 void MarchingCubes::Bits4EdgeEdgePara(int index[8])
520 {
521  int const numV = 8;
522  int vpair[2 * numV] =
523  {
524  index[0], index[4],
525  index[0], index[2],
526  index[1], index[3],
527  index[1], index[5],
528  index[2], index[6],
529  index[4], index[6],
530  index[5], index[7],
531  index[3], index[7]
532  };
533 
534  int const numT = 4;
535  int itriple[3 * numT] =
536  {
537  0, 1, 2,
538  0, 2, 3,
539  4, 5, 6,
540  4, 6, 7
541  };
542 
543  SetTable(numV, vpair, numT, itriple);
544 }
545 
546 void MarchingCubes::Bits4EdgeEdgePerp(int index[8])
547 {
548  int const numV = 12;
549  int vpair[2 * numV] =
550  {
551  index[0], index[1],
552  index[0], index[4],
553  index[0], index[2],
554  index[2], index[6],
555  index[4], index[6],
556  index[6], index[7],
557  index[2], index[3],
558  index[3], index[7],
559  index[1], index[3],
560  index[1], index[5],
561  index[5], index[7],
562  index[4], index[5]
563  };
564 
565  int const numT = 4;
566  int itriple[3 * numT] =
567  {
568  0, 1, 2,
569  3, 4, 5,
570  6, 7, 8,
571  9, 10, 11
572  };
573 
574  SetTable(numV, vpair, numT, itriple);
575 
576 }
577 
578 MarchingCubes::Topology::Topology()
579  :
580  numVertices(0),
581  numTriangles(0)
582 {
583  std::fill(vpair.begin(), vpair.end(), std::array<int, 2>{ 0, 0 });
584  std::fill(itriple.begin(), itriple.end(), std::array<int, 3>{ 0, 0, 0 });
585 }
586 
587 #define MC_ENTRY(name) CT_##name, &MarchingCubes::name
588 
589 MarchingCubes::Configuration MarchingCubes::msConfiguration[256] =
590 {
591  /*00000000*/{ MC_ENTRY(Bits0), 0, 1, 2, 3, 4, 5, 6, 7 },
592  /*00000001*/{ MC_ENTRY(Bits1), 0, 1, 2, 3, 4, 5, 6, 7 },
593  /*00000010*/{ MC_ENTRY(Bits1), 1, 3, 0, 2, 5, 7, 4, 6 },
594  /*00000011*/{ MC_ENTRY(Bits2Edge), 0, 1, 2, 3, 4, 5, 6, 7 },
595  /*00000100*/{ MC_ENTRY(Bits1), 2, 0, 3, 1, 6, 4, 7, 5 },
596  /*00000101*/{ MC_ENTRY(Bits2Edge), 2, 0, 3, 1, 6, 4, 7, 5 },
597  /*00000110*/{ MC_ENTRY(Bits2FaceDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
598  /*00000111*/{ MC_ENTRY(Bits3SameFace), 0, 1, 2, 3, 4, 5, 6, 7 },
599  /*00001000*/{ MC_ENTRY(Bits1), 3, 2, 1, 0, 7, 6, 5, 4 },
600  /*00001001*/{ MC_ENTRY(Bits2FaceDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
601  /*00001010*/{ MC_ENTRY(Bits2Edge), 1, 3, 0, 2, 5, 7, 4, 6 },
602  /*00001011*/{ MC_ENTRY(Bits3SameFace), 1, 3, 0, 2, 5, 7, 4, 6 },
603  /*00001100*/{ MC_ENTRY(Bits2Edge), 3, 2, 1, 0, 7, 6, 5, 4 },
604  /*00001101*/{ MC_ENTRY(Bits3SameFace), 2, 0, 3, 1, 6, 4, 7, 5 },
605  /*00001110*/{ MC_ENTRY(Bits3SameFace), 3, 2, 1, 0, 7, 6, 5, 4 },
606  /*00001111*/{ MC_ENTRY(Bits4SameFace), 0, 1, 2, 3, 4, 5, 6, 7 },
607  /*00010000*/{ MC_ENTRY(Bits1), 4, 5, 0, 1, 6, 7, 2, 3 },
608  /*00010001*/{ MC_ENTRY(Bits2Edge), 4, 0, 6, 2, 5, 1, 7, 3 },
609  /*00010010*/{ MC_ENTRY(Bits2FaceDiag), 1, 0, 5, 4, 3, 2, 7, 6 },
610  /*00010011*/{ MC_ENTRY(Bits3SameFace), 0, 4, 1, 5, 2, 6, 3, 7 },
611  /*00010100*/{ MC_ENTRY(Bits2FaceDiag), 4, 0, 6, 2, 5, 1, 7, 3 },
612  /*00010101*/{ MC_ENTRY(Bits3SameFace), 0, 2, 4, 6, 1, 3, 5, 7 },
613  /*00010110*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
614  /*00010111*/{ MC_ENTRY(Bits4FaceEdge), 0, 1, 2, 3, 4, 5, 6, 7 },
615  /*00011000*/{ MC_ENTRY(Bits2BoxDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
616  /*00011001*/{ MC_ENTRY(Bits3EdgeFaceDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
617  /*00011010*/{ MC_ENTRY(Bits3EdgeFaceDiag), 1, 0, 5, 4, 3, 2, 7, 6 },
618  /*00011011*/{ MC_ENTRY(Bits4FaceFaceDiagR), 1, 3, 0, 2, 5, 7, 4, 6 },
619  /*00011100*/{ MC_ENTRY(Bits3EdgeFaceDiag), 2, 6, 0, 4, 3, 7, 1, 5 },
620  /*00011101*/{ MC_ENTRY(Bits4FaceFaceDiagL), 2, 0, 3, 1, 6, 4, 7, 5 },
621  /*00011110*/{ MC_ENTRY(Bits4FaceBoxDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
622  /*00011111*/{ MC_ENTRY(Bits5SameFace), 7, 5, 6, 4, 3, 1, 2, 0 },
623  /*00100000*/{ MC_ENTRY(Bits1), 5, 7, 1, 3, 4, 6, 0, 2 },
624  /*00100001*/{ MC_ENTRY(Bits2FaceDiag), 0, 4, 1, 5, 2, 6, 3, 7 },
625  /*00100010*/{ MC_ENTRY(Bits2Edge), 5, 1, 4, 0, 7, 3, 6, 2 },
626  /*00100011*/{ MC_ENTRY(Bits3SameFace), 1, 0, 5, 4, 3, 2, 7, 6 },
627  /*00100100*/{ MC_ENTRY(Bits2BoxDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
628  /*00100101*/{ MC_ENTRY(Bits3EdgeFaceDiag), 0, 4, 1, 5, 2, 6, 3, 7 },
629  /*00100110*/{ MC_ENTRY(Bits3EdgeFaceDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
630  /*00100111*/{ MC_ENTRY(Bits4FaceFaceDiagL), 0, 1, 2, 3, 4, 5, 6, 7 },
631  /*00101000*/{ MC_ENTRY(Bits2FaceDiag), 5, 7, 1, 3, 4, 6, 0, 2 },
632  /*00101001*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
633  /*00101010*/{ MC_ENTRY(Bits3SameFace), 1, 5, 3, 7, 0, 4, 2, 6 },
634  /*00101011*/{ MC_ENTRY(Bits4FaceEdge), 1, 3, 0, 2, 5, 7, 4, 6 },
635  /*00101100*/{ MC_ENTRY(Bits3EdgeFaceDiag), 3, 1, 7, 5, 2, 0, 6, 4 },
636  /*00101101*/{ MC_ENTRY(Bits4FaceBoxDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
637  /*00101110*/{ MC_ENTRY(Bits4FaceFaceDiagR), 3, 2, 1, 0, 7, 6, 5, 4 },
638  /*00101111*/{ MC_ENTRY(Bits5SameFace), 6, 7, 4, 5, 2, 3, 0, 1 },
639  /*00110000*/{ MC_ENTRY(Bits2Edge), 4, 5, 0, 1, 6, 7, 2, 3 },
640  /*00110001*/{ MC_ENTRY(Bits3SameFace), 4, 5, 0, 1, 6, 7, 2, 3 },
641  /*00110010*/{ MC_ENTRY(Bits3SameFace), 5, 1, 4, 0, 7, 3, 6, 2 },
642  /*00110011*/{ MC_ENTRY(Bits4SameFace), 0, 4, 1, 5, 2, 6, 3, 7 },
643  /*00110100*/{ MC_ENTRY(Bits3EdgeFaceDiag), 4, 0, 6, 2, 5, 1, 7, 3 },
644  /*00110101*/{ MC_ENTRY(Bits4FaceFaceDiagR), 0, 2, 4, 6, 1, 3, 5, 7 },
645  /*00110110*/{ MC_ENTRY(Bits4FaceBoxDiag), 5, 1, 4, 0, 7, 3, 6, 2 },
646  /*00110111*/{ MC_ENTRY(Bits5SameFace), 7, 6, 3, 2, 5, 4, 1, 0 },
647  /*00111000*/{ MC_ENTRY(Bits3EdgeFaceDiag), 5, 7, 1, 3, 4, 6, 0, 2 },
648  /*00111001*/{ MC_ENTRY(Bits4FaceBoxDiag), 4, 5, 0, 1, 6, 7, 2, 3 },
649  /*00111010*/{ MC_ENTRY(Bits4FaceFaceDiagL), 5, 1, 4, 0, 7, 3, 6, 2 },
650  /*00111011*/{ MC_ENTRY(Bits5SameFace), 6, 2, 7, 3, 4, 0, 5, 1 },
651  /*00111100*/{ MC_ENTRY(Bits4EdgeEdgePara), 3, 2, 1, 0, 7, 6, 5, 4 },
652  /*00111101*/{ MC_ENTRY(Bits5EdgeFaceDiag), 7, 3, 5, 1, 6, 2, 4, 0 },
653  /*00111110*/{ MC_ENTRY(Bits5EdgeFaceDiag), 6, 4, 2, 0, 7, 5, 3, 1 },
654  /*00111111*/{ MC_ENTRY(Bits6Edge), 6, 7, 4, 5, 2, 3, 0, 1 },
655  /*01000000*/{ MC_ENTRY(Bits1), 6, 7, 4, 5, 2, 3, 0, 1 },
656  /*01000001*/{ MC_ENTRY(Bits2FaceDiag), 0, 2, 4, 6, 1, 3, 5, 7 },
657  /*01000010*/{ MC_ENTRY(Bits2BoxDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
658  /*01000011*/{ MC_ENTRY(Bits3EdgeFaceDiag), 0, 2, 4, 6, 1, 3, 5, 7 },
659  /*01000100*/{ MC_ENTRY(Bits2Edge), 6, 2, 7, 3, 4, 0, 5, 1 },
660  /*01000101*/{ MC_ENTRY(Bits3SameFace), 2, 6, 0, 4, 3, 7, 1, 5 },
661  /*01000110*/{ MC_ENTRY(Bits3EdgeFaceDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
662  /*01000111*/{ MC_ENTRY(Bits4FaceFaceDiagR), 0, 1, 2, 3, 4, 5, 6, 7 },
663  /*01001000*/{ MC_ENTRY(Bits2FaceDiag), 3, 7, 2, 6, 1, 5, 0, 4 },
664  /*01001001*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
665  /*01001010*/{ MC_ENTRY(Bits3EdgeFaceDiag), 3, 7, 2, 6, 1, 5, 0, 4 },
666  /*01001011*/{ MC_ENTRY(Bits4FaceBoxDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
667  /*01001100*/{ MC_ENTRY(Bits3SameFace), 2, 3, 6, 7, 0, 1, 4, 5 },
668  /*01001101*/{ MC_ENTRY(Bits4FaceEdge), 2, 0, 3, 1, 6, 4, 7, 5 },
669  /*01001110*/{ MC_ENTRY(Bits4FaceFaceDiagL), 3, 2, 1, 0, 7, 6, 5, 4 },
670  /*01001111*/{ MC_ENTRY(Bits5SameFace), 5, 4, 7, 6, 1, 0, 3, 2 },
671  /*01010000*/{ MC_ENTRY(Bits2Edge), 6, 4, 2, 0, 7, 5, 3, 1 },
672  /*01010001*/{ MC_ENTRY(Bits3SameFace), 4, 0, 6, 2, 5, 1, 7, 3 },
673  /*01010010*/{ MC_ENTRY(Bits3EdgeFaceDiag), 4, 5, 0, 1, 6, 7, 2, 3 },
674  /*01010011*/{ MC_ENTRY(Bits4FaceFaceDiagL), 0, 4, 1, 5, 2, 6, 3, 7 },
675  /*01010100*/{ MC_ENTRY(Bits3SameFace), 6, 4, 2, 0, 7, 5, 3, 1 },
676  /*01010101*/{ MC_ENTRY(Bits4SameFace), 0, 2, 4, 6, 1, 3, 5, 7 },
677  /*01010110*/{ MC_ENTRY(Bits4FaceBoxDiag), 6, 4, 2, 0, 7, 5, 3, 1 },
678  /*01010111*/{ MC_ENTRY(Bits5SameFace), 7, 3, 5, 1, 6, 2, 4, 0 },
679  /*01011000*/{ MC_ENTRY(Bits3EdgeFaceDiag), 6, 2, 7, 3, 4, 0, 5, 1 },
680  /*01011001*/{ MC_ENTRY(Bits4FaceBoxDiag), 4, 0, 6, 2, 5, 1, 7, 3 },
681  /*01011010*/{ MC_ENTRY(Bits4EdgeEdgePara), 1, 3, 0, 2, 5, 7, 4, 6 },
682  /*01011011*/{ MC_ENTRY(Bits5EdgeFaceDiag), 7, 6, 3, 2, 5, 4, 1, 0 },
683  /*01011100*/{ MC_ENTRY(Bits4FaceFaceDiagR), 6, 4, 2, 0, 7, 5, 3, 1 },
684  /*01011101*/{ MC_ENTRY(Bits5SameFace), 5, 7, 1, 3, 4, 6, 0, 2 },
685  /*01011110*/{ MC_ENTRY(Bits5EdgeFaceDiag), 5, 1, 4, 0, 7, 3, 6, 2 },
686  /*01011111*/{ MC_ENTRY(Bits6Edge), 5, 7, 1, 3, 4, 6, 0, 2 },
687  /*01100000*/{ MC_ENTRY(Bits2FaceDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
688  /*01100001*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
689  /*01100010*/{ MC_ENTRY(Bits3EdgeFaceDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
690  /*01100011*/{ MC_ENTRY(Bits4FaceBoxDiag), 1, 0, 5, 4, 3, 2, 7, 6 },
691  /*01100100*/{ MC_ENTRY(Bits3EdgeFaceDiag), 6, 7, 4, 5, 2, 3, 0, 1 },
692  /*01100101*/{ MC_ENTRY(Bits4FaceBoxDiag), 2, 6, 0, 4, 3, 7, 1, 5 },
693  /*01100110*/{ MC_ENTRY(Bits4EdgeEdgePara), 6, 2, 7, 3, 4, 0, 5, 1 },
694  /*01100111*/{ MC_ENTRY(Bits5EdgeFaceDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
695  /*01101000*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 6, 7, 4, 5, 2, 3, 0, 1 },
696  /*01101001*/{ MC_ENTRY(Bits4EdgeEdgePerp), 0, 1, 2, 3, 4, 5, 6, 7 },
697  /*01101010*/{ MC_ENTRY(Bits4FaceBoxDiag), 1, 5, 3, 7, 0, 4, 2, 6 },
698  /*01101011*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 4, 6, 5, 7, 0, 2, 1, 3 },
699  /*01101100*/{ MC_ENTRY(Bits4FaceBoxDiag), 2, 3, 6, 7, 0, 1, 4, 5 },
700  /*01101101*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
701  /*01101110*/{ MC_ENTRY(Bits5EdgeFaceDiag), 4, 6, 5, 7, 0, 2, 1, 3 },
702  /*01101111*/{ MC_ENTRY(Bits6FaceDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
703  /*01110000*/{ MC_ENTRY(Bits3SameFace), 4, 6, 5, 7, 0, 2, 1, 3 },
704  /*01110001*/{ MC_ENTRY(Bits4FaceEdge), 4, 6, 5, 7, 0, 2, 1, 3 },
705  /*01110010*/{ MC_ENTRY(Bits4FaceFaceDiagR), 5, 1, 4, 0, 7, 3, 6, 2 },
706  /*01110011*/{ MC_ENTRY(Bits5SameFace), 3, 7, 2, 6, 1, 5, 0, 4 },
707  /*01110100*/{ MC_ENTRY(Bits4FaceFaceDiagL), 4, 6, 5, 7, 0, 2, 1, 3 },
708  /*01110101*/{ MC_ENTRY(Bits5SameFace), 3, 1, 7, 5, 2, 0, 6, 4 },
709  /*01110110*/{ MC_ENTRY(Bits5EdgeFaceDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
710  /*01110111*/{ MC_ENTRY(Bits6Edge), 3, 7, 2, 6, 1, 5, 0, 4 },
711  /*01111000*/{ MC_ENTRY(Bits4FaceBoxDiag), 4, 6, 5, 7, 0, 2, 1, 3 },
712  /*01111001*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
713  /*01111010*/{ MC_ENTRY(Bits5EdgeFaceDiag), 2, 3, 6, 7, 0, 1, 4, 5 },
714  /*01111011*/{ MC_ENTRY(Bits6FaceDiag), 2, 3, 6, 7, 0, 1, 4, 5 },
715  /*01111100*/{ MC_ENTRY(Bits5EdgeFaceDiag), 1, 5, 3, 7, 0, 4, 2, 6 },
716  /*01111101*/{ MC_ENTRY(Bits6FaceDiag), 1, 5, 3, 7, 0, 4, 2, 6 },
717  /*01111110*/{ MC_ENTRY(Bits6BoxDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
718  /*01111111*/{ MC_ENTRY(Bits7), 7, 3, 5, 1, 6, 2, 4, 0 },
719  /*10000000*/{ MC_ENTRY(Bits1), 7, 3, 5, 1, 6, 2, 4, 0 },
720  /*10000001*/{ MC_ENTRY(Bits2BoxDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
721  /*10000010*/{ MC_ENTRY(Bits2FaceDiag), 1, 5, 3, 7, 0, 4, 2, 6 },
722  /*10000011*/{ MC_ENTRY(Bits3EdgeFaceDiag), 1, 5, 3, 7, 0, 4, 2, 6 },
723  /*10000100*/{ MC_ENTRY(Bits2FaceDiag), 2, 3, 6, 7, 0, 1, 4, 5 },
724  /*10000101*/{ MC_ENTRY(Bits3EdgeFaceDiag), 2, 3, 6, 7, 0, 1, 4, 5 },
725  /*10000110*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
726  /*10000111*/{ MC_ENTRY(Bits4FaceBoxDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
727  /*10001000*/{ MC_ENTRY(Bits2Edge), 3, 7, 2, 6, 1, 5, 0, 4 },
728  /*10001001*/{ MC_ENTRY(Bits3EdgeFaceDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
729  /*10001010*/{ MC_ENTRY(Bits3SameFace), 3, 1, 7, 5, 2, 0, 6, 4 },
730  /*10001011*/{ MC_ENTRY(Bits4FaceFaceDiagL), 1, 3, 0, 2, 5, 7, 4, 6 },
731  /*10001100*/{ MC_ENTRY(Bits3SameFace), 3, 7, 2, 6, 1, 5, 0, 4 },
732  /*10001101*/{ MC_ENTRY(Bits4FaceFaceDiagR), 2, 0, 3, 1, 6, 4, 7, 5 },
733  /*10001110*/{ MC_ENTRY(Bits4FaceEdge), 3, 2, 1, 0, 7, 6, 5, 4 },
734  /*10001111*/{ MC_ENTRY(Bits5SameFace), 4, 6, 5, 7, 0, 2, 1, 3 },
735  /*10010000*/{ MC_ENTRY(Bits2FaceDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
736  /*10010001*/{ MC_ENTRY(Bits3EdgeFaceDiag), 4, 6, 5, 7, 0, 2, 1, 3 },
737  /*10010010*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
738  /*10010011*/{ MC_ENTRY(Bits4FaceBoxDiag), 0, 4, 1, 5, 2, 6, 3, 7 },
739  /*10010100*/{ MC_ENTRY(Bits3FaceDiagFaceDiag), 4, 6, 5, 7, 0, 2, 1, 3 },
740  /*10010101*/{ MC_ENTRY(Bits4FaceBoxDiag), 0, 2, 4, 6, 1, 3, 5, 7 },
741  /*10010110*/{ MC_ENTRY(Bits4EdgeEdgePerp), 1, 3, 0, 2, 5, 7, 4, 6 },
742  /*10010111*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 6, 7, 4, 5, 2, 3, 0, 1 },
743  /*10011000*/{ MC_ENTRY(Bits3EdgeFaceDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
744  /*10011001*/{ MC_ENTRY(Bits4EdgeEdgePara), 4, 0, 6, 2, 5, 1, 7, 3 },
745  /*10011010*/{ MC_ENTRY(Bits4FaceBoxDiag), 3, 1, 7, 5, 2, 0, 6, 4 },
746  /*10011011*/{ MC_ENTRY(Bits5EdgeFaceDiag), 6, 7, 4, 5, 2, 3, 0, 1 },
747  /*10011100*/{ MC_ENTRY(Bits4FaceBoxDiag), 3, 7, 2, 6, 1, 5, 0, 4 },
748  /*10011101*/{ MC_ENTRY(Bits5EdgeFaceDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
749  /*10011110*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
750  /*10011111*/{ MC_ENTRY(Bits6FaceDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
751  /*10100000*/{ MC_ENTRY(Bits2Edge), 5, 7, 1, 3, 4, 6, 0, 2 },
752  /*10100001*/{ MC_ENTRY(Bits3EdgeFaceDiag), 5, 1, 4, 0, 7, 3, 6, 2 },
753  /*10100010*/{ MC_ENTRY(Bits3SameFace), 5, 7, 1, 3, 4, 6, 0, 2 },
754  /*10100011*/{ MC_ENTRY(Bits4FaceFaceDiagR), 1, 0, 5, 4, 3, 2, 7, 6 },
755  /*10100100*/{ MC_ENTRY(Bits3EdgeFaceDiag), 7, 6, 3, 2, 5, 4, 1, 0 },
756  /*10100101*/{ MC_ENTRY(Bits4EdgeEdgePara), 2, 0, 3, 1, 6, 4, 7, 5 },
757  /*10100110*/{ MC_ENTRY(Bits4FaceBoxDiag), 5, 7, 1, 3, 4, 6, 0, 2 },
758  /*10100111*/{ MC_ENTRY(Bits5EdgeFaceDiag), 6, 2, 7, 3, 4, 0, 5, 1 },
759  /*10101000*/{ MC_ENTRY(Bits3SameFace), 7, 3, 5, 1, 6, 2, 4, 0 },
760  /*10101001*/{ MC_ENTRY(Bits4FaceBoxDiag), 7, 3, 5, 1, 6, 2, 4, 0 },
761  /*10101010*/{ MC_ENTRY(Bits4SameFace), 1, 5, 3, 7, 0, 4, 2, 6 },
762  /*10101011*/{ MC_ENTRY(Bits5SameFace), 6, 4, 2, 0, 7, 5, 3, 1 },
763  /*10101100*/{ MC_ENTRY(Bits4FaceFaceDiagL), 3, 7, 2, 6, 1, 5, 0, 4 },
764  /*10101101*/{ MC_ENTRY(Bits5EdgeFaceDiag), 4, 5, 0, 1, 6, 7, 2, 3 },
765  /*10101110*/{ MC_ENTRY(Bits5SameFace), 4, 0, 6, 2, 5, 1, 7, 3 },
766  /*10101111*/{ MC_ENTRY(Bits6Edge), 6, 4, 2, 0, 7, 5, 3, 1 },
767  /*10110000*/{ MC_ENTRY(Bits3SameFace), 5, 4, 7, 6, 1, 0, 3, 2 },
768  /*10110001*/{ MC_ENTRY(Bits4FaceFaceDiagL), 4, 5, 0, 1, 6, 7, 2, 3 },
769  /*10110010*/{ MC_ENTRY(Bits4FaceEdge), 5, 1, 4, 0, 7, 3, 6, 2 },
770  /*10110011*/{ MC_ENTRY(Bits5SameFace), 2, 3, 6, 7, 0, 1, 4, 5 },
771  /*10110100*/{ MC_ENTRY(Bits4FaceBoxDiag), 5, 4, 7, 6, 1, 0, 3, 2 },
772  /*10110101*/{ MC_ENTRY(Bits5EdgeFaceDiag), 3, 7, 2, 6, 1, 5, 0, 4 },
773  /*10110110*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
774  /*10110111*/{ MC_ENTRY(Bits6FaceDiag), 3, 7, 2, 6, 1, 5, 0, 4 },
775  /*10111000*/{ MC_ENTRY(Bits4FaceFaceDiagR), 7, 3, 5, 1, 6, 2, 4, 0 },
776  /*10111001*/{ MC_ENTRY(Bits5EdgeFaceDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
777  /*10111010*/{ MC_ENTRY(Bits5SameFace), 2, 6, 0, 4, 3, 7, 1, 5 },
778  /*10111011*/{ MC_ENTRY(Bits6Edge), 6, 2, 7, 3, 4, 0, 5, 1 },
779  /*10111100*/{ MC_ENTRY(Bits5EdgeFaceDiag), 0, 2, 4, 6, 1, 3, 5, 7 },
780  /*10111101*/{ MC_ENTRY(Bits6BoxDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
781  /*10111110*/{ MC_ENTRY(Bits6FaceDiag), 0, 2, 4, 6, 1, 3, 5, 7 },
782  /*10111111*/{ MC_ENTRY(Bits7), 6, 7, 4, 5, 2, 3, 0, 1 },
783  /*11000000*/{ MC_ENTRY(Bits2Edge), 6, 7, 4, 5, 2, 3, 0, 1 },
784  /*11000001*/{ MC_ENTRY(Bits3EdgeFaceDiag), 6, 4, 2, 0, 7, 5, 3, 1 },
785  /*11000010*/{ MC_ENTRY(Bits3EdgeFaceDiag), 7, 3, 5, 1, 6, 2, 4, 0 },
786  /*11000011*/{ MC_ENTRY(Bits4EdgeEdgePara), 0, 1, 2, 3, 4, 5, 6, 7 },
787  /*11000100*/{ MC_ENTRY(Bits3SameFace), 6, 2, 7, 3, 4, 0, 5, 1 },
788  /*11000101*/{ MC_ENTRY(Bits4FaceFaceDiagL), 2, 6, 0, 4, 3, 7, 1, 5 },
789  /*11000110*/{ MC_ENTRY(Bits4FaceBoxDiag), 6, 2, 7, 3, 4, 0, 5, 1 },
790  /*11000111*/{ MC_ENTRY(Bits5EdgeFaceDiag), 5, 7, 1, 3, 4, 6, 0, 2 },
791  /*11001000*/{ MC_ENTRY(Bits3SameFace), 7, 6, 3, 2, 5, 4, 1, 0 },
792  /*11001001*/{ MC_ENTRY(Bits4FaceBoxDiag), 7, 6, 3, 2, 5, 4, 1, 0 },
793  /*11001010*/{ MC_ENTRY(Bits4FaceFaceDiagR), 7, 6, 3, 2, 5, 4, 1, 0 },
794  /*11001011*/{ MC_ENTRY(Bits5EdgeFaceDiag), 4, 0, 6, 2, 5, 1, 7, 3 },
795  /*11001100*/{ MC_ENTRY(Bits4SameFace), 2, 3, 6, 7, 0, 1, 4, 5 },
796  /*11001101*/{ MC_ENTRY(Bits5SameFace), 5, 1, 4, 0, 7, 3, 6, 2 },
797  /*11001110*/{ MC_ENTRY(Bits5SameFace), 4, 5, 0, 1, 6, 7, 2, 3 },
798  /*11001111*/{ MC_ENTRY(Bits6Edge), 4, 5, 0, 1, 6, 7, 2, 3 },
799  /*11010000*/{ MC_ENTRY(Bits3SameFace), 6, 7, 4, 5, 2, 3, 0, 1 },
800  /*11010001*/{ MC_ENTRY(Bits4FaceFaceDiagR), 4, 0, 6, 2, 5, 1, 7, 3 },
801  /*11010010*/{ MC_ENTRY(Bits4FaceBoxDiag), 6, 7, 4, 5, 2, 3, 0, 1 },
802  /*11010011*/{ MC_ENTRY(Bits5EdgeFaceDiag), 3, 1, 7, 5, 2, 0, 6, 4 },
803  /*11010100*/{ MC_ENTRY(Bits4FaceEdge), 6, 4, 2, 0, 7, 5, 3, 1 },
804  /*11010101*/{ MC_ENTRY(Bits5SameFace), 1, 5, 3, 7, 0, 4, 2, 6 },
805  /*11010110*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
806  /*11010111*/{ MC_ENTRY(Bits6FaceDiag), 5, 7, 1, 3, 4, 6, 0, 2 },
807  /*11011000*/{ MC_ENTRY(Bits4FaceFaceDiagL), 6, 7, 4, 5, 2, 3, 0, 1 },
808  /*11011001*/{ MC_ENTRY(Bits5EdgeFaceDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
809  /*11011010*/{ MC_ENTRY(Bits5EdgeFaceDiag), 0, 4, 1, 5, 2, 6, 3, 7 },
810  /*11011011*/{ MC_ENTRY(Bits6BoxDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
811  /*11011100*/{ MC_ENTRY(Bits5SameFace), 1, 0, 5, 4, 3, 2, 7, 6 },
812  /*11011101*/{ MC_ENTRY(Bits6Edge), 5, 1, 4, 0, 7, 3, 6, 2 },
813  /*11011110*/{ MC_ENTRY(Bits6FaceDiag), 0, 4, 1, 5, 2, 6, 3, 7 },
814  /*11011111*/{ MC_ENTRY(Bits7), 5, 7, 1, 3, 4, 6, 0, 2 },
815  /*11100000*/{ MC_ENTRY(Bits3SameFace), 7, 5, 6, 4, 3, 1, 2, 0 },
816  /*11100001*/{ MC_ENTRY(Bits4FaceBoxDiag), 7, 5, 6, 4, 3, 1, 2, 0 },
817  /*11100010*/{ MC_ENTRY(Bits4FaceFaceDiagL), 7, 5, 6, 4, 3, 1, 2, 0 },
818  /*11100011*/{ MC_ENTRY(Bits5EdgeFaceDiag), 2, 6, 0, 4, 3, 7, 1, 5 },
819  /*11100100*/{ MC_ENTRY(Bits4FaceFaceDiagR), 7, 5, 6, 4, 3, 1, 2, 0 },
820  /*11100101*/{ MC_ENTRY(Bits5EdgeFaceDiag), 1, 0, 5, 4, 3, 2, 7, 6 },
821  /*11100110*/{ MC_ENTRY(Bits5EdgeFaceDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
822  /*11100111*/{ MC_ENTRY(Bits6BoxDiag), 3, 2, 1, 0, 7, 6, 5, 4 },
823  /*11101000*/{ MC_ENTRY(Bits4FaceEdge), 7, 5, 6, 4, 3, 1, 2, 0 },
824  /*11101001*/{ MC_ENTRY(Bits5FaceDiagFaceDiag), 2, 0, 3, 1, 6, 4, 7, 5 },
825  /*11101010*/{ MC_ENTRY(Bits5SameFace), 0, 2, 4, 6, 1, 3, 5, 7 },
826  /*11101011*/{ MC_ENTRY(Bits6FaceDiag), 4, 0, 6, 2, 5, 1, 7, 3 },
827  /*11101100*/{ MC_ENTRY(Bits5SameFace), 0, 4, 1, 5, 2, 6, 3, 7 },
828  /*11101101*/{ MC_ENTRY(Bits6FaceDiag), 1, 0, 5, 4, 3, 2, 7, 6 },
829  /*11101110*/{ MC_ENTRY(Bits6Edge), 4, 0, 6, 2, 5, 1, 7, 3 },
830  /*11101111*/{ MC_ENTRY(Bits7), 4, 5, 0, 1, 6, 7, 2, 3 },
831  /*11110000*/{ MC_ENTRY(Bits4SameFace), 4, 6, 5, 7, 0, 2, 1, 3 },
832  /*11110001*/{ MC_ENTRY(Bits5SameFace), 3, 2, 1, 0, 7, 6, 5, 4 },
833  /*11110010*/{ MC_ENTRY(Bits5SameFace), 2, 0, 3, 1, 6, 4, 7, 5 },
834  /*11110011*/{ MC_ENTRY(Bits6Edge), 3, 2, 1, 0, 7, 6, 5, 4 },
835  /*11110100*/{ MC_ENTRY(Bits5SameFace), 1, 3, 0, 2, 5, 7, 4, 6 },
836  /*11110101*/{ MC_ENTRY(Bits6Edge), 1, 3, 0, 2, 5, 7, 4, 6 },
837  /*11110110*/{ MC_ENTRY(Bits6FaceDiag), 0, 1, 2, 3, 4, 5, 6, 7 },
838  /*11110111*/{ MC_ENTRY(Bits7), 3, 2, 1, 0, 7, 6, 5, 4 },
839  /*11111000*/{ MC_ENTRY(Bits5SameFace), 0, 1, 2, 3, 4, 5, 6, 7 },
840  /*11111001*/{ MC_ENTRY(Bits6FaceDiag), 1, 3, 0, 2, 5, 7, 4, 6 },
841  /*11111010*/{ MC_ENTRY(Bits6Edge), 2, 0, 3, 1, 6, 4, 7, 5 },
842  /*11111011*/{ MC_ENTRY(Bits7), 2, 0, 3, 1, 6, 4, 7, 5 },
843  /*11111100*/{ MC_ENTRY(Bits6Edge), 0, 1, 2, 3, 4, 5, 6, 7 },
844  /*11111101*/{ MC_ENTRY(Bits7), 1, 3, 0, 2, 5, 7, 4, 6 },
845  /*11111110*/{ MC_ENTRY(Bits7), 0, 1, 2, 3, 4, 5, 6, 7 },
846  /*11111111*/{ MC_ENTRY(Bits0), 0, 1, 2, 3, 4, 5, 6, 7 }
847 };
848 
849 std::string MarchingCubes::msConfigurationString[CT_NUM_TYPES] =
850 {
851  "Bits0",
852  "Bits1",
853  "Bits7",
854  "Bits2Edge",
855  "Bits6Edge",
856  "Bits2FaceDiag",
857  "Bits6FaceDiag",
858  "Bits2BoxDiag",
859  "Bits6BoxDiag",
860  "Bits3SameFace",
861  "Bits5SameFace",
862  "Bits3EdgeFaceDiag",
863  "Bits5EdgeFaceDiag",
864  "Bits3FaceDiagFaceDiag",
865  "Bits5FaceDiagFaceDiag",
866  "Bits4SameFace",
867  "Bits4FaceEdge",
868  "Bits4FaceFaceDiagL",
869  "Bits4FaceFaceDiagR",
870  "Bits4FaceBoxDiag",
871  "Bits4EdgeEdgePara",
872  "Bits4EdgeEdgePerp"
873 };
gte::MarchingCubes::Bits2Edge
void Bits2Edge(int index[8])
Definition: GteMarchingCubes.cpp:100
gte::MarchingCubes::mTable
Topology mTable[256]
Definition: GteMarchingCubes.h:72
gte::MarchingCubes::Bits2BoxDiag
void Bits2BoxDiag(int index[8])
Definition: GteMarchingCubes.cpp:192
gte::MarchingCubes::msConfiguration
static Configuration msConfiguration[256]
Definition: GteMarchingCubes.h:141
gte::MarchingCubes::Bits4FaceFaceDiagR
void Bits4FaceFaceDiagR(int index[8])
Definition: GteMarchingCubes.cpp:467
gte::MarchingCubes::Bits4FaceEdge
void Bits4FaceEdge(int index[8])
Definition: GteMarchingCubes.cpp:417
gte::MarchingCubes::Bits7
void Bits7(int index[8])
Definition: GteMarchingCubes.cpp:81
gte::MarchingCubes::Bits5FaceDiagFaceDiag
void Bits5FaceDiagFaceDiag(int index[8])
Definition: GteMarchingCubes.cpp:365
gte::MarchingCubes::Bits4FaceBoxDiag
void Bits4FaceBoxDiag(int index[8])
Definition: GteMarchingCubes.cpp:492
MC_ENTRY
#define MC_ENTRY(name)
Definition: GteMarchingCubes.cpp:587
gte::MarchingCubes::Bits3EdgeFaceDiag
void Bits3EdgeFaceDiag(int index[8])
Definition: GteMarchingCubes.cpp:284
string
GLsizei const GLchar *const * string
Definition: glcorearb.h:809
gte::MarchingCubes::Bits6BoxDiag
void Bits6BoxDiag(int index[8])
Definition: GteMarchingCubes.cpp:215
gte::MarchingCubes::Bits4SameFace
void Bits4SameFace(int index[8])
Definition: GteMarchingCubes.cpp:396
gte::MarchingCubes::Bits6FaceDiag
void Bits6FaceDiag(int index[8])
Definition: GteMarchingCubes.cpp:165
gte::MarchingCubes::msConfigurationString
static std::string msConfigurationString[CT_NUM_TYPES]
Definition: GteMarchingCubes.h:142
gte::MarchingCubes::Bits5EdgeFaceDiag
void Bits5EdgeFaceDiag(int index[8])
Definition: GteMarchingCubes.cpp:309
gte::MarchingCubes::Bits3FaceDiagFaceDiag
void Bits3FaceDiagFaceDiag(int index[8])
Definition: GteMarchingCubes.cpp:338
gte::MarchingCubes::Bits1
void Bits1(int index[8])
Definition: GteMarchingCubes.cpp:62
gte::MarchingCubes::GetConfigurationType
static std::string GetConfigurationType(int entry)
Definition: GteMarchingCubes.cpp:27
gte::MarchingCubes::Bits3SameFace
void Bits3SameFace(int index[8])
Definition: GteMarchingCubes.cpp:238
gte::MarchingCubes::Bits4EdgeEdgePerp
void Bits4EdgeEdgePerp(int index[8])
Definition: GteMarchingCubes.cpp:546
gte::MarchingCubes::Bits4EdgeEdgePara
void Bits4EdgeEdgePara(int index[8])
Definition: GteMarchingCubes.cpp:519
gte::MarchingCubes::Topology::itriple
std::array< std::array< int, 3 >, MAX_TRIANGLES > itriple
Definition: GteMarchingCubes.h:52
gte::MarchingCubes::Bits5SameFace
void Bits5SameFace(int index[8])
Definition: GteMarchingCubes.cpp:261
index
GLuint index
Definition: glcorearb.h:781
gte::MarchingCubes::SetTable
void SetTable(int numV, int const *vpair, int numT, int const *itriple)
Definition: GteMarchingCubes.cpp:36
gte::MarchingCubes::Bits6Edge
void Bits6Edge(int index[8])
Definition: GteMarchingCubes.cpp:121
gte::MarchingCubes::Bits4FaceFaceDiagL
void Bits4FaceFaceDiagL(int index[8])
Definition: GteMarchingCubes.cpp:442
gte::MarchingCubes::Bits2FaceDiag
void Bits2FaceDiag(int index[8])
Definition: GteMarchingCubes.cpp:142
gte::MarchingCubes::Topology::vpair
std::array< std::array< int, 2 >, MAX_VERTICES > vpair
Definition: GteMarchingCubes.h:51
gte::MarchingCubes::Bits0
void Bits0(int index[8])
Definition: GteMarchingCubes.cpp:57

geometric_tools_engine
Author(s): Yijiang Huang
autogenerated on Thu Jul 18 2019 04:00:01