111
112
CCG_USE_AGING = 1,
112
113
CCG_USE_ARENA = 2,
114
CCG_CALC_NORMALS = 4,
115
/* add an extra four bytes for a mask layer */
117
CCG_SIMPLE_SUBDIV = 16
116
static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels, CCGFlags flags)
120
static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels,
121
int numLayers, CCGFlags flags)
119
124
CCGSubSurf *ccgSS;
120
125
int useAging = !!(flags & CCG_USE_AGING);
121
126
int useArena = flags & CCG_USE_ARENA;
127
int normalOffset = 0;
123
/* subdivLevels==0 is not allowed */
129
/* (subdivLevels == 0) is not allowed */
124
130
subdivLevels = MAX2(subdivLevels, 1);
145
154
ifc.vertUserSize = ifc.edgeUserSize = ifc.faceUserSize = 8;
147
ifc.vertDataSize = sizeof(float) * (flags & CCG_CALC_NORMALS ? 6 : 3);
156
ifc.numLayers = numLayers;
157
ifc.vertDataSize = sizeof(float) * numLayers;
158
normalOffset += sizeof(float) * numLayers;
159
if (flags & CCG_CALC_NORMALS)
160
ifc.vertDataSize += sizeof(float) * 3;
161
if (flags & CCG_ALLOC_MASK)
162
ifc.vertDataSize += sizeof(float);
163
ifc.simpleSubdiv = !!(flags & CCG_SIMPLE_SUBDIV);
150
166
CCGAllocatorIFC allocatorIFC;
165
181
ccgSubSurf_setUseAgeCounts(ccgSS, 1, 8, 8, 8);
184
if (flags & CCG_ALLOC_MASK) {
185
normalOffset += sizeof(float);
186
/* mask is allocated after regular layers */
187
ccgSubSurf_setAllocMask(ccgSS, 1, sizeof(float) * numLayers);
168
190
if (flags & CCG_CALC_NORMALS)
169
ccgSubSurf_setCalcVertexNormals(ccgSS, 1, offsetof(DMGridData, no));
191
ccgSubSurf_setCalcVertexNormals(ccgSS, 1, normalOffset);
171
193
ccgSubSurf_setCalcVertexNormals(ccgSS, 0, 0);
273
295
float uv[3] = {0.0f, 0.0f, 0.0f}; /* only first 2 values are written into */
275
297
limit[0] = limit[1] = STD_UV_CONNECT_LIMIT;
276
vmap = make_uv_vert_map(mpoly, mloop, mloopuv, totface, totvert, 0, limit);
298
vmap = BKE_mesh_uv_vert_map_make(mpoly, mloop, mloopuv, totface, totvert, 0, limit);
282
304
/* create vertices */
283
305
for (i = 0; i < totvert; i++) {
284
if (!get_uv_map_vert(vmap, i))
306
if (!BKE_mesh_uv_vert_map_get_vert(vmap, i))
287
for (v = get_uv_map_vert(vmap, i)->next; v; v = v->next)
309
for (v = BKE_mesh_uv_vert_map_get_vert(vmap, i)->next; v; v = v->next)
291
313
seam = (v != NULL) || ((mvert + i)->flag & ME_VERT_MERGED);
293
for (v = get_uv_map_vert(vmap, i); v; v = v->next) {
315
for (v = BKE_mesh_uv_vert_map_get_vert(vmap, i); v; v = v->next) {
294
316
if (v->separate) {
296
318
int loopid = mpoly[v->f].loopstart + v->tfindex;
493
513
w2 = (1.0f - fx + fac2 * fx * -fac) * (fy);
494
514
w4 = (fx) * (1.0f - fy + -fac2 * fy * fac);
496
fac2 = 1.0f - (w1 + w2 + w4);
497
fac2 = fac2 / (float)(faceLen - 3);
498
for (j = 0; j < faceLen; j++)
516
/* these values aren't used for tri's and cause divide by zero */
518
fac2 = 1.0f - (w1 + w2 + w4);
519
fac2 = fac2 / (float)(faceLen - 3);
520
for (j = 0; j < faceLen; j++) {
502
526
w[(i - 1 + faceLen) % faceLen] = w2;
633
658
return ((int *) ccgSubSurf_getFaceUserData(ss, f))[1];
661
static void minmax_v3_v3v3(const float vec[3], float min[3], float max[3])
663
if (min[0] > vec[0]) min[0] = vec[0];
664
if (min[1] > vec[1]) min[1] = vec[1];
665
if (min[2] > vec[2]) min[2] = vec[2];
666
if (max[0] < vec[0]) max[0] = vec[0];
667
if (max[1] < vec[1]) max[1] = vec[1];
668
if (max[2] < vec[2]) max[2] = vec[2];
636
671
static void ccgDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
638
673
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
639
674
CCGSubSurf *ss = ccgdm->ss;
640
CCGVertIterator *vi = ccgSubSurf_getVertIterator(ss);
641
CCGEdgeIterator *ei = ccgSubSurf_getEdgeIterator(ss);
642
CCGFaceIterator *fi = ccgSubSurf_getFaceIterator(ss);
643
679
int i, edgeSize = ccgSubSurf_getEdgeSize(ss);
644
680
int gridSize = ccgSubSurf_getGridSize(ss);
682
CCG_key_top_level(&key, ss);
646
684
if (!ccgSubSurf_getNumVerts(ss))
647
685
min_r[0] = min_r[1] = min_r[2] = max_r[0] = max_r[1] = max_r[2] = 0.0;
649
for (; !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
687
for (vi = ccgSubSurf_getVertIterator(ss); !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
650
688
CCGVert *v = ccgVertIterator_getCurrent(vi);
651
689
float *co = ccgSubSurf_getVertData(ss, v);
653
DO_MINMAX(co, min_r, max_r);
691
minmax_v3_v3v3(co, min_r, max_r);
693
ccgVertIterator_free(vi);
656
for (; !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
695
for (ei = ccgSubSurf_getEdgeIterator(ss); !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
657
696
CCGEdge *e = ccgEdgeIterator_getCurrent(ei);
658
DMGridData *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
697
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
660
699
for (i = 0; i < edgeSize; i++)
661
DO_MINMAX(edgeData[i].co, min_r, max_r);
700
minmax_v3_v3v3(CCG_elem_offset_co(&key, edgeData, i), min_r, max_r);
702
ccgEdgeIterator_free(ei);
664
for (; !ccgFaceIterator_isStopped(fi); ccgFaceIterator_next(fi)) {
704
for (fi = ccgSubSurf_getFaceIterator(ss); !ccgFaceIterator_isStopped(fi); ccgFaceIterator_next(fi)) {
665
705
CCGFace *f = ccgFaceIterator_getCurrent(fi);
666
706
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);
668
708
for (S = 0; S < numVerts; S++) {
669
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
709
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
671
711
for (y = 0; y < gridSize; y++)
672
712
for (x = 0; x < gridSize; x++)
673
DO_MINMAX(faceGridData[y * gridSize + x].co, min_r, max_r);
713
minmax_v3_v3v3(CCG_grid_elem_co(&key, faceGridData, x, y), min_r, max_r);
677
716
ccgFaceIterator_free(fi);
678
ccgEdgeIterator_free(ei);
679
ccgVertIterator_free(vi);
682
719
static int ccgDM_getNumVerts(DerivedMesh *dm)
745
785
offset = vertNum - ccgdm->faceMap[i].startVert;
746
786
if (offset < 1) {
747
787
vd = ccgSubSurf_getFaceCenterData(f);
748
copy_v3_v3(mv->co, vd->co);
749
normal_float_to_short_v3(mv->no, vd->no);
788
copy_v3_v3(mv->co, CCG_elem_co(&key, vd));
789
normal_float_to_short_v3(mv->no, CCG_elem_no(&key, vd));
751
791
else if (offset < gridSideEnd) {
753
793
grid = offset / gridSideVerts;
754
794
x = offset % gridSideVerts + 1;
755
795
vd = ccgSubSurf_getFaceGridEdgeData(ss, f, grid, x);
756
copy_v3_v3(mv->co, vd->co);
757
normal_float_to_short_v3(mv->no, vd->no);
796
copy_v3_v3(mv->co, CCG_elem_co(&key, vd));
797
normal_float_to_short_v3(mv->no, CCG_elem_no(&key, vd));
759
799
else if (offset < gridInternalEnd) {
760
800
offset -= gridSideEnd;
763
803
y = offset / gridSideVerts + 1;
764
804
x = offset % gridSideVerts + 1;
765
805
vd = ccgSubSurf_getFaceGridData(ss, f, grid, x, y);
766
copy_v3_v3(mv->co, vd->co);
767
normal_float_to_short_v3(mv->no, vd->no);
806
copy_v3_v3(mv->co, CCG_elem_co(&key, vd));
807
normal_float_to_short_v3(mv->no, CCG_elem_no(&key, vd));
770
810
else if ((vertNum < ccgdm->vertMap[0].startVert) && (ccgSubSurf_getNumEdges(ss) > 0)) {
777
while (i < lastedge && vertNum >= ccgdm->edgeMap[i + 1].startVert)
817
while (i < lastedge && vertNum >= ccgdm->edgeMap[i + 1].startVert) {
780
821
e = ccgdm->edgeMap[i].edge;
782
823
x = vertNum - ccgdm->edgeMap[i].startVert + 1;
783
824
vd = ccgSubSurf_getEdgeData(ss, e, x);
784
copy_v3_v3(mv->co, vd->co);
785
normal_float_to_short_v3(mv->no, vd->no);
825
copy_v3_v3(mv->co, CCG_elem_co(&key, vd));
826
normal_float_to_short_v3(mv->no, CCG_elem_no(&key, vd));
788
829
/* this vert comes from vert data */
1061
/* Translate GridPaintMask into vertex paint masks. Assumes vertices
1062
* are in the order output by ccgDM_copyFinalVertArray. */
1063
void subsurf_copy_grid_paint_mask(DerivedMesh *dm, const MPoly *mpoly,
1065
const GridPaintMask *grid_paint_mask)
1067
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
1068
CCGSubSurf *ss = ccgdm->ss;
1069
int level = ccgSubSurf_getSubdivisionLevels(ss);
1070
int gridSize = ccgSubSurf_getGridSize(ss);
1071
int edgeSize = ccgSubSurf_getEdgeSize(ss);
1072
int totface = ccgSubSurf_getNumFaces(ss);
1073
int i, j, x, y, factor, gpm_gridsize;
1075
for (i = 0; i < totface; i++) {
1076
CCGFace *f = ccgdm->faceMap[i].face;
1077
const MPoly *p = &mpoly[i];
1079
for (j = 0; j < p->totloop; j++) {
1080
const GridPaintMask *gpm = &grid_paint_mask[p->loopstart + j];
1084
factor = ccg_factor(level, gpm->level);
1085
gpm_gridsize = ccg_gridsize(gpm->level);
1087
for (y = 0; y < gridSize; y++) {
1088
for (x = 0; x < gridSize; x++) {
1091
vndx = getFaceIndex(ss, f, j, x, y, edgeSize, gridSize);
1092
offset = y * factor * gpm_gridsize + x * factor;
1093
paint_mask[vndx] = gpm->data[offset];
1100
/* utility functon */
1101
BLI_INLINE void ccgDM_to_MVert(MVert *mv, const CCGKey *key, CCGElem *elem)
1103
copy_v3_v3(mv->co, CCG_elem_co(key, elem));
1104
normal_float_to_short_v3(mv->no, CCG_elem_no(key, elem));
1105
mv->flag = mv->bweight = 0;
1015
1108
static void ccgDM_copyFinalVertArray(DerivedMesh *dm, MVert *mvert)
1017
1110
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1018
1111
CCGSubSurf *ss = ccgdm->ss;
1021
1115
int totvert, totedge, totface;
1022
1116
int gridSize = ccgSubSurf_getGridSize(ss);
1023
1117
int edgeSize = ccgSubSurf_getEdgeSize(ss);
1120
CCG_key_top_level(&key, ss);
1026
1122
totface = ccgSubSurf_getNumFaces(ss);
1027
1123
for (index = 0; index < totface; index++) {
1029
1125
int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
1031
1127
vd = ccgSubSurf_getFaceCenterData(f);
1032
copy_v3_v3(mvert[i].co, vd->co);
1033
normal_float_to_short_v3(mvert[i].no, vd->no);
1128
ccgDM_to_MVert(&mvert[i++], &key, vd);
1036
1130
for (S = 0; S < numVerts; S++) {
1037
for (x = 1; x < gridSize - 1; x++, i++) {
1131
for (x = 1; x < gridSize - 1; x++) {
1038
1132
vd = ccgSubSurf_getFaceGridEdgeData(ss, f, S, x);
1039
copy_v3_v3(mvert[i].co, vd->co);
1040
normal_float_to_short_v3(mvert[i].no, vd->no);
1133
ccgDM_to_MVert(&mvert[i++], &key, vd);
1044
1137
for (S = 0; S < numVerts; S++) {
1045
1138
for (y = 1; y < gridSize - 1; y++) {
1046
for (x = 1; x < gridSize - 1; x++, i++) {
1139
for (x = 1; x < gridSize - 1; x++) {
1047
1140
vd = ccgSubSurf_getFaceGridData(ss, f, S, x, y);
1048
copy_v3_v3(mvert[i].co, vd->co);
1049
normal_float_to_short_v3(mvert[i].no, vd->no);
1141
ccgDM_to_MVert(&mvert[i++], &key, vd);
1057
1149
CCGEdge *e = ccgdm->edgeMap[index].edge;
1060
for (x = 1; x < edgeSize - 1; x++, i++) {
1061
vd = ccgSubSurf_getEdgeData(ss, e, x);
1062
copy_v3_v3(mvert[i].co, vd->co);
1152
for (x = 1; x < edgeSize - 1; x++) {
1063
1153
/* This gives errors with -debug-fpe
1064
1154
* the normals don't seem to be unit length.
1065
1155
* this is most likely caused by edges with no
1066
1156
* faces which are now zerod out, see comment in:
1067
1157
* ccgSubSurf__calcVertNormals(), - campbell */
1068
normal_float_to_short_v3(mvert[i].no, vd->no);
1158
vd = ccgSubSurf_getEdgeData(ss, e, x);
1159
ccgDM_to_MVert(&mvert[i++], &key, vd);
1074
1165
CCGVert *v = ccgdm->vertMap[index].vert;
1076
1167
vd = ccgSubSurf_getVertData(ss, v);
1077
copy_v3_v3(mvert[i].co, vd->co);
1078
normal_float_to_short_v3(mvert[i].no, vd->no);
1168
ccgDM_to_MVert(&mvert[i++], &key, vd);
1173
/* utility functon */
1174
BLI_INLINE void ccgDM_to_MEdge(MEdge *med, const int v1, const int v2, const short flag)
1178
med->crease = med->bweight = 0;
1083
1182
static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
1085
1184
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1099
1199
for (S = 0; S < numVerts; S++) {
1100
1200
for (x = 0; x < gridSize - 1; x++) {
1101
MEdge *med = &medge[i];
1103
if (ccgdm->drawInteriorEdges)
1104
med->flag = ME_EDGEDRAW | ME_EDGERENDER;
1105
med->v1 = getFaceIndex(ss, f, S, x, 0, edgeSize, gridSize);
1106
med->v2 = getFaceIndex(ss, f, S, x + 1, 0, edgeSize, gridSize);
1201
ccgDM_to_MEdge(&medge[i++],
1202
getFaceIndex(ss, f, S, x, 0, edgeSize, gridSize),
1203
getFaceIndex(ss, f, S, x + 1, 0, edgeSize, gridSize),
1110
1207
for (x = 1; x < gridSize - 1; x++) {
1111
1208
for (y = 0; y < gridSize - 1; y++) {
1115
if (ccgdm->drawInteriorEdges)
1116
med->flag = ME_EDGEDRAW | ME_EDGERENDER;
1117
med->v1 = getFaceIndex(ss, f, S, x, y,
1118
edgeSize, gridSize);
1119
med->v2 = getFaceIndex(ss, f, S, x, y + 1,
1120
edgeSize, gridSize);
1124
if (ccgdm->drawInteriorEdges)
1125
med->flag = ME_EDGEDRAW | ME_EDGERENDER;
1126
med->v1 = getFaceIndex(ss, f, S, y, x,
1127
edgeSize, gridSize);
1128
med->v2 = getFaceIndex(ss, f, S, y + 1, x,
1129
edgeSize, gridSize);
1209
ccgDM_to_MEdge(&medge[i++],
1210
getFaceIndex(ss, f, S, x, y, edgeSize, gridSize),
1211
getFaceIndex(ss, f, S, x, y + 1, edgeSize, gridSize),
1213
ccgDM_to_MEdge(&medge[i++],
1214
getFaceIndex(ss, f, S, y, x, edgeSize, gridSize),
1215
getFaceIndex(ss, f, S, y + 1, x, edgeSize, gridSize),
1136
1222
totedge = ccgSubSurf_getNumEdges(ss);
1137
1223
for (index = 0; index < totedge; index++) {
1138
1224
CCGEdge *e = ccgdm->edgeMap[index].edge;
1139
unsigned int flags = 0;
1141
1227
int edgeIdx = GET_INT_FROM_POINTER(ccgSubSurf_getEdgeEdgeHandle(e));
1143
if (!ccgSubSurf_getEdgeNumFaces(e)) flags |= ME_LOOSEEDGE;
1229
if (!ccgSubSurf_getEdgeNumFaces(e)) {
1230
ed_flag |= ME_LOOSEEDGE;
1145
1233
if (edgeFlags) {
1146
1234
if (edgeIdx != -1) {
1147
flags |= (edgeFlags[index] & (ME_SEAM | ME_SHARP))
1148
| ME_EDGEDRAW | ME_EDGERENDER;
1235
ed_flag |= ((edgeFlags[index] & (ME_SEAM | ME_SHARP)) | ME_EDGEDRAW | ME_EDGERENDER);
1152
flags |= ME_EDGEDRAW | ME_EDGERENDER;
1239
ed_flag |= ME_EDGEDRAW | ME_EDGERENDER;
1155
1242
for (x = 0; x < edgeSize - 1; x++) {
1156
MEdge *med = &medge[i];
1157
med->v1 = getEdgeIndex(ss, e, x, edgeSize);
1158
med->v2 = getEdgeIndex(ss, e, x + 1, edgeSize);
1243
ccgDM_to_MEdge(&medge[i++],
1244
getEdgeIndex(ss, e, x, edgeSize),
1245
getEdgeIndex(ss, e, x + 1, edgeSize),
1231
1318
for (index = 0; index < totface; index++) {
1232
1319
CCGFace *f = ccgdm->faceMap[index].face;
1233
1320
int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
1234
/* int flag = (faceFlags)? faceFlags[index*2]: ME_SMOOTH; */ /* UNUSED */
1235
/* int mat_nr = (faceFlags)? faceFlags[index*2+1]: 0; */ /* UNUSED */
1321
/* int flag = (faceFlags) ? faceFlags[index * 2]: ME_SMOOTH; */ /* UNUSED */
1322
/* int mat_nr = (faceFlags) ? faceFlags[index * 2 + 1]: 0; */ /* UNUSED */
1237
1324
for (S = 0; S < numVerts; S++) {
1238
1325
for (y = 0; y < gridSize - 1; y++) {
1394
1478
static void ccgDM_foreachMappedVert(
1396
void (*func)(void *userData, int index, const float co[3], const float no_f[3], const short no_s[3]),
1480
void (*func)(void *userData, int index, const float co[3], const float no_f[3], const short no_s[3]),
1399
1483
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1400
CCGVertIterator *vi = ccgSubSurf_getVertIterator(ccgdm->ss);
1484
CCGVertIterator *vi;
1486
CCG_key_top_level(&key, ccgdm->ss);
1402
for (; !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
1488
for (vi = ccgSubSurf_getVertIterator(ccgdm->ss); !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
1403
1489
CCGVert *v = ccgVertIterator_getCurrent(vi);
1404
DMGridData *vd = ccgSubSurf_getVertData(ccgdm->ss, v);
1490
CCGElem *vd = ccgSubSurf_getVertData(ccgdm->ss, v);
1405
1491
int index = ccgDM_getVertMapIndex(ccgdm->ss, v);
1407
1493
if (index != -1)
1408
func(userData, index, vd->co, vd->no, NULL);
1494
func(userData, index, CCG_elem_co(&key, vd), CCG_elem_no(&key, vd), NULL);
1411
1497
ccgVertIterator_free(vi);
1414
1500
static void ccgDM_foreachMappedEdge(
1416
void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
1502
void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
1419
1505
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1420
1506
CCGSubSurf *ss = ccgdm->ss;
1421
CCGEdgeIterator *ei = ccgSubSurf_getEdgeIterator(ss);
1507
CCGEdgeIterator *ei;
1422
1509
int i, edgeSize = ccgSubSurf_getEdgeSize(ss);
1424
for (; !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
1511
CCG_key_top_level(&key, ss);
1513
for (ei = ccgSubSurf_getEdgeIterator(ss); !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
1425
1514
CCGEdge *e = ccgEdgeIterator_getCurrent(ei);
1426
DMGridData *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
1515
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
1427
1516
int index = ccgDM_getEdgeMapIndex(ss, e);
1429
1518
if (index != -1) {
1430
1519
for (i = 0; i < edgeSize - 1; i++)
1431
func(userData, index, edgeData[i].co, edgeData[i + 1].co);
1520
func(userData, index, CCG_elem_offset_co(&key, edgeData, i), CCG_elem_offset_co(&key, edgeData, i + 1));
1446
1535
CCGFaceIterator *fi;
1448
1537
glBegin(GL_POINTS);
1449
vi = ccgSubSurf_getVertIterator(ss);
1450
for (; !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
1538
for (vi = ccgSubSurf_getVertIterator(ss); !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
1451
1539
CCGVert *v = ccgVertIterator_getCurrent(vi);
1452
1540
glVertex3fv(ccgSubSurf_getVertData(ss, v));
1454
1542
ccgVertIterator_free(vi);
1456
ei = ccgSubSurf_getEdgeIterator(ss);
1457
for (; !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
1544
for (ei = ccgSubSurf_getEdgeIterator(ss); !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
1458
1545
CCGEdge *e = ccgEdgeIterator_getCurrent(ei);
1501
1587
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1502
1588
CCGSubSurf *ss = ccgdm->ss;
1503
1590
int i, j, edgeSize = ccgSubSurf_getEdgeSize(ss);
1504
1591
int totedge = ccgSubSurf_getNumEdges(ss);
1505
1592
int gridSize = ccgSubSurf_getGridSize(ss);
1595
CCG_key_top_level(&key, ss);
1508
1596
ccgdm_pbvh_update(ccgdm);
1510
1598
ccgSubSurf_getUseAgeCounts(ss, &useAging, NULL, NULL, NULL);
1512
1600
for (j = 0; j < totedge; j++) {
1513
1601
CCGEdge *e = ccgdm->edgeMap[j].edge;
1514
DMGridData *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
1602
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
1516
1604
if (!drawLooseEdges && !ccgSubSurf_getEdgeNumFaces(e))
1544
1632
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);
1546
1634
for (S = 0; S < numVerts; S++) {
1547
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1635
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1549
1637
glBegin(GL_LINE_STRIP);
1550
1638
for (x = 0; x < gridSize; x++)
1551
glVertex3fv(faceGridData[x].co);
1639
glVertex3fv(CCG_elem_offset_co(&key, faceGridData, x));
1553
1641
for (y = 1; y < gridSize - 1; y++) {
1554
1642
glBegin(GL_LINE_STRIP);
1555
1643
for (x = 0; x < gridSize; x++)
1556
glVertex3fv(faceGridData[y * gridSize + x].co);
1644
glVertex3fv(CCG_grid_elem_co(&key, faceGridData, x, y));
1559
1647
for (x = 1; x < gridSize - 1; x++) {
1560
1648
glBegin(GL_LINE_STRIP);
1561
1649
for (y = 0; y < gridSize; y++)
1562
glVertex3fv(faceGridData[y * gridSize + x].co);
1650
glVertex3fv(CCG_grid_elem_co(&key, faceGridData, x, y));
1572
1660
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1573
1661
CCGSubSurf *ss = ccgdm->ss;
1574
1663
int totedge = ccgSubSurf_getNumEdges(ss);
1575
1664
int i, j, edgeSize = ccgSubSurf_getEdgeSize(ss);
1666
CCG_key_top_level(&key, ss);
1577
1668
for (j = 0; j < totedge; j++) {
1578
1669
CCGEdge *e = ccgdm->edgeMap[j].edge;
1579
DMGridData *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
1670
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
1581
1672
if (!ccgSubSurf_getEdgeNumFaces(e)) {
1582
1673
glBegin(GL_LINE_STRIP);
1583
1674
for (i = 0; i < edgeSize - 1; i++) {
1584
glVertex3fv(edgeData[i].co);
1585
glVertex3fv(edgeData[i + 1].co);
1675
glVertex3fv(CCG_elem_offset_co(&key, edgeData, i));
1676
glVertex3fv(CCG_elem_offset_co(&key, edgeData, i + 1));
1609
1700
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1610
1701
CCGSubSurf *ss = ccgdm->ss;
1611
1703
int gridSize = ccgSubSurf_getGridSize(ss);
1612
1704
DMFlagMat *faceFlags = ccgdm->faceFlags;
1613
1705
int step = (fast) ? gridSize - 1 : 1;
1614
1706
int i, totface = ccgSubSurf_getNumFaces(ss);
1615
1707
int drawcurrent = 0, matnr = -1, shademodel = -1;
1709
CCG_key_top_level(&key, ss);
1617
1710
ccgdm_pbvh_update(ccgdm);
1619
1712
if (ccgdm->pbvh && ccgdm->multires.mmd && !fast) {
1620
1713
if (dm->numTessFaceData) {
1621
BLI_pbvh_draw(ccgdm->pbvh, partial_redraw_planes, NULL, setMaterial);
1714
BKE_pbvh_draw(ccgdm->pbvh, partial_redraw_planes, NULL,
1715
setMaterial, FALSE);
1622
1716
glShadeModel(GL_FLAT);
1655
1749
for (S = 0; S < numVerts; S++) {
1656
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1750
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1658
1752
if (shademodel == GL_SMOOTH) {
1659
1753
for (y = 0; y < gridSize - 1; y += step) {
1660
1754
glBegin(GL_QUAD_STRIP);
1661
1755
for (x = 0; x < gridSize; x += step) {
1662
DMGridData *a = &faceGridData[(y + 0) * gridSize + x];
1663
DMGridData *b = &faceGridData[(y + step) * gridSize + x];
1756
CCGElem *a = CCG_grid_elem(&key, faceGridData, x, y + 0);
1757
CCGElem *b = CCG_grid_elem(&key, faceGridData, x, y + step);
1759
glNormal3fv(CCG_elem_no(&key, a));
1760
glVertex3fv(CCG_elem_co(&key, a));
1761
glNormal3fv(CCG_elem_no(&key, b));
1762
glVertex3fv(CCG_elem_co(&key, b));
1674
1768
glBegin(GL_QUADS);
1675
1769
for (y = 0; y < gridSize - 1; y += step) {
1676
1770
for (x = 0; x < gridSize - 1; x += step) {
1677
float *a = faceGridData[(y + 0) * gridSize + x].co;
1678
float *b = faceGridData[(y + 0) * gridSize + x + step].co;
1679
float *c = faceGridData[(y + step) * gridSize + x + step].co;
1680
float *d = faceGridData[(y + step) * gridSize + x].co;
1771
float *a = CCG_grid_elem_co(&key, faceGridData, x, y + 0);
1772
float *b = CCG_grid_elem_co(&key, faceGridData, x + step, y + 0);
1773
float *c = CCG_grid_elem_co(&key, faceGridData, x + step, y + step);
1774
float *d = CCG_grid_elem_co(&key, faceGridData, x, y + step);
1682
1776
ccgDM_glNormalFast(a, b, c, d);
1708
1803
int gridFaces = gridSize - 1;
1709
1804
int edgeSize = ccgSubSurf_getEdgeSize(ss);
1710
1805
DMFlagMat *faceFlags = ccgdm->faceFlags;
1711
int a, b, i, doDraw, numVerts, matnr, new_matnr, totface;
1806
int a, b, i, do_draw, numVerts, matnr, new_matnr, totface;
1808
CCG_key_top_level(&key, ss);
1713
1809
ccgdm_pbvh_update(ccgdm);
1718
#define PASSATTRIB(dx, dy, vert) { \
1719
if (attribs.totorco) { \
1720
index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \
1721
glVertexAttrib3fvARB(attribs.orco.glIndex, attribs.orco.array[index]); \
1723
for (b = 0; b < attribs.tottface; b++) { \
1724
MTFace *tf = &attribs.tface[b].array[a]; \
1725
glVertexAttrib2fvARB(attribs.tface[b].glIndex, tf->uv[vert]); \
1727
for (b = 0; b < attribs.totmcol; b++) { \
1728
MCol *cp = &attribs.mcol[b].array[a * 4 + vert]; \
1730
col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; \
1731
glVertexAttrib4ubvARB(attribs.mcol[b].glIndex, col); \
1733
if (attribs.tottang) { \
1734
float *tang = attribs.tang.array[a * 4 + vert]; \
1735
glVertexAttrib4fvARB(attribs.tang.glIndex, tang); \
1814
#define PASSATTRIB(dx, dy, vert) { \
1815
if (attribs.totorco) { \
1816
index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \
1817
glVertexAttrib3fvARB(attribs.orco.gl_index, \
1818
attribs.orco.array[index]); \
1820
for (b = 0; b < attribs.tottface; b++) { \
1821
MTFace *tf = &attribs.tface[b].array[a]; \
1822
glVertexAttrib2fvARB(attribs.tface[b].gl_index, tf->uv[vert]); \
1824
for (b = 0; b < attribs.totmcol; b++) { \
1825
MCol *cp = &attribs.mcol[b].array[a * 4 + vert]; \
1827
col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; \
1828
glVertexAttrib4ubvARB(attribs.mcol[b].gl_index, col); \
1830
if (attribs.tottang) { \
1831
float *tang = attribs.tang.array[a * 4 + vert]; \
1832
glVertexAttrib4fvARB(attribs.tang.gl_index, tang); \
1739
1836
totface = ccgSubSurf_getNumFaces(ss);
1740
1837
for (a = 0, i = 0; i < totface; i++) {
1757
1854
if (new_matnr != matnr) {
1758
doDraw = setMaterial(matnr = new_matnr, &gattribs);
1855
do_draw = setMaterial(matnr = new_matnr, &gattribs);
1760
1857
DM_vertex_attributes_from_gpu(dm, &gattribs, &attribs);
1763
if (!doDraw || (setDrawOptions && (origIndex != ORIGINDEX_NONE) &&
1860
if (!do_draw || (setDrawOptions && (origIndex != ORIGINDEX_NONE) &&
1764
1861
(setDrawOptions(userData, origIndex) == DM_DRAW_OPTION_SKIP)))
1766
1863
a += gridFaces * gridFaces * numVerts;
1770
1867
glShadeModel(drawSmooth ? GL_SMOOTH : GL_FLAT);
1771
1868
for (S = 0; S < numVerts; S++) {
1772
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1773
DMGridData *vda, *vdb;
1869
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1775
1872
if (drawSmooth) {
1776
1873
for (y = 0; y < gridFaces; y++) {
1777
1874
glBegin(GL_QUAD_STRIP);
1778
1875
for (x = 0; x < gridFaces; x++) {
1779
vda = &faceGridData[(y + 0) * gridSize + x];
1780
vdb = &faceGridData[(y + 1) * gridSize + x];
1876
vda = CCG_grid_elem(&key, faceGridData, x, y + 0);
1877
vdb = CCG_grid_elem(&key, faceGridData, x, y + 1);
1782
1879
PASSATTRIB(0, 0, 0);
1783
glNormal3fv(vda->no);
1784
glVertex3fv(vda->co);
1880
glNormal3fv(CCG_elem_no(&key, vda));
1881
glVertex3fv(CCG_elem_co(&key, vda));
1786
1883
PASSATTRIB(0, 1, 1);
1787
glNormal3fv(vdb->no);
1788
glVertex3fv(vdb->co);
1884
glNormal3fv(CCG_elem_no(&key, vdb));
1885
glVertex3fv(CCG_elem_co(&key, vdb));
1790
1887
if (x != gridFaces - 1)
1794
vda = &faceGridData[(y + 0) * gridSize + x];
1795
vdb = &faceGridData[(y + 1) * gridSize + x];
1891
vda = CCG_grid_elem(&key, faceGridData, x, y + 0);
1892
vdb = CCG_grid_elem(&key, faceGridData, x, y + 1);
1797
1894
PASSATTRIB(0, 0, 3);
1798
glNormal3fv(vda->no);
1799
glVertex3fv(vda->co);
1895
glNormal3fv(CCG_elem_no(&key, vda));
1896
glVertex3fv(CCG_elem_co(&key, vda));
1801
1898
PASSATTRIB(0, 1, 2);
1802
glNormal3fv(vdb->no);
1803
glVertex3fv(vdb->co);
1899
glNormal3fv(CCG_elem_no(&key, vdb));
1900
glVertex3fv(CCG_elem_co(&key, vdb));
1811
1908
glBegin(GL_QUADS);
1812
1909
for (y = 0; y < gridFaces; y++) {
1813
1910
for (x = 0; x < gridFaces; x++) {
1814
float *aco = faceGridData[(y + 0) * gridSize + x].co;
1815
float *bco = faceGridData[(y + 0) * gridSize + x + 1].co;
1816
float *cco = faceGridData[(y + 1) * gridSize + x + 1].co;
1817
float *dco = faceGridData[(y + 1) * gridSize + x].co;
1911
float *aco = CCG_grid_elem_co(&key, faceGridData, x, y);
1912
float *bco = CCG_grid_elem_co(&key, faceGridData, x + 1, y);
1913
float *cco = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);
1914
float *dco = CCG_grid_elem_co(&key, faceGridData, x, y + 1);
1819
1916
ccgDM_glNormalFast(aco, bco, cco, dco);
1846
1943
/* Only used by non-editmesh types */
1847
static void ccgDM_drawMappedFacesMat(DerivedMesh *dm, void (*setMaterial)(void *userData, int, void *attribs), int (*setFace)(void *userData, int index), void *userData)
1944
static void ccgDM_drawMappedFacesMat(DerivedMesh *dm,
1945
void (*setMaterial)(void *userData, int, void *attribs),
1946
int (*setFace)(void *userData, int index), void *userData)
1849
1948
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
1850
1949
CCGSubSurf *ss = ccgdm->ss;
1851
1951
GPUVertexAttribs gattribs;
1852
1952
DMVertexAttribs attribs = {{{NULL}}};
1853
1953
int gridSize = ccgSubSurf_getGridSize(ss);
1856
1956
DMFlagMat *faceFlags = ccgdm->faceFlags;
1857
1957
int a, b, i, numVerts, matnr, new_matnr, totface;
1959
CCG_key_top_level(&key, ss);
1859
1960
ccgdm_pbvh_update(ccgdm);
1863
#define PASSATTRIB(dx, dy, vert) { \
1864
if (attribs.totorco) { \
1865
index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \
1866
if (attribs.orco.glTexco) \
1867
glTexCoord3fv(attribs.orco.array[index]); \
1869
glVertexAttrib3fvARB(attribs.orco.glIndex, attribs.orco.array[index]); \
1871
for (b = 0; b < attribs.tottface; b++) { \
1872
MTFace *tf = &attribs.tface[b].array[a]; \
1873
if (attribs.tface[b].glTexco) \
1874
glTexCoord2fv(tf->uv[vert]); \
1876
glVertexAttrib2fvARB(attribs.tface[b].glIndex, tf->uv[vert]); \
1878
for (b = 0; b < attribs.totmcol; b++) { \
1879
MCol *cp = &attribs.mcol[b].array[a * 4 + vert]; \
1881
col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; \
1882
glVertexAttrib4ubvARB(attribs.mcol[b].glIndex, col); \
1884
if (attribs.tottang) { \
1885
float *tang = attribs.tang.array[a * 4 + vert]; \
1886
glVertexAttrib4fvARB(attribs.tang.glIndex, tang); \
1964
#define PASSATTRIB(dx, dy, vert) { \
1965
if (attribs.totorco) { \
1966
index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \
1967
if (attribs.orco.gl_texco) \
1968
glTexCoord3fv(attribs.orco.array[index]); \
1970
glVertexAttrib3fvARB(attribs.orco.gl_index, \
1971
attribs.orco.array[index]); \
1973
for (b = 0; b < attribs.tottface; b++) { \
1974
MTFace *tf = &attribs.tface[b].array[a]; \
1975
if (attribs.tface[b].gl_texco) \
1976
glTexCoord2fv(tf->uv[vert]); \
1978
glVertexAttrib2fvARB(attribs.tface[b].gl_index, tf->uv[vert]); \
1980
for (b = 0; b < attribs.totmcol; b++) { \
1981
MCol *cp = &attribs.mcol[b].array[a * 4 + vert]; \
1983
col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; \
1984
glVertexAttrib4ubvARB(attribs.mcol[b].gl_index, col); \
1986
if (attribs.tottang) { \
1987
float *tang = attribs.tang.array[a * 4 + vert]; \
1988
glVertexAttrib4fvARB(attribs.tang.gl_index, tang); \
1890
1992
totface = ccgSubSurf_getNumFaces(ss);
1891
1993
for (a = 0, i = 0; i < totface; i++) {
1922
2024
glShadeModel(drawSmooth ? GL_SMOOTH : GL_FLAT);
1923
2025
for (S = 0; S < numVerts; S++) {
1924
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1925
DMGridData *vda, *vdb;
2026
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
1927
2029
if (drawSmooth) {
1928
2030
for (y = 0; y < gridFaces; y++) {
1929
2031
glBegin(GL_QUAD_STRIP);
1930
2032
for (x = 0; x < gridFaces; x++) {
1931
vda = &faceGridData[(y + 0) * gridSize + x];
1932
vdb = &faceGridData[(y + 1) * gridSize + x];
2033
vda = CCG_grid_elem(&key, faceGridData, x, y);
2034
vdb = CCG_grid_elem(&key, faceGridData, x, y + 1);
1934
2036
PASSATTRIB(0, 0, 0);
1935
glNormal3fv(vda->no);
1936
glVertex3fv(vda->co);
2037
glNormal3fv(CCG_elem_no(&key, vda));
2038
glVertex3fv(CCG_elem_co(&key, vda));
1938
2040
PASSATTRIB(0, 1, 1);
1939
glNormal3fv(vdb->no);
1940
glVertex3fv(vdb->co);
2041
glNormal3fv(CCG_elem_no(&key, vdb));
2042
glVertex3fv(CCG_elem_co(&key, vdb));
1942
2044
if (x != gridFaces - 1)
1946
vda = &faceGridData[(y + 0) * gridSize + x];
1947
vdb = &faceGridData[(y + 1) * gridSize + x];
2048
vda = CCG_grid_elem(&key, faceGridData, x, y + 0);
2049
vdb = CCG_grid_elem(&key, faceGridData, x, y + 1);
1949
2051
PASSATTRIB(0, 0, 3);
1950
glNormal3fv(vda->no);
1951
glVertex3fv(vda->co);
2052
glNormal3fv(CCG_elem_no(&key, vda));
2053
glVertex3fv(CCG_elem_co(&key, vda));
1953
2055
PASSATTRIB(0, 1, 2);
1954
glNormal3fv(vdb->no);
1955
glVertex3fv(vdb->co);
2056
glNormal3fv(CCG_elem_no(&key, vdb));
2057
glVertex3fv(CCG_elem_co(&key, vdb));
1963
2065
glBegin(GL_QUADS);
1964
2066
for (y = 0; y < gridFaces; y++) {
1965
2067
for (x = 0; x < gridFaces; x++) {
1966
float *aco = faceGridData[(y + 0) * gridSize + x].co;
1967
float *bco = faceGridData[(y + 0) * gridSize + x + 1].co;
1968
float *cco = faceGridData[(y + 1) * gridSize + x + 1].co;
1969
float *dco = faceGridData[(y + 1) * gridSize + x].co;
2068
float *aco = CCG_grid_elem_co(&key, faceGridData, x, y + 0);
2069
float *bco = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);
2070
float *cco = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);
2071
float *dco = CCG_grid_elem_co(&key, faceGridData, x, y + 1);
1971
2073
ccgDM_glNormalFast(aco, bco, cco, dco);
2057
2161
for (S = 0; S < numVerts; S++) {
2058
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
2162
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
2061
2165
if (drawSmooth) {
2062
2166
glShadeModel(GL_SMOOTH);
2063
2167
for (y = 0; y < gridFaces; y++) {
2064
2168
glBegin(GL_QUAD_STRIP);
2065
2169
for (x = 0; x < gridFaces; x++) {
2066
a = &faceGridData[(y + 0) * gridSize + x];
2067
b = &faceGridData[(y + 1) * gridSize + x];
2170
a = CCG_grid_elem(&key, faceGridData, x, y + 0);
2171
b = CCG_grid_elem(&key, faceGridData, x, y + 1);
2069
2173
if (tf) glTexCoord2fv(tf->uv[0]);
2070
2174
if (cp) glColor3ub(cp[3], cp[2], cp[1]);
2175
glNormal3fv(CCG_elem_no(&key, a));
2176
glVertex3fv(CCG_elem_co(&key, a));
2074
2178
if (tf) glTexCoord2fv(tf->uv[1]);
2075
2179
if (cp) glColor3ub(cp[7], cp[6], cp[5]);
2180
glNormal3fv(CCG_elem_no(&key, b));
2181
glVertex3fv(CCG_elem_co(&key, b));
2079
2183
if (x != gridFaces - 1) {
2085
a = &faceGridData[(y + 0) * gridSize + x];
2086
b = &faceGridData[(y + 1) * gridSize + x];
2189
a = CCG_grid_elem(&key, faceGridData, x, y + 0);
2190
b = CCG_grid_elem(&key, faceGridData, x, y + 1);
2088
2192
if (tf) glTexCoord2fv(tf->uv[3]);
2089
2193
if (cp) glColor3ub(cp[15], cp[14], cp[13]);
2194
glNormal3fv(CCG_elem_no(&key, a));
2195
glVertex3fv(CCG_elem_co(&key, a));
2093
2197
if (tf) glTexCoord2fv(tf->uv[2]);
2094
2198
if (cp) glColor3ub(cp[11], cp[10], cp[9]);
2199
glNormal3fv(CCG_elem_no(&key, b));
2200
glVertex3fv(CCG_elem_co(&key, b));
2099
2203
if (cp) cp += 16;
2105
glShadeModel((cp)? GL_SMOOTH: GL_FLAT);
2209
glShadeModel((cp) ? GL_SMOOTH : GL_FLAT);
2106
2210
glBegin(GL_QUADS);
2107
2211
for (y = 0; y < gridFaces; y++) {
2108
2212
for (x = 0; x < gridFaces; x++) {
2109
float *a_co = faceGridData[(y + 0) * gridSize + x].co;
2110
float *b_co = faceGridData[(y + 0) * gridSize + x + 1].co;
2111
float *c_co = faceGridData[(y + 1) * gridSize + x + 1].co;
2112
float *d_co = faceGridData[(y + 1) * gridSize + x].co;
2213
float *a_co = CCG_grid_elem_co(&key, faceGridData, x, y + 0);
2214
float *b_co = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);
2215
float *c_co = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);
2216
float *d_co = CCG_grid_elem_co(&key, faceGridData, x, y + 1);
2114
2218
ccgDM_glNormalFast(a_co, b_co, c_co, d_co);
2198
2302
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
2199
2303
CCGSubSurf *ss = ccgdm->ss;
2200
2305
MCol *mcol = NULL;
2201
2306
int i, gridSize = ccgSubSurf_getGridSize(ss);
2202
2307
DMFlagMat *faceFlags = ccgdm->faceFlags;
2203
2308
int useColors = flag & DM_DRAW_USE_COLORS;
2204
2309
int gridFaces = gridSize - 1, totface;
2311
CCG_key_top_level(&key, ss);
2206
2313
/* currently unused -- each original face is handled separately */
2207
2314
(void)compareDrawOptions;
2250
2357
glShadeModel(GL_SMOOTH);
2252
2359
for (S = 0; S < numVerts; S++) {
2253
DMGridData *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
2360
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);
2254
2361
if (drawSmooth) {
2255
2362
for (y = 0; y < gridFaces; y++) {
2257
2364
glBegin(GL_QUAD_STRIP);
2258
2365
for (x = 0; x < gridFaces; x++) {
2259
a = &faceGridData[(y + 0) * gridSize + x];
2260
b = &faceGridData[(y + 1) * gridSize + x];
2366
a = CCG_grid_elem(&key, faceGridData, x, y + 0);
2367
b = CCG_grid_elem(&key, faceGridData, x, y + 1);
2262
2369
if (cp) glColor3ub(cp[3], cp[2], cp[1]);
2370
glNormal3fv(CCG_elem_no(&key, a));
2371
glVertex3fv(CCG_elem_co(&key, a));
2265
2372
if (cp) glColor3ub(cp[7], cp[6], cp[5]);
2373
glNormal3fv(CCG_elem_no(&key, b));
2374
glVertex3fv(CCG_elem_co(&key, b));
2269
2376
if (x != gridFaces - 1) {
2270
2377
if (cp) cp += 16;
2274
a = &faceGridData[(y + 0) * gridSize + x];
2275
b = &faceGridData[(y + 1) * gridSize + x];
2381
a = CCG_grid_elem(&key, faceGridData, x, y + 0);
2382
b = CCG_grid_elem(&key, faceGridData, x, y + 1);
2277
2384
if (cp) glColor3ub(cp[15], cp[14], cp[13]);
2385
glNormal3fv(CCG_elem_no(&key, a));
2386
glVertex3fv(CCG_elem_co(&key, a));
2280
2387
if (cp) glColor3ub(cp[11], cp[10], cp[9]);
2388
glNormal3fv(CCG_elem_no(&key, b));
2389
glVertex3fv(CCG_elem_co(&key, b));
2284
2391
if (cp) cp += 16;
2290
2397
glBegin(GL_QUADS);
2291
2398
for (y = 0; y < gridFaces; y++) {
2292
2399
for (x = 0; x < gridFaces; x++) {
2293
float *a = faceGridData[(y + 0) * gridSize + x].co;
2294
float *b = faceGridData[(y + 0) * gridSize + x + 1].co;
2295
float *c = faceGridData[(y + 1) * gridSize + x + 1].co;
2296
float *d = faceGridData[(y + 1) * gridSize + x].co;
2400
float *a = CCG_grid_elem_co(&key, faceGridData, x, y + 0);
2401
float *b = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);
2402
float *c = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);
2403
float *d = CCG_grid_elem_co(&key, faceGridData, x, y + 1);
2298
2405
ccgDM_glNormalFast(a, b, c, d);
2326
2433
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
2327
2434
CCGSubSurf *ss = ccgdm->ss;
2328
CCGEdgeIterator *ei = ccgSubSurf_getEdgeIterator(ss);
2435
CCGEdgeIterator *ei;
2329
2437
int i, useAging, edgeSize = ccgSubSurf_getEdgeSize(ss);
2439
CCG_key_top_level(&key, ss);
2331
2440
ccgSubSurf_getUseAgeCounts(ss, &useAging, NULL, NULL, NULL);
2333
for (; !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
2442
for (ei = ccgSubSurf_getEdgeIterator(ss); !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
2334
2443
CCGEdge *e = ccgEdgeIterator_getCurrent(ei);
2335
DMGridData *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
2444
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
2336
2445
int index = ccgDM_getEdgeMapIndex(ss, e);
2338
2447
glBegin(GL_LINE_STRIP);
2361
2470
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
2362
2471
CCGSubSurf *ss = ccgdm->ss;
2363
CCGEdgeIterator *ei = ccgSubSurf_getEdgeIterator(ss);
2473
CCGEdgeIterator *ei;
2364
2474
int i, useAging, edgeSize = ccgSubSurf_getEdgeSize(ss);
2476
CCG_key_top_level(&key, ss);
2366
2477
ccgSubSurf_getUseAgeCounts(ss, &useAging, NULL, NULL, NULL);
2368
for (; !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
2479
for (ei = ccgSubSurf_getEdgeIterator(ss); !ccgEdgeIterator_isStopped(ei); ccgEdgeIterator_next(ei)) {
2369
2480
CCGEdge *e = ccgEdgeIterator_getCurrent(ei);
2370
DMGridData *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
2481
CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
2371
2482
int index = ccgDM_getEdgeMapIndex(ss, e);
2373
2484
glBegin(GL_LINE_STRIP);
2392
2503
static void ccgDM_foreachMappedFaceCenter(
2394
void (*func)(void *userData, int index, const float co[3], const float no[3]),
2505
void (*func)(void *userData, int index, const float co[3], const float no[3]),
2397
2508
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
2398
2509
CCGSubSurf *ss = ccgdm->ss;
2399
CCGFaceIterator *fi = ccgSubSurf_getFaceIterator(ss);
2401
for (; !ccgFaceIterator_isStopped(fi); ccgFaceIterator_next(fi)) {
2511
CCGFaceIterator *fi;
2513
CCG_key_top_level(&key, ss);
2515
for (fi = ccgSubSurf_getFaceIterator(ss); !ccgFaceIterator_isStopped(fi); ccgFaceIterator_next(fi)) {
2402
2516
CCGFace *f = ccgFaceIterator_getCurrent(fi);
2403
2517
int index = ccgDM_getFaceMapIndex(ss, f);
2405
2519
if (index != -1) {
2406
2520
/* Face center data normal isn't updated atm. */
2407
DMGridData *vd = ccgSubSurf_getFaceGridData(ss, f, 0, 0, 0);
2521
CCGElem *vd = ccgSubSurf_getFaceGridData(ss, f, 0, 0, 0);
2409
func(userData, index, vd->co, vd->no);
2523
func(userData, index, CCG_elem_co(&key, vd), CCG_elem_no(&key, vd));
2596
2712
if (type == CD_ORIGINDEX) {
2597
2713
/* create origindex on demand to save memory */
2716
/* Avoid re-creation if the layer exists already */
2717
origindex = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
2722
DM_add_tessface_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
2723
origindex = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
2725
/* silly loop counting up */
2726
range_vn_i(origindex, dm->getNumTessFaces(dm), 0);
2731
return DM_get_tessface_data_layer(dm, type);
2734
static void *ccgDM_get_poly_data_layer(DerivedMesh *dm, int type)
2736
if (type == CD_ORIGINDEX) {
2737
/* create origindex on demand to save memory */
2598
2738
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
2599
2739
CCGSubSurf *ss = ccgdm->ss;
2600
2740
int *origindex;
2602
2742
int gridFaces = ccgSubSurf_getGridSize(ss) - 1;
2604
2744
/* Avoid re-creation if the layer exists already */
2605
origindex = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
2745
origindex = DM_get_poly_data_layer(dm, CD_ORIGINDEX);
2606
2746
if (origindex) {
2607
2747
return origindex;
2610
DM_add_tessface_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
2611
origindex = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
2750
DM_add_poly_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
2751
origindex = DM_get_poly_data_layer(dm, CD_ORIGINDEX);
2613
2753
totface = ccgSubSurf_getNumFaces(ss);
2657
2797
return DM_get_tessface_data(dm, index, type);
2800
static void *ccgDM_get_poly_data(DerivedMesh *dm, int index, int type)
2802
if (type == CD_ORIGINDEX) {
2803
/* ensure creation of CD_ORIGINDEX layer */
2804
ccgDM_get_tessface_data_layer(dm, type);
2807
return DM_get_poly_data(dm, index, type);
2660
2810
static int ccgDM_getNumGrids(DerivedMesh *dm)
2662
2812
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
2886
3046
if (grid_pbvh) {
2887
3047
ccgdm_create_grids(dm);
2889
gridSize = ccgDM_getGridSize(dm);
2890
3049
numGrids = ccgDM_getNumGrids(dm);
2892
ob->sculpt->pbvh = ccgdm->pbvh = BLI_pbvh_new();
2893
BLI_pbvh_build_grids(ccgdm->pbvh, ccgdm->gridData, ccgdm->gridAdjacency,
2894
numGrids, gridSize, (void **)ccgdm->gridFaces, ccgdm->gridFlagMats, ccgdm->gridHidden);
3051
ob->sculpt->pbvh = ccgdm->pbvh = BKE_pbvh_new();
3052
BKE_pbvh_build_grids(ccgdm->pbvh, ccgdm->gridData, ccgdm->gridAdjacency,
3053
numGrids, &key, (void **) ccgdm->gridFaces, ccgdm->gridFlagMats, ccgdm->gridHidden);
2896
3055
else if (ob->type == OB_MESH) {
2897
3056
Mesh *me = ob->data;
2898
ob->sculpt->pbvh = ccgdm->pbvh = BLI_pbvh_new();
3057
ob->sculpt->pbvh = ccgdm->pbvh = BKE_pbvh_new();
2899
3058
BLI_assert(!(me->mface == NULL && me->mpoly != NULL)); /* BMESH ONLY complain if mpoly is valid but not mface */
2900
BLI_pbvh_build_mesh(ccgdm->pbvh, me->mface, me->mvert,
2901
me->totface, me->totvert);
3059
BKE_pbvh_build_mesh(ccgdm->pbvh, me->mface, me->mvert,
3060
me->totface, me->totvert, &me->vdata);
3064
pbvh_show_diffuse_color_set(ccgdm->pbvh, ob->sculpt->show_diffuse_color);
2904
3066
return ccgdm->pbvh;
3004
3166
ccgdm->dm.getVertData = ccgDM_get_vert_data;
3005
3167
ccgdm->dm.getEdgeData = ccgDM_get_edge_data;
3006
3168
ccgdm->dm.getTessFaceData = ccgDM_get_tessface_data;
3169
ccgdm->dm.getPolyData = ccgDM_get_poly_data;
3007
3170
ccgdm->dm.getVertDataArray = ccgDM_get_vert_data_layer;
3008
3171
ccgdm->dm.getEdgeDataArray = ccgDM_get_edge_data_layer;
3009
3172
ccgdm->dm.getTessFaceDataArray = ccgDM_get_tessface_data_layer;
3173
ccgdm->dm.getPolyDataArray = ccgDM_get_poly_data_layer;
3010
3174
ccgdm->dm.getNumGrids = ccgDM_getNumGrids;
3011
3175
ccgdm->dm.getGridSize = ccgDM_getGridSize;
3012
3176
ccgdm->dm.getGridData = ccgDM_getGridData;
3013
3177
ccgdm->dm.getGridAdjacency = ccgDM_getGridAdjacency;
3014
3178
ccgdm->dm.getGridOffset = ccgDM_getGridOffset;
3179
ccgdm->dm.getGridKey = ccgDM_getGridKey;
3015
3180
ccgdm->dm.getGridFlagMats = ccgDM_getGridFlagMats;
3016
3181
ccgdm->dm.getGridHidden = ccgDM_getGridHidden;
3017
3182
ccgdm->dm.getPolyMap = ccgDM_getPolyMap;
3148
3310
*((int *)ccgSubSurf_getFaceUserData(ss, f)) = vertNum;
3150
3312
BLI_array_empty(loopidx);
3151
BLI_array_growitems(loopidx, numVerts);
3313
BLI_array_grow_items(loopidx, numVerts);
3152
3314
for (s = 0; s < numVerts; s++) {
3153
3315
loopidx[s] = loopindex++;
3156
3318
BLI_array_empty(vertidx);
3157
BLI_array_growitems(vertidx, numVerts);
3319
BLI_array_grow_items(vertidx, numVerts);
3158
3320
for (s = 0; s < numVerts; s++) {
3159
3321
CCGVert *v = ccgSubSurf_getFaceVert(f, s);
3160
3322
vertidx[s] = GET_INT_FROM_POINTER(ccgSubSurf_getVertVertHandle(v));
3363
3526
struct DerivedMesh *subsurf_make_derived_from_derived(
3364
3527
struct DerivedMesh *dm,
3365
3528
struct SubsurfModifierData *smd,
3366
int useRenderParams, float (*vertCos)[3],
3367
int isFinalCalc, int forEditMode, int inEditMode)
3529
float (*vertCos)[3],
3369
int useSimple = smd->subdivType == ME_SIMPLE_SUBSURF;
3532
int useSimple = (smd->subdivType == ME_SIMPLE_SUBSURF) ? CCG_SIMPLE_SUBDIV : 0;
3370
3533
CCGFlags useAging = smd->flags & eSubsurfModifierFlag_DebugIncr ? CCG_USE_AGING : 0;
3371
3534
int useSubsurfUv = smd->flags & eSubsurfModifierFlag_SubsurfUv;
3372
3535
int drawInteriorEdges = !(smd->flags & eSubsurfModifierFlag_ControlEdges);
3373
3536
CCGDerivedMesh *result;
3538
if (flags & SUBSURF_FOR_EDIT_MODE) {
3376
3539
int levels = (smd->modifier.scene) ? get_render_subsurf_level(&smd->modifier.scene->r, smd->levels) : smd->levels;
3378
smd->emCache = _getSubSurf(smd->emCache, levels, useAging | CCG_CALC_NORMALS);
3541
smd->emCache = _getSubSurf(smd->emCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
3379
3542
ss_sync_from_derivedmesh(smd->emCache, dm, vertCos, useSimple);
3381
3544
result = getCCGDerivedMesh(smd->emCache,
3382
3545
drawInteriorEdges,
3383
3546
useSubsurfUv, dm);
3385
else if (useRenderParams) {
3548
else if (flags & SUBSURF_USE_RENDER_PARAMS) {
3386
3549
/* Do not use cache in render mode. */
3387
3550
CCGSubSurf *ss;
3388
3551
int levels = (smd->modifier.scene) ? get_render_subsurf_level(&smd->modifier.scene->r, smd->renderLevels) : smd->renderLevels;
3415
3578
* Addendum: we can't really ensure that this is never called in edit
3416
3579
* mode, so now we have a parameter to verify it. - brecht
3418
if (!inEditMode && smd->emCache) {
3581
if (!(flags & SUBSURF_IN_EDIT_MODE) && smd->emCache) {
3419
3582
ccgSubSurf_free(smd->emCache);
3420
3583
smd->emCache = NULL;
3423
if (useIncremental && isFinalCalc) {
3424
smd->mCache = ss = _getSubSurf(smd->mCache, levels, useAging | CCG_CALC_NORMALS);
3586
if (useIncremental && (flags & SUBSURF_IS_FINAL_CALC)) {
3587
smd->mCache = ss = _getSubSurf(smd->mCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
3426
3589
ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple);
3430
3593
useSubsurfUv, dm);
3433
if (smd->mCache && isFinalCalc) {
3596
CCGFlags ccg_flags = useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS;
3598
if (smd->mCache && (flags & SUBSURF_IS_FINAL_CALC)) {
3434
3599
ccgSubSurf_free(smd->mCache);
3435
3600
smd->mCache = NULL;
3438
ss = _getSubSurf(NULL, levels, CCG_USE_ARENA | CCG_CALC_NORMALS);
3603
if (flags & SUBSURF_ALLOC_PAINT_MASK)
3604
ccg_flags |= CCG_ALLOC_MASK;
3606
ss = _getSubSurf(NULL, levels, 3, ccg_flags);
3439
3607
ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple);
3441
3609
result = getCCGDerivedMesh(ss, drawInteriorEdges, useSubsurfUv, dm);
3611
if (flags & SUBSURF_IS_FINAL_CALC)
3444
3612
smd->mCache = ss;
3446
3614
result->freeSS = 1;
3616
if (flags & SUBSURF_ALLOC_PAINT_MASK)
3617
ccgSubSurf_setNumLayers(ss, 4);
3457
3628
* calculated vert positions is incorrect for the verts
3458
3629
* on the boundary of the mesh.
3460
CCGSubSurf *ss = _getSubSurf(NULL, 1, CCG_USE_ARENA);
3631
CCGSubSurf *ss = _getSubSurf(NULL, 1, 3, CCG_USE_ARENA);
3461
3632
float edge_sum[3], face_sum[3];
3462
3633
CCGVertIterator *vi;
3463
3634
DerivedMesh *dm = CDDM_from_mesh(me, NULL);
3465
3636
ss_sync_from_derivedmesh(ss, dm, NULL, 0);
3467
vi = ccgSubSurf_getVertIterator(ss);
3468
for (; !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
3638
for (vi = ccgSubSurf_getVertIterator(ss); !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
3469
3639
CCGVert *v = ccgVertIterator_getCurrent(vi);
3470
3640
int idx = GET_INT_FROM_POINTER(ccgSubSurf_getVertVertHandle(v));
3471
3641
int N = ccgSubSurf_getVertNumEdges(v);
added
removed
source/blender/blenkernel/intern/subsurf_ccg.c
