36 namespace HDK_Sample {
47 template<
typename INT_TYPE,
typename FUNCTOR>
53 if (nedgerows < 0 || nedgecols < 0)
57 INT_TYPE prev_pt = INT_TYPE(-1);
61 for (
exint col = 0; col < nedgecols; ++col)
64 if (col == 0 || point != prev_pt)
66 functor(point,
row, col);
71 if (nedgecols == 0 || (!grid.
doesRowWrap(
row) && point != prev_pt))
73 functor(point,
row, nedgecols);
77 for (
exint col = 0; col < nedgecols; ++col)
79 INT_TYPE point = grid.
getPoint(nedgerows, col);
80 if (nedgerows == 0 || (!grid.
doesColWrap(col) && (col == 0 || point != prev_pt)))
82 functor(point, nedgerows, col);
86 INT_TYPE point = grid.
getPoint(nedgerows, nedgecols);
87 if ((nedgecols == 0 || !grid.
doesRowWrap(nedgerows)) && (nedgerows == 0 || !grid.
doesColWrap(nedgecols)) && point != prev_pt)
89 functor(point, nedgerows, nedgecols);
96 template<
typename INT_TYPE,
typename FUNCTOR>
108 if (nedgerows < 0 || nedgecols < 0)
135 nvertices = nedgecols +
exint(!closed);
137 functor(primnum, 0, 0, nvertices, closed);
149 npoints = nedgecols +
exint(!closed_curve);
151 for (
exint col = 0; col < npoints; ++col)
153 functor(primnum, 0, col, 1,
false);
166 exint npoints = nedgerows +
exint(!closed_curve);
168 for (exint
row = 0;
row < npoints; ++
row)
170 functor(primnum,
row, 0, 1,
false);
181 functor(primnum, 0, 0, nvertices, closed);
197 for (exint
row = first_row;
row < nedgerows; ++
row, ++primnum)
199 if (different_nvertices)
202 nvertices = nedgecols +
exint(!closed);
204 functor(primnum,
row, 0, nvertices, closed);
211 if (different_nvertices)
214 nvertices = nedgecols +
exint(!closed);
216 functor(primnum, nedgerows, 0, nvertices, closed);
225 for (exint col = 0; col < nedgecols; ++col, col_wraps = next_col_wraps)
228 bool currently_in_a_curve = (primvtx != 0);
229 if (!currently_in_a_curve)
231 if (col_wraps && next_col_wraps)
250 else if (col_wraps && next_col_wraps)
255 functor(primnum, nedgerows, primstartcol, col+1-primstartcol,
false);
284 functor(primnum, nedgerows, primstartcol, nedgecols+1-primstartcol,
false);
302 for (exint col = first_col; col < nedgecols; ++col, ++primnum)
304 if (different_nvertices)
307 nvertices = nedgerows +
exint(!closed);
309 functor(primnum, 0, col, nvertices, closed);
316 if (different_nvertices)
319 nvertices = nedgerows +
exint(!closed);
321 functor(primnum, 0, nedgecols, nvertices, closed);
330 for (exint
row = 0;
row < nedgerows; ++
row, row_wraps = next_row_wraps)
333 bool currently_in_a_curve = (primvtx != 0);
334 if (!currently_in_a_curve)
336 if (row_wraps && next_row_wraps)
355 else if (row_wraps && next_row_wraps)
360 functor(primnum, primstartrow, nedgecols,
row+1-primstartrow,
false);
389 functor(primnum, primstartrow, nedgecols, nedgerows+1-primstartrow,
false);
398 UT_ASSERT_MSG(nedgerows >= 1 && nedgecols >= 1,
"Caller should have switched quads to rows or cols");
407 for (
exint col = 0; col < nedgecols; ++col, ++primnum)
409 functor(primnum,
row, col, 4,
true);
418 for (
exint col = 0; col < nedgecols; ++col, primnum+=2)
420 functor(primnum,
row, col, 3,
true);
421 functor(primnum+1,
row, col, 3,
true);
435 auto &&boundary_quad = [&grid,surface_type,&functor](
exint row,
exint col,
exint &primnum)
440 points[0] = grid.
getPoint(row, col );
441 points[1] = grid.
getPoint(row, col+1);
442 points[2] = grid.
getPoint(row+1, col );
443 points[3] = grid.
getPoint(row+1, col+1);
446 if (points[0] == points[2] || points[1] == points[3])
449 const bool row0_equal = (points[0] == points[1]);
450 const bool row1_equal = (points[2] == points[3]);
451 const bool col0_equal = (points[0] == points[2]);
452 const bool col1_equal = (points[1] == points[3]);
454 if ((row0_equal && row1_equal) || (col0_equal && col1_equal))
457 if (!row0_equal && !row1_equal && !col0_equal && !col1_equal)
462 functor(primnum, row, col, 4,
true);
467 functor(primnum, row, col, 3,
true);
468 functor(primnum+1, row, col, 3,
true);
475 functor(primnum, row, col, 3,
true);
480 for (
exint col = 0; col < nedgecols; ++col)
482 boundary_quad(row, col, primnum);
484 for (row = 1; row < nedgerows-1; ++
row)
487 boundary_quad(row, col, primnum);
492 for (col = 1; col < nedgecols-1; ++col, ++primnum)
494 functor(primnum, row, col, 4,
true);
499 for (col = 1; col < nedgecols-1; ++col, primnum+=2)
501 functor(primnum, row, col, 3,
true);
502 functor(primnum+1, row, col, 3,
true);
506 boundary_quad(row, col, primnum);
508 for (
exint col = 0; col < nedgecols; ++col)
510 boundary_quad(row, col, primnum);
516 template<
typename INT_TYPE,
typename FUNCTOR>
528 if (nedgerows < 0 || nedgecols < 0)
549 for (
exint col = 0; col < nedgecols; ++col)
551 functor(vtxnum,
row, col,
false,
false, primnum, vtxnum);
557 functor(vtxnum,
row, nedgecols-1,
false,
true, primnum, vtxnum);
564 for (
exint col = 0; col < nedgecols; ++col)
566 functor(vtxnum, nedgerows-1, col,
true,
false, primnum, vtxnum);
572 functor(vtxnum, nedgerows-1, nedgecols-1,
true,
true, primnum, vtxnum);
588 functor(vtxnum, 0, 0,
false,
false, primnum, 0);
595 for (
exint col = 0; col < nedgecols; ++col, ++vtxnum)
596 functor(vtxnum, 0, col,
false,
false, primnum, col);
601 functor(vtxnum, 0, nedgecols-1,
false,
true, primnum, nedgecols);
614 functor(vtxnum, 0, 0,
false,
false, primnum, 0);
621 for (
exint col = 0; col < nedgecols; ++col, ++vtxnum, ++primnum)
622 functor(vtxnum, 0, col,
false,
false, primnum, 0);
627 functor(vtxnum, 0, nedgecols-1,
false,
true, primnum, 0);
643 functor(vtxnum,
row, 0,
false,
false, primnum, 0);
648 functor(vtxnum, nedgerows-1, 0,
true,
false, primnum, 0);
659 functor(vtxnum,
row, 0,
false,
false, primnum,
row);
664 functor(vtxnum, nedgerows-1, 0,
true,
false, primnum, nedgerows);
679 for (
exint col = 0; col < nedgecols; ++col, ++vtxnum)
680 functor(vtxnum,
row, col,
false,
false, primnum, col);
685 functor(vtxnum,
row, nedgecols-1,
false,
true, primnum, nedgecols);
695 for (
exint col = 0; col < nedgecols; ++col, col_wraps = next_col_wraps)
698 bool currently_in_a_curve = (primvtx != 0);
699 if (!currently_in_a_curve)
701 if (col_wraps && next_col_wraps)
717 functor(vtxnum, nedgerows-1, col,
true,
false, primnum, 0);
721 else if (col_wraps && next_col_wraps)
725 functor(vtxnum, nedgerows-1, col,
true,
false, primnum, primvtx);
740 functor(vtxnum, nedgerows-1, col,
true,
false, primnum, primvtx);
755 functor(vtxnum, nedgerows-1, nedgecols-1,
true,
true, primnum, primvtx);
769 for (
exint col = first_col; col < nedgecols; ++col, ++primnum)
772 functor(vtxnum,
row, col,
false,
false, primnum,
row);
777 functor(vtxnum, nedgerows-1, col,
true,
false, primnum, nedgerows);
787 for (
exint row = 0;
row < nedgerows; ++
row, row_wraps = next_row_wraps)
790 bool currently_in_a_curve = (primvtx != 0);
791 if (!currently_in_a_curve)
793 if (row_wraps && next_row_wraps)
809 functor(vtxnum,
row, nedgecols-1,
false,
true, primnum, 0);
813 else if (row_wraps && next_row_wraps)
817 functor(vtxnum,
row, nedgecols-1,
false,
true, primnum, primvtx);
832 functor(vtxnum,
row, nedgecols-1,
false,
true, primnum, primvtx);
847 functor(vtxnum, nedgerows-1, nedgecols-1,
true,
true, primnum, primvtx);
859 UT_ASSERT_MSG(nedgerows >= 1 && nedgecols >= 1,
"Caller should have switched quads to rows or cols");
867 for (
exint col = 0; col < nedgecols; ++col, ++primnum, vtxnum+=4)
869 functor(vtxnum ,
row, col,
false,
false, primnum, 0);
870 functor(vtxnum+1,
row, col,
false,
true, primnum, 1);
871 functor(vtxnum+2,
row, col,
true,
true, primnum, 2);
872 functor(vtxnum+3,
row, col,
true,
false, primnum, 3);
881 for (
exint col = 0; col < nedgecols; ++col, primnum+=2, vtxnum+=6)
884 const bool switched = (rev || (alt && ((
row^col)&1)));
886 functor(vtxnum ,
row, col,
false,
false, primnum , 0);
887 functor(vtxnum+1,
row, col,
false,
true, primnum , 1);
888 functor(vtxnum+2,
row, col,
true, !switched, primnum , 2);
890 functor(vtxnum+3,
row, col,
false, switched, primnum+1, 0);
891 functor(vtxnum+4,
row, col,
true,
true, primnum+1, 1);
892 functor(vtxnum+5,
row, col,
true,
false, primnum+1, 2);
906 auto &&boundary_quad = [&grid,surface_type,&functor,rev,alt](
exint &vtxnum,
exint row,
exint col,
exint &primnum)
911 points[0] = grid.
getPoint(row, col );
912 points[1] = grid.
getPoint(row, col+1);
913 points[2] = grid.
getPoint(row+1, col );
914 points[3] = grid.
getPoint(row+1, col+1);
917 if (points[0] == points[2] || points[1] == points[3])
920 const bool row0_equal = (points[0] == points[1]);
921 const bool row1_equal = (points[2] == points[3]);
922 const bool col0_equal = (points[0] == points[2]);
923 const bool col1_equal = (points[1] == points[3]);
925 if ((row0_equal && row1_equal) || (col0_equal && col1_equal))
928 if (!row0_equal && !row1_equal && !col0_equal && !col1_equal)
933 functor(vtxnum , row, col,
false,
false, primnum, 0);
934 functor(vtxnum+1, row, col,
false,
true, primnum, 1);
935 functor(vtxnum+2, row, col,
true,
true, primnum, 2);
936 functor(vtxnum+3, row, col,
true,
false, primnum, 3);
943 const bool switched = (rev || (alt && ((row^col)&1)));
945 functor(vtxnum , row, col,
false,
false, primnum , 0);
946 functor(vtxnum+1, row, col,
false,
true, primnum , 1);
947 functor(vtxnum+2, row, col,
true, !switched, primnum , 2);
949 functor(vtxnum+3, row, col,
false, switched, primnum+1, 0);
950 functor(vtxnum+4, row, col,
true,
true, primnum+1, 1);
951 functor(vtxnum+5, row, col,
true,
false, primnum+1, 2);
959 functor(vtxnum, row, col,
false,
false, primnum, vtxnum);
963 functor(vtxnum, row, col,
false,
true, primnum, vtxnum);
966 if (!row1_equal && !col1_equal)
968 functor(vtxnum, row, col,
true,
true, primnum, vtxnum);
973 functor(vtxnum, row, col,
true,
false, primnum, vtxnum);
980 for (
exint col = 0; col < nedgecols; ++col)
982 boundary_quad(vtxnum, row, col, primnum);
984 for (row = 1; row < nedgerows-1; ++
row)
987 boundary_quad(vtxnum, row, col, primnum);
992 for (col = 1; col < nedgecols-1; ++col, ++primnum, vtxnum+=4)
994 functor(vtxnum , row, col,
false,
false, primnum, 0);
995 functor(vtxnum+1, row, col,
false,
true, primnum, 1);
996 functor(vtxnum+2, row, col,
true,
true, primnum, 2);
997 functor(vtxnum+3, row, col,
true,
false, primnum, 3);
1002 for (col = 1; col < nedgecols-1; ++col, primnum+=2, vtxnum+=6)
1005 const bool switched = (rev || (alt && ((row^col)&1)));
1007 functor(vtxnum , row, col,
false,
false, primnum , 0);
1008 functor(vtxnum+1, row, col,
false,
true, primnum , 1);
1009 functor(vtxnum+2, row, col,
true, !switched, primnum , 2);
1011 functor(vtxnum+3, row, col,
false, switched, primnum+1, 0);
1012 functor(vtxnum+4, row, col,
true,
true, primnum+1, 1);
1013 functor(vtxnum+5, row, col,
true,
false, primnum+1, 2);
1017 boundary_quad(vtxnum, row, col, primnum);
1019 for (
exint col = 0; col < nedgecols; ++col)
1021 boundary_quad(vtxnum, row, col, primnum);
1025 template<
typename INT_TYPE>
1028 const exint nedgerows = myNumEdgeRows;
1029 const exint nedgecols = myNumEdgeCols;
1030 if (nedgerows < 0 || nedgecols < 0 || (nedgerows == 0 && nedgecols == 0))
1040 const bool wrapu = (myCorners[0] == myCorners[1]);
1049 const bool wrapv = (myCorners[0] == myCorners[2]);
1057 bool wrapu0 = (myCorners[0] == myCorners[1]);
1058 bool wrapu1 = (myCorners[2] == myCorners[3]);
1059 bool has_wrapu = wrapu0 || wrapu1;
1060 bool has_notwrapu = !wrapu0 || !wrapu1;
1062 bool wrapv0 = (myCorners[0] == myCorners[2]);
1063 bool wrapv1 = (myCorners[1] == myCorners[3]);
1064 bool has_wrapv = wrapv0 || wrapv1;
1065 bool has_notwrapv = !wrapv0 || !wrapv1;
1067 if ((myCol0Start < INT_TYPE(0)) || (myCol1Start < INT_TYPE(0)) || (myCol0Step != myCol1Step))
1070 for (
exint rowm1 = 0; rowm1 < nedgerows-1; ++rowm1)
1072 INT_TYPE pt0 = (myCol0Start < INT_TYPE(0)) ? myCol0Array[rowm1] : (myCol0Start + myCol0Step*rowm1);
1073 INT_TYPE pt1 = (myCol1Start < INT_TYPE(0)) ? myCol1Array[rowm1] : (myCol1Start + myCol1Step*rowm1);
1074 bool wrapu = (pt0 == pt1);
1076 has_notwrapu |= !wrapu;
1082 bool wrapu = (myCol0Start == myCol1Start);
1084 has_notwrapu |= !wrapu;
1087 if ((myRow0Start < INT_TYPE(0)) || (myRow1Start < INT_TYPE(0)) || (myRow0Step != myRow1Step))
1090 for (
exint colm1 = 0; colm1 < nedgecols-1; ++colm1)
1092 INT_TYPE pt0 = (myRow0Start < INT_TYPE(0)) ? myRow0Array[colm1] : (myRow0Start + myRow0Step*colm1);
1093 INT_TYPE pt1 = (myRow1Start < INT_TYPE(0)) ? myRow1Array[colm1] : (myRow1Start + myRow1Step*colm1);
1094 bool wrapv = (pt0 == pt1);
1096 has_notwrapv |= !wrapv;
1102 bool wrapv = (myRow0Start == myRow1Start);
1104 has_notwrapv |= !wrapv;
1107 myAllWrapU = !has_notwrapu;
1108 myAllWrapV = !has_notwrapv;
1109 myNoWrapU = !has_wrapu;
1110 myNoWrapV = !has_wrapv;
1113 template<
typename INT_TYPE>
1115 exint nedgerows,
exint nedgecols, INT_TYPE start_pt)
1119 myNumEdgeRows = nedgerows;
1120 myNumEdgeCols = nedgecols;
1129 myCorners[0] = start_pt;
1130 myCorners[1] = start_pt + nedgecols;
1131 myCorners[2] = start_pt + nedgerows*(nedgecols+1);
1132 myCorners[3] = start_pt + nedgerows*(nedgecols+1) + nedgecols;
1134 myRow0Step = INT_TYPE(1);
1135 myRow0Start = myCorners[0]+myRow0Step;
1136 myRow1Step = INT_TYPE(1);
1137 myRow1Start = myCorners[2]+myRow1Step;
1139 myCol0Step = INT_TYPE(nedgecols+1);
1140 myCol0Start = myCorners[0]+myCol0Step;
1141 myCol1Step = INT_TYPE(nedgecols+1);
1142 myCol1Start = myCorners[1]+myCol1Step;
1144 myMiddleStart = myCol0Start+1;
1145 myMiddleColStep = myRow0Step;
1146 myMiddleRowStep = myCol0Step;
1150 myNumPrimitives = 0;
1158 myNumPrimitives = 1;
1165 const bool has_endrow = myNoWrapV || myUnrollCurves;
1166 const bool has_endcol = myNoWrapU || myUnrollCurves;
1167 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1168 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1169 myNumVertices = nvtxrows*nvtxcols;
1175 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1176 myNumVertices = 4*myNumPrimitives;
1181 myNumPrimitives = 0;
1185 myNumPrimitives = myNumEdgeRows-1 +
exint(myFirstRowIfNotWrapped) +
exint(myLastRowIfNotWrapped);
1186 myNumVertices = myNumPrimitives*(myNumEdgeCols+1);
1192 exint col_polys = myNumEdgeCols-1 +
exint(myFirstColIfNotWrapped) +
exint(myLastColIfNotWrapped);
1193 myNumPrimitives += col_polys;
1194 myNumVertices += col_polys*(myNumEdgeRows+1);
1199 myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
1200 myNumVertices = 3*myNumPrimitives;
1203 template<
typename INT_TYPE>
1205 exint nedgerows,
exint nedgecols, INT_TYPE start_pt)
1209 myNumEdgeRows = nedgerows;
1210 myNumEdgeCols = nedgecols;
1219 myCorners[0] = start_pt;
1220 myCorners[1] = myCorners[0];
1221 myCorners[2] = start_pt + nedgerows*nedgecols;
1222 myCorners[3] = myCorners[2];
1224 myRow0Step = INT_TYPE(1);
1225 myRow0Start = myCorners[0]+myRow0Step;
1226 myRow1Step = INT_TYPE(1);
1227 myRow1Start = myCorners[2]+myRow1Step;
1229 myCol0Step = INT_TYPE(nedgecols);
1230 myCol0Start = myCorners[0]+myCol0Step;
1231 myCol1Step = INT_TYPE(nedgecols);
1232 myCol1Start = myCorners[1]+myCol1Step;
1234 myMiddleStart = myCol0Start+1;
1235 myMiddleColStep = myRow0Step;
1236 myMiddleRowStep = myCol0Step;
1240 myNumPrimitives = 0;
1248 myNumPrimitives = 1;
1255 const bool has_endrow = myNoWrapV || myUnrollCurves;
1256 const bool has_endcol = myNoWrapU || myUnrollCurves;
1257 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1258 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1259 myNumVertices = nvtxrows*nvtxcols;
1265 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1266 myNumVertices = 4*myNumPrimitives;
1271 myNumPrimitives = 0;
1275 myNumPrimitives = myNumEdgeRows-1 +
exint(myFirstRowIfNotWrapped) +
exint(myLastRowIfNotWrapped);
1276 myNumVertices = myNumPrimitives*(myNumEdgeCols+myUnrollCurves);
1282 myNumPrimitives += myNumEdgeCols;
1283 myNumVertices += myNumEdgeCols*(myNumEdgeRows+1);
1288 myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
1289 myNumVertices = 3*myNumPrimitives;
1292 template<
typename INT_TYPE>
1294 exint nedgerows,
exint nedgecols, INT_TYPE start_pt)
1298 myNumEdgeRows = nedgerows;
1299 myNumEdgeCols = nedgecols;
1308 myCorners[0] = start_pt;
1309 myCorners[1] = start_pt + nedgecols;
1310 myCorners[2] = myCorners[0];
1311 myCorners[3] = myCorners[1];
1313 myRow0Step = INT_TYPE(1);
1314 myRow0Start = myCorners[0]+myRow0Step;
1315 myRow1Step = INT_TYPE(1);
1316 myRow1Start = myCorners[2]+myRow1Step;
1318 myCol0Step = INT_TYPE(nedgecols+1);
1319 myCol0Start = myCorners[0]+myCol0Step;
1320 myCol1Step = INT_TYPE(nedgecols+1);
1321 myCol1Start = myCorners[1]+myCol1Step;
1323 myMiddleStart = myCol0Start+1;
1324 myMiddleColStep = myRow0Step;
1325 myMiddleRowStep = myCol0Step;
1329 myNumPrimitives = 0;
1337 myNumPrimitives = 1;
1344 const bool has_endrow = myNoWrapV || myUnrollCurves;
1345 const bool has_endcol = myNoWrapU || myUnrollCurves;
1346 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1347 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1348 myNumVertices = nvtxrows*nvtxcols;
1354 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1355 myNumVertices = 4*myNumPrimitives;
1360 myNumPrimitives = 0;
1364 myNumPrimitives = myNumEdgeRows;
1365 myNumVertices = myNumPrimitives*(myNumEdgeCols+1);
1371 exint col_polys = myNumEdgeCols-1 +
exint(myFirstColIfNotWrapped) +
exint(myLastColIfNotWrapped);
1372 myNumPrimitives += col_polys;
1373 myNumVertices += col_polys*(myNumEdgeRows+myUnrollCurves);
1378 myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
1379 myNumVertices = 3*myNumPrimitives;
1382 template<
typename INT_TYPE>
1385 INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
1389 myNumEdgeRows = nedgerows;
1390 myNumEdgeCols = nedgecols;
1399 myCorners[0] = start_pt;
1400 myCorners[1] = myCorners[0];
1401 myCorners[2] = end_pt;
1402 myCorners[3] = myCorners[2];
1404 myRow0Step = INT_TYPE(0);
1405 myRow0Start = start_pt;
1406 myRow1Step = INT_TYPE(0);
1407 myRow1Start = end_pt;
1409 myCol0Step = INT_TYPE(nedgecols);
1410 myCol0Start = start_mid_pt;
1411 myCol1Step = INT_TYPE(nedgecols);
1412 myCol1Start = start_mid_pt;
1414 myMiddleStart = myCol0Start+1;
1415 myMiddleColStep = INT_TYPE(1);
1416 myMiddleRowStep = INT_TYPE(nedgecols);
1420 myNumPrimitives = 0;
1428 myNumPrimitives = 1;
1435 const bool has_endrow = myNoWrapV || myUnrollCurves;
1436 const bool has_endcol = myNoWrapU || myUnrollCurves;
1437 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1438 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1439 myNumVertices = nvtxrows*nvtxcols;
1445 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1446 myNumVertices = 4*myNumPrimitives - (myTriangularPoles ? 2*myNumEdgeCols : 0);
1451 myNumPrimitives = 0;
1455 const exint rowprims = myNumEdgeRows-1 +
exint(myFirstRowIfNotWrapped) +
exint(myLastRowIfNotWrapped);
1456 myNumPrimitives = rowprims;
1457 myNumVertices = rowprims*(myNumEdgeCols+myUnrollCurves);
1463 myNumPrimitives += myNumEdgeCols;
1464 myNumVertices += myNumEdgeCols*(myNumEdgeRows+1);
1469 myNumPrimitives = (myNumEdgeRows -
exint(myTriangularPoles))*2*myNumEdgeCols;
1470 myNumVertices = 3*myNumPrimitives;
1473 template<
typename INT_TYPE>
1476 INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
1480 myNumEdgeRows = nedgerows;
1481 myNumEdgeCols = nedgecols;
1490 myCorners[0] = start_pt;
1491 myCorners[1] = end_pt;
1492 myCorners[2] = start_pt;
1493 myCorners[3] = end_pt;
1495 myRow0Step = INT_TYPE(1);
1496 myRow0Start = start_mid_pt;
1497 myRow1Step = INT_TYPE(1);
1498 myRow1Start = start_mid_pt;
1500 myCol0Step = INT_TYPE(0);
1501 myCol0Start = start_pt;
1502 myCol1Step = INT_TYPE(0);
1503 myCol1Start = end_pt;
1505 myMiddleStart = myRow0Start+nedgecols-1;
1506 myMiddleColStep = INT_TYPE(1);
1507 myMiddleRowStep = INT_TYPE(nedgecols-1);
1511 myNumPrimitives = 0;
1519 myNumPrimitives = 1;
1526 const bool has_endrow = myNoWrapV || myUnrollCurves;
1527 const bool has_endcol = myNoWrapU || myUnrollCurves;
1528 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1529 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1530 myNumVertices = nvtxrows*nvtxcols;
1536 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1537 myNumVertices = 4*myNumPrimitives - (myTriangularPoles ? 2*myNumEdgeRows : 0);
1542 myNumPrimitives = 0;
1546 myNumPrimitives = myNumEdgeRows;
1547 myNumVertices = myNumEdgeRows*(myNumEdgeCols+1);
1553 const exint colprims = myNumEdgeCols-1 +
exint(myFirstColIfNotWrapped) +
exint(myLastColIfNotWrapped);
1554 myNumPrimitives += colprims;
1555 myNumVertices += colprims*(myNumEdgeRows+myUnrollCurves);
1560 myNumPrimitives = myNumEdgeRows*2*(myNumEdgeCols -
exint(myTriangularPoles));
1561 myNumVertices = 3*myNumPrimitives;
1564 template<
typename INT_TYPE>
1567 INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
1571 myNumEdgeRows = nedgerows;
1572 myNumEdgeCols = nedgecols;
1581 myCorners[0] = start_pt;
1582 myCorners[1] = myCorners[0];
1583 myCorners[2] = end_pt;
1584 myCorners[3] = myCorners[2];
1586 myRow0Step = INT_TYPE(0);
1587 myRow0Start = start_pt;
1588 myRow1Step = INT_TYPE(0);
1589 myRow1Start = end_pt;
1591 myCol0Step = INT_TYPE(nedgecols+1);
1592 myCol0Start = start_mid_pt;
1593 myCol1Step = INT_TYPE(nedgecols+1);
1594 myCol1Start = start_mid_pt+nedgecols;
1596 myMiddleStart = myCol0Start+1;
1597 myMiddleColStep = INT_TYPE(1);
1598 myMiddleRowStep = INT_TYPE(nedgecols+1);
1602 myNumPrimitives = 0;
1610 myNumPrimitives = 1;
1617 const bool has_endrow = myNoWrapV || myUnrollCurves;
1618 const bool has_endcol = myNoWrapU || myUnrollCurves;
1619 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1620 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1621 myNumVertices = nvtxrows*nvtxcols;
1627 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1628 myNumVertices = 4*myNumPrimitives - (myTriangularPoles ? 2*myNumEdgeCols : 0);
1633 myNumPrimitives = 0;
1637 const exint rowprims = myNumEdgeRows-1 +
exint(myFirstRowIfNotWrapped) +
exint(myLastRowIfNotWrapped);
1638 myNumPrimitives = rowprims;
1639 myNumVertices = rowprims*(myNumEdgeCols+1);
1645 myNumPrimitives += myNumEdgeCols-1 +
exint(myFirstColIfNotWrapped) +
exint(myLastColIfNotWrapped);
1646 myNumVertices += (myNumEdgeCols+1)*(myNumEdgeRows+1);
1651 myNumPrimitives = (myNumEdgeRows -
exint(myTriangularPoles))*2*myNumEdgeCols;
1652 myNumVertices = 3*myNumPrimitives;
1655 template<
typename INT_TYPE>
1657 exint nedgerows,
exint nedgecols, INT_TYPE start_pt)
1661 myNumEdgeRows = nedgerows;
1662 myNumEdgeCols = nedgecols;
1671 myCorners[0] = start_pt;
1672 myCorners[1] = start_pt;
1673 myCorners[2] = start_pt;
1674 myCorners[3] = start_pt;
1676 myRow0Step = INT_TYPE(1);
1677 myRow0Start = myCorners[0]+myRow0Step;
1678 myRow1Step = INT_TYPE(1);
1679 myRow1Start = myCorners[2]+myRow1Step;
1681 myCol0Step = INT_TYPE(nedgecols);
1682 myCol0Start = myCorners[0]+myCol0Step;
1683 myCol1Step = INT_TYPE(nedgecols);
1684 myCol1Start = myCorners[1]+myCol1Step;
1686 myMiddleStart = myCol0Start+1;
1687 myMiddleColStep = myRow0Step;
1688 myMiddleRowStep = myCol0Step;
1692 myNumPrimitives = 0;
1700 myNumPrimitives = 1;
1707 const bool has_endrow = myNoWrapV || myUnrollCurves;
1708 const bool has_endcol = myNoWrapU || myUnrollCurves;
1709 const exint nvtxrows = myNumEdgeRows +
exint(has_endrow);
1710 const exint nvtxcols = myNumEdgeCols +
exint(has_endcol);
1711 myNumVertices = nvtxrows*nvtxcols;
1717 myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
1718 myNumVertices = 4*myNumPrimitives;
1723 myNumPrimitives = 0;
1727 myNumPrimitives = myNumEdgeRows;
1728 myNumVertices = myNumPrimitives*(myNumEdgeCols+myUnrollCurves);
1734 myNumPrimitives += myNumEdgeCols;
1735 myNumVertices += myNumEdgeCols*(myNumEdgeRows+myUnrollCurves);
1740 myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
1741 myNumVertices = 3*myNumPrimitives;
INT_TYPE getPoint(exint row, exint col) const
void initTorus(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0))
GLdouble GLdouble GLint GLint const GLdouble * points
PrimitiveType myPrimitiveType
GEO_SurfaceType mySurfaceType
void initSplitColSphere(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0), INT_TYPE end_pt=INT_TYPE(1), INT_TYPE start_mid_pt=INT_TYPE(2))
bool myFirstColIfNotWrapped
bool doesColWrap(exint col) const
void initColSphere(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0), INT_TYPE end_pt=INT_TYPE(1), INT_TYPE start_mid_pt=INT_TYPE(2))
#define UT_ASSERT_MSG(ZZ,...)
void GUiterateGridVertices(const GU_GridT< INT_TYPE > &grid, FUNCTOR &&functor)
void initRowTube(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0))
void initRowSphere(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0), INT_TYPE end_pt=INT_TYPE(1), INT_TYPE start_mid_pt=INT_TYPE(2))
void initSingleGrid(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0))
bool myLastRowIfNotWrapped
PrimitiveType myPrimitiveType
void initColTube(exint nedgerows, exint nedgecols, INT_TYPE start_pt=INT_TYPE(0))
bool myLastColIfNotWrapped
bool myFirstRowIfNotWrapped
bool isInvalidTPSurf() const
GLenum GLenum GLsizei void * row
void GUiterateGridPrimitives(const GU_GridT< INT_TYPE > &grid, FUNCTOR &&functor)
bool doesRowWrap(exint row) const
void GUiterateGridPoints(const GU_GridT< INT_TYPE > &grid, FUNCTOR &&functor)