813 const int coarse_face_index)
818 const int ptex_face_inner_resolution = ptex_face_resolution - 2;
819 const int num_inner_vertices_per_ptex = (ptex_face_resolution - 1) * (ptex_face_resolution - 2);
820 const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
823 const int start_vert_index = center_vert_index + 1;
826 for (
int corner = 0; corner < coarse_face.
size(); corner++) {
827 const int start_ptex_face_vert_index = start_vert_index + corner * num_inner_vertices_per_ptex;
833 start_ptex_face_vert_index,
834 ptex_face_inner_resolution + 1);
835 for (
int row = 0; row < ptex_face_inner_resolution - 1; row++) {
836 const int start_row_vert_index = start_ptex_face_vert_index +
837 row * (ptex_face_inner_resolution + 1);
843 start_row_vert_index,
844 ptex_face_inner_resolution + 1);
849 start_row_vert_index +
850 ptex_face_inner_resolution + 1,
851 ptex_face_inner_resolution + 1);
855 for (
int corner = 0; corner < coarse_face.
size(); corner++) {
856 const int next_corner = (corner + 1) % coarse_face.
size();
857 int current_patch_vert_index = start_vert_index + corner * num_inner_vertices_per_ptex +
858 ptex_face_inner_resolution;
859 int next_path_vert_index = start_vert_index + next_corner * num_inner_vertices_per_ptex +
860 num_inner_vertices_per_ptex - ptex_face_resolution + 1;
861 for (
int row = 0; row < ptex_face_inner_resolution; row++, subdiv_edge_index++) {
862 const int v1 = current_patch_vert_index;
863 const int v2 = next_path_vert_index;
866 current_patch_vert_index += ptex_face_inner_resolution + 1;
867 next_path_vert_index += 1;
871 if (ptex_face_resolution >= 3) {
872 for (
int corner = 0; corner < coarse_face.
size(); corner++, subdiv_edge_index++) {
873 const int current_patch_end_vert_index = start_vert_index +
874 corner * num_inner_vertices_per_ptex +
875 num_inner_vertices_per_ptex - 1;
876 const int v1 = center_vert_index;
877 const int v2 = current_patch_end_vert_index;
883 int prev_corner = coarse_face.
size() - 1;
884 for (
int corner = 0; corner < coarse_face.
size(); corner++) {
891 coarse_edge_i * num_subdiv_vertices_per_coarse_edge;
892 const bool flip = (coarse_edge[1] == coarse_vert);
893 int side_start_index;
894 if (ptex_face_resolution >= 3) {
895 side_start_index = start_vert_index + num_inner_vertices_per_ptex * corner;
898 side_start_index = center_vert_index;
900 for (
int i = 0; i < ptex_face_resolution - 1; i++, subdiv_edge_index++) {
901 const int v1 = (flip) ? (start_edge_vert + (resolution - i - 3)) : (start_edge_vert + i);
902 const int v2 = side_start_index + i;
907 if (ptex_face_resolution >= 3) {
910 coarse_prev_edge * num_subdiv_vertices_per_coarse_edge;
911 const bool flip = (coarse_edge[1] == coarse_vert);
912 int side_start_index = start_vert_index + num_inner_vertices_per_ptex * corner;
913 for (
int i = 0; i < ptex_face_resolution - 2; i++, subdiv_edge_index++) {
914 const int v1 = (flip) ? (start_edge_vert + (resolution - i - 3)) : (start_edge_vert + i);
915 const int v2 = side_start_index + (ptex_face_inner_resolution + 1) * i;
920 prev_corner = corner;
1070 const int coarse_face_index)
1076 const int ptex_inner_resolution = ptex_resolution - 2;
1077 const int num_subdiv_edges_per_coarse_edge = resolution - 1;
1078 const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
1079 const float inv_ptex_resolution_1 = 1.0f /
float(ptex_resolution - 1);
1085 const int start_loop_index = 4 * start_face_index;
1086 const float du = inv_ptex_resolution_1;
1087 const float dv = inv_ptex_resolution_1;
1089 int subdiv_loop_index = start_loop_index;
1091 for (
int y = 1;
y < ptex_resolution - 2;
y++) {
1092 const float v =
y * inv_ptex_resolution_1;
1093 const int inner_y =
y - 1;
1094 for (
int x = 1;
x < ptex_resolution - 2;
x++, subdiv_loop_index += 4) {
1095 const int inner_x =
x - 1;
1096 const float u =
x * inv_ptex_resolution_1;
1098 const int v0 = start_vert_index + (inner_y * ptex_inner_resolution + inner_x);
1099 const int v1 = v0 + 1;
1100 const int v2 = v0 + ptex_inner_resolution + 1;
1101 const int v3 = v0 + ptex_inner_resolution;
1103 const int e0 = start_edge_index + (inner_y * (2 * ptex_inner_resolution - 1) + inner_x);
1104 const int e1 = e0 + ptex_inner_resolution;
1105 const int e2 = e0 + (2 * ptex_inner_resolution - 1);
1106 const int e3 = e0 + ptex_inner_resolution - 1;
1130 int prev_corner_index = coarse_face.
size() - 1;
1131 for (
int corner = 0; corner < coarse_face.
size(); corner++) {
1140 coarse_edge_i * num_subdiv_vertices_per_coarse_edge;
1141 const bool flip = (coarse_edge[1] == coarse_vert);
1142 int side_start_index = start_vert_index;
1143 int side_stride = 0;
1146 int e2_offset, e2_stride;
1147 float u,
v, delta_u, delta_v;
1148 if (coase_prev_vert == prev_coarse_edge[0]) {
1150 num_subdiv_vertices_per_coarse_edge - 1;
1152 num_subdiv_edges_per_coarse_edge - 1;
1168 else if (corner == 1) {
1169 side_start_index += resolution - 3;
1170 side_stride = resolution - 2;
1171 e2_offset = 2 * num_subdiv_edges_per_coarse_edge - 4;
1172 e2_stride = 2 * num_subdiv_edges_per_coarse_edge - 3;
1178 else if (corner == 2) {
1179 side_start_index += num_subdiv_vertices_per_coarse_edge *
1180 num_subdiv_vertices_per_coarse_edge -
1190 else if (corner == 3) {
1191 side_start_index += num_subdiv_vertices_per_coarse_edge *
1192 (num_subdiv_vertices_per_coarse_edge - 1);
1193 side_stride = -(resolution - 2);
1195 (2 * num_subdiv_edges_per_coarse_edge - 3);
1196 e2_stride = -(2 * num_subdiv_edges_per_coarse_edge - 3);
1202 for (
int i = 0; i < resolution - 2; i++, subdiv_loop_index += 4) {
1205 v1 = start_edge_vert + (resolution - i - 3);
1208 v1 = start_edge_vert + i;
1210 const int v2 = side_start_index + side_stride * i;
1214 num_subdiv_edges_per_coarse_edge - i - 1;
1220 corner * num_subdiv_vertices_per_coarse_edge + i;
1224 ((corner - 1 + coarse_face.
size()) % coarse_face.
size()) *
1225 num_subdiv_vertices_per_coarse_edge +
1226 num_subdiv_vertices_per_coarse_edge - 1;
1229 e2 = start_edge_index + e2_offset + e2_stride * (i - 1);
1232 const float loop_u = u + delta_u * i;
1233 const float loop_v =
v + delta_v * i;
1258 prev_corner_index = corner;
1264 const int coarse_face_index)
1270 const int ptex_face_inner_resolution = ptex_face_resolution - 2;
1271 const float inv_ptex_resolution_1 = 1.0f /
float(ptex_face_resolution - 1);
1272 const int num_inner_vertices_per_ptex = (ptex_face_resolution - 1) * (ptex_face_resolution - 2);
1274 ptex_face_inner_resolution + 1);
1275 const int num_subdiv_vertices_per_coarse_edge = resolution - 2;
1276 const int num_subdiv_edges_per_coarse_edge = resolution - 1;
1280 const int start_vert_index = center_vert_index + 1;
1281 const int start_inner_vert_index = center_vert_index + 1;
1284 const int start_loop_index = 4 * start_face_index;
1285 const float du = inv_ptex_resolution_1;
1286 const float dv = inv_ptex_resolution_1;
1288 int subdiv_loop_index = start_loop_index;
1289 for (
int corner = 0; corner < coarse_face.
size(); corner++) {
1290 const int corner_vert_index = start_vert_index + corner * num_inner_vertices_per_ptex;
1291 const int corner_edge_index = start_edge_index + corner * num_inner_edges_per_ptex_face;
1292 for (
int y = 1;
y < ptex_face_inner_resolution;
y++) {
1293 const float v =
y * inv_ptex_resolution_1;
1294 const int inner_y =
y - 1;
1295 for (
int x = 1;
x < ptex_face_inner_resolution + 1;
x++, subdiv_loop_index += 4) {
1296 const int inner_x =
x - 1;
1297 const float u =
x * inv_ptex_resolution_1;
1299 const int v0 = corner_vert_index + (inner_y * (ptex_face_inner_resolution + 1) + inner_x);
1300 const int v1 = v0 + 1;
1301 const int v2 = v0 + ptex_face_inner_resolution + 2;
1302 const int v3 = v0 + ptex_face_inner_resolution + 1;
1304 const int e0 = corner_edge_index +
1305 (inner_y * (2 * ptex_face_inner_resolution + 1) + inner_x);
1306 const int e1 = e0 + ptex_face_inner_resolution + 1;
1307 const int e2 = e0 + (2 * ptex_face_inner_resolution + 1);
1308 const int e3 = e0 + ptex_face_inner_resolution;
1312 ptex_face_index + corner,
1332 for (
int corner = 0; corner < coarse_face.
size(); corner++) {
1333 const int next_corner = (corner + 1) % coarse_face.
size();
1334 const int corner_edge_index = start_edge_index + corner * num_inner_edges_per_ptex_face;
1335 const int next_corner_edge_index = start_edge_index +
1336 next_corner * num_inner_edges_per_ptex_face;
1337 int current_patch_vert_index = start_inner_vert_index + corner * num_inner_vertices_per_ptex +
1338 ptex_face_inner_resolution;
1339 int next_path_vert_index = start_inner_vert_index + next_corner * num_inner_vertices_per_ptex +
1340 num_inner_vertices_per_ptex - ptex_face_resolution + 1;
1341 int v0 = current_patch_vert_index;
1342 int v1 = next_path_vert_index;
1343 current_patch_vert_index += ptex_face_inner_resolution + 1;
1344 next_path_vert_index += 1;
1345 int e0 = start_edge_index + coarse_face.
size() * num_inner_edges_per_ptex_face +
1346 corner * (ptex_face_resolution - 2);
1347 int e1 = next_corner_edge_index + num_inner_edges_per_ptex_face - ptex_face_resolution + 2;
1348 int e3 = corner_edge_index + 2 * ptex_face_resolution - 4;
1349 for (
int row = 1; row < ptex_face_inner_resolution; row++, subdiv_loop_index += 4) {
1350 const int v2 = next_path_vert_index;
1351 const int v3 = current_patch_vert_index;
1352 const int e2 = e0 + 1;
1353 const float u = row * du;
1354 const float v = 1.0f - dv;
1358 ptex_face_index + next_corner,
1374 current_patch_vert_index += ptex_face_inner_resolution + 1;
1375 next_path_vert_index += 1;
1380 e3 += 2 * ptex_face_resolution - 3;
1384 if (ptex_face_resolution >= 3) {
1385 const int start_center_edge_index = start_edge_index + (num_inner_edges_per_ptex_face +
1386 ptex_face_inner_resolution) *
1388 const int start_boundary_edge = start_edge_index +
1389 coarse_face.
size() * num_inner_edges_per_ptex_face +
1390 ptex_face_inner_resolution - 1;
1391 for (
int corner = 0, prev_corner = coarse_face.
size() - 1; corner < coarse_face.
size();
1392 prev_corner = corner, corner++, subdiv_loop_index += 4)
1394 const int corner_edge_index = start_edge_index + corner * num_inner_edges_per_ptex_face;
1395 const int current_patch_end_vert_index = start_vert_index +
1396 corner * num_inner_vertices_per_ptex +
1397 num_inner_vertices_per_ptex - 1;
1398 const int prev_current_patch_end_vert_index = start_vert_index +
1399 prev_corner * num_inner_vertices_per_ptex +
1400 num_inner_vertices_per_ptex - 1;
1401 const int v0 = center_vert_index;
1402 const int v1 = prev_current_patch_end_vert_index;
1403 const int v2 = current_patch_end_vert_index - 1;
1404 const int v3 = current_patch_end_vert_index;
1405 const int e0 = start_center_edge_index + prev_corner;
1406 const int e1 = start_boundary_edge + prev_corner * (ptex_face_inner_resolution);
1407 const int e2 = corner_edge_index + num_inner_edges_per_ptex_face - 1;
1408 const int e3 = start_center_edge_index + corner;
1409 const float u = 1.0f - du;
1410 const float v = 1.0f - dv;
1414 ptex_face_index + corner,
1433 for (
int prev_corner = coarse_face.
size() - 1, corner = 0; corner < coarse_face.
size();
1434 prev_corner = corner, corner++)
1443 const bool flip = (coarse_edge[1] == coarse_vert);
1445 coarse_edge_i * num_subdiv_vertices_per_coarse_edge;
1446 const int corner_vert_index = start_vert_index + corner * num_inner_vertices_per_ptex;
1447 const int corner_edge_index = start_edge_index + corner * num_inner_edges_per_ptex_face;
1451 if (coase_prev_vert == prev_coarse_edge[0]) {
1453 num_subdiv_vertices_per_coarse_edge - 1;
1455 num_subdiv_edges_per_coarse_edge - 1;
1461 for (
int i = 0; i <= ptex_face_inner_resolution; i++, subdiv_loop_index += 4) {
1464 v1 = start_edge_vert + (resolution - i - 3);
1467 v1 = start_edge_vert + i;
1470 if (ptex_face_inner_resolution >= 1) {
1471 v2 = corner_vert_index + i;
1474 v2 = center_vert_index;
1479 num_subdiv_edges_per_coarse_edge - i - 1;
1484 int e1 = start_edge_index + corner * (2 * ptex_face_inner_resolution + 1);
1485 if (ptex_face_resolution >= 3) {
1486 e1 += coarse_face.
size() *
1487 (num_inner_edges_per_ptex_face + ptex_face_inner_resolution + 1) +
1491 if (i == 0 && ptex_face_resolution >= 3) {
1492 e2 = start_edge_index +
1493 coarse_face.
size() *
1494 (num_inner_edges_per_ptex_face + ptex_face_inner_resolution + 1) +
1495 corner * (2 * ptex_face_inner_resolution + 1) + ptex_face_inner_resolution + 1;
1497 else if (i == 0 && ptex_face_resolution < 3) {
1498 e2 = start_edge_index + prev_corner * (2 * ptex_face_inner_resolution + 1);
1501 e2 = corner_edge_index + i - 1;
1503 const float u = du * i;
1504 const float v = 0.0f;
1508 ptex_face_index + corner,
1529 const bool flip_prev = (prev_coarse_edge[1] == coarse_vert);
1530 v0 = corner_vert_index;
1531 if (coase_prev_vert == prev_coarse_edge[0]) {
1533 num_subdiv_vertices_per_coarse_edge - 1;
1538 e3 = start_edge_index +
1539 coarse_face.
size() * (num_inner_edges_per_ptex_face + ptex_face_inner_resolution + 1) +
1540 corner * (2 * ptex_face_inner_resolution + 1) + ptex_face_inner_resolution + 1;
1541 for (
int i = 0; i <= ptex_face_inner_resolution - 1; i++, subdiv_loop_index += 4) {
1544 if (i == ptex_face_inner_resolution - 1) {
1545 v1 = start_vert_index + prev_corner * num_inner_vertices_per_ptex +
1546 ptex_face_inner_resolution;
1547 e1 = start_edge_index +
1548 coarse_face.
size() *
1549 (num_inner_edges_per_ptex_face + ptex_face_inner_resolution + 1) +
1550 prev_corner * (2 * ptex_face_inner_resolution + 1) + ptex_face_inner_resolution;
1551 e0 = start_edge_index + coarse_face.
size() * num_inner_edges_per_ptex_face +
1552 prev_corner * ptex_face_inner_resolution;
1555 v1 = v0 + ptex_face_inner_resolution + 1;
1556 e0 = corner_edge_index + ptex_face_inner_resolution +
1557 i * (2 * ptex_face_inner_resolution + 1);
1560 int v2 = flip_prev ? v3 - 1 : v3 + 1;
1564 num_subdiv_edges_per_coarse_edge - 2 - i;
1570 const float u = 0.0f;
1571 const float v = du * (i + 1);
1575 ptex_face_index + corner,