static void add_weight_mcol_dm(Object *ob, DerivedMesh *dm, int const draw_flag)
{
- Mesh *me = ob->data;
- MFace *mf = me->mface;
+ // Mesh *me = ob->data; // UNUSED
+ MFace *mf = dm->getTessFaceArray(dm);
+ MLoop *mloop = dm->getLoopArray(dm), *ml;
+ MPoly *mp = dm->getPolyArray(dm);
ColorBand *coba= stored_cb; /* warning, not a local var */
unsigned char *wtcol;
- int i;
-
+ unsigned char(*wlcol)[4] = NULL;
+ BLI_array_declare(wlcol);
+ int i, j, totface=dm->getNumTessFaces(dm), totloop;
+ int *origIndex = dm->getVertDataArray(dm, CD_ORIGINDEX);
+
- int defbase_len = BLI_countlist(&ob->defbase);
- char *defbase_sel = MEM_mallocN(defbase_len * sizeof(char), __func__);
- int selected = get_selected_defgroups(ob, defbase_sel, defbase_len);
- int unselected = defbase_len - selected;
+ int defbase_tot = BLI_countlist(&ob->defbase);
+ char *defbase_sel = MEM_mallocN(defbase_tot * sizeof(char), __func__);
+ int selected = get_selected_defgroups(ob, defbase_sel, defbase_tot);
+ int unselected = defbase_tot - selected;
- wtcol = MEM_callocN (sizeof (unsigned char) * me->totface*4*4, "weightmap");
+ wtcol = MEM_callocN (sizeof (unsigned char) * totface*4*4, "weightmap");
- memset(wtcol, 0x55, sizeof (unsigned char) * me->totface*4*4);
- for (i=0; i<me->totface; i++, mf++) {
+ /*first add colors to the tesselation faces*/
+ memset(wtcol, 0x55, sizeof (unsigned char) * totface*4*4);
+ for (i=0; i<totface; i++, mf++) {
+ /*origindex being NULL means we're operating on original mesh data*/
- calc_weightpaint_vert_color(ob, coba, mf->v1, &wtcol[(i*4 + 0)*4], defbase_sel, selected, unselected, draw_flag);
- calc_weightpaint_vert_color(ob, coba, mf->v2, &wtcol[(i*4 + 1)*4], defbase_sel, selected, unselected, draw_flag);
- calc_weightpaint_vert_color(ob, coba, mf->v3, &wtcol[(i*4 + 2)*4], defbase_sel, selected, unselected, draw_flag);
+ calc_weightpaint_vert_color(ob, defbase_tot, coba, mf->v1, &wtcol[(i*4 + 0)*4], defbase_sel, selected, unselected, draw_flag);
+ calc_weightpaint_vert_color(ob, defbase_tot, coba, mf->v2, &wtcol[(i*4 + 1)*4], defbase_sel, selected, unselected, draw_flag);
+ calc_weightpaint_vert_color(ob, defbase_tot, coba, mf->v3, &wtcol[(i*4 + 2)*4], defbase_sel, selected, unselected, draw_flag);
if (mf->v4)
- calc_weightpaint_vert_color(ob, coba, mf->v4, &wtcol[(i*4 + 3)*4], defbase_sel, selected, unselected, draw_flag);
+ calc_weightpaint_vert_color(ob, defbase_tot, coba, mf->v4, &wtcol[(i*4 + 3)*4], defbase_sel, selected, unselected, draw_flag);
}
- calc_weightpaint_vert_color(ob, coba, origIndex ? origIndex[ml->v] : ml->v,
+ CustomData_add_layer(&dm->faceData, CD_WEIGHT_MCOL, CD_ASSIGN, wtcol, totface);
+
+ /*now add to loops, so the data can be passed through the modifier stack*/
+ totloop = 0;
+ for (i=0; i<dm->numPolyData; i++, mp++) {
+ ml = mloop + mp->loopstart;
+
+ for (j=0; j<mp->totloop; j++, ml++, totloop++) {
+ BLI_array_growone(wlcol);
+
++ calc_weightpaint_vert_color(ob, defbase_tot, coba, origIndex ? origIndex[ml->v] : ml->v,
+ (unsigned char *)&wlcol[totloop], defbase_sel, selected, unselected, draw_flag);
+ }
+ }
+
MEM_freeN(defbase_sel);
- CustomData_add_layer(&dm->faceData, CD_WEIGHT_MCOL, CD_ASSIGN, wtcol, dm->numFaceData);
+ CustomData_add_layer(&dm->loopData, CD_WEIGHT_MLOOPCOL, CD_ASSIGN, wlcol, totloop);
+}
+
+
+static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid)
+{
+ KeyBlock *kb;
+ int i, j, tot;
+
+ if (!me->key)
+ return;
+
+ tot = CustomData_number_of_layers(&dm->vertData, CD_SHAPEKEY);
+ for (i=0; i<tot; i++) {
+ CustomDataLayer *layer = &dm->vertData.layers[CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i)];
+ float (*cos)[3], (*kbcos)[3];
+
+ for (kb=me->key->block.first; kb; kb=kb->next) {
+ if (kb->uid == layer->uid)
+ break;
+ }
+
+ if (!kb) {
+ kb = add_keyblock(me->key, layer->name);
+ kb->uid = layer->uid;
+ }
+
+ if (kb->data)
+ MEM_freeN(kb->data);
+
+ cos = CustomData_get_layer_n(&dm->vertData, CD_SHAPEKEY, i);
+ kb->totelem = dm->numVertData;
+
+ kb->data = kbcos = MEM_mallocN(sizeof(float)*3*kb->totelem, "kbcos DerivedMesh.c");
+ if (kb->uid == actshape_uid) {
+ MVert *mvert = dm->getVertArray(dm);
+
+ for (j=0; j<dm->numVertData; j++, kbcos++, mvert++) {
+ copy_v3_v3(*kbcos, mvert->co);
+ }
+ } else {
+ for (j=0; j<kb->totelem; j++, cos++, kbcos++) {
+ copy_v3_v3(*kbcos, *cos);
+ }
+ }
+ }
+
+ for (kb=me->key->block.first; kb; kb=kb->next) {
+ if (kb->totelem != dm->numVertData) {
+ if (kb->data)
+ MEM_freeN(kb->data);
+
+ kb->totelem = dm->numVertData;
+ kb->data = MEM_callocN(sizeof(float)*3*kb->totelem, "kb->data derivedmesh.c");
+ fprintf(stderr, "%s: lost a shapekey layer! (bmesh internal error)\n", __func__);
+ }
+ }
+}
+
+static void add_shapekey_layers(DerivedMesh *dm, Mesh *me, Object *UNUSED(ob))
+{
+ KeyBlock *kb;
+ Key *key = me->key;
+ int a, b;
+
+ if (!me->key)
+ return;
+
+ if (dm->numVertData != me->totvert) {
+ printf("error in add_shapekey_layers: dm isn't the same size as me\n");
+ return;
+ }
+
+ for (a=0, kb=key->block.first; kb; kb=kb->next, a++) {
+ float (*cos)[3] = CustomData_add_layer_named(&dm->vertData, CD_SHAPEKEY, CD_CALLOC, NULL, dm->numVertData, kb->name);
+ int ci = CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, a);
+
+ dm->vertData.layers[ci].uid = kb->uid;
+ if (kb->totelem != dm->numVertData) {
+ printf("error in add_shapekey_layers: totelem and totvert don't match");
+ continue;
+ }
+
+ for (b=0; b<kb->totelem; b++, cos++) {
+ copy_v3_v3((float *)cos, ((float*)kb->data)+b*3);
+ }
+ }
}
/* new value for useDeform -1 (hack for the gameengine):
MEM_freeN(vtangents);
}
- int totface= dm->getNumFaces(dm);
+ void DM_calc_auto_bump_scale(DerivedMesh *dm)
+ {
+ /* int totvert= dm->getNumVerts(dm); */ /* UNUSED */
- MFace * mface = dm->getFaceArray(dm);
- MTFace * mtface = dm->getFaceDataArray(dm, CD_MTFACE);
++ int totface= dm->getNumTessFaces(dm);
+
+ MVert * mvert = dm->getVertArray(dm);
++ MFace * mface = dm->getTessFaceArray(dm);
++ MTFace * mtface = dm->getTessFaceDataArray(dm, CD_MTFACE);
+
+ if(mtface)
+ {
+ double dsum = 0.0;
+ int nr_accumulated = 0;
+ int f;
+
+ for ( f=0; f<totface; f++ )
+ {
+ {
+ float * verts[4], * tex_coords[4];
+ const int nr_verts = mface[f].v4!=0 ? 4 : 3;
+ int i, is_degenerate;
+
+ verts[0]=mvert[mface[f].v1].co; verts[1]=mvert[mface[f].v2].co; verts[2]=mvert[mface[f].v3].co;
+ tex_coords[0]=mtface[f].uv[0]; tex_coords[1]=mtface[f].uv[1]; tex_coords[2]=mtface[f].uv[2];
+ if(nr_verts==4)
+ {
+ verts[3]=mvert[mface[f].v4].co;
+ tex_coords[3]=mtface[f].uv[3];
+ }
+
+ // discard degenerate faces
+ is_degenerate = 0;
+ if( equals_v3v3(verts[0], verts[1]) || equals_v3v3(verts[0], verts[2]) || equals_v3v3(verts[1], verts[2]) ||
+ equals_v2v2(tex_coords[0], tex_coords[1]) || equals_v2v2(tex_coords[0], tex_coords[2]) || equals_v2v2(tex_coords[1], tex_coords[2]) )
+ {
+ is_degenerate = 1;
+ }
+
+ // verify last vertex as well if this is a quad
+ if ( is_degenerate==0 && nr_verts==4 )
+ {
+ if( equals_v3v3(verts[3], verts[0]) || equals_v3v3(verts[3], verts[1]) || equals_v3v3(verts[3], verts[2]) ||
+ equals_v2v2(tex_coords[3], tex_coords[0]) || equals_v2v2(tex_coords[3], tex_coords[1]) || equals_v2v2(tex_coords[3], tex_coords[2]) )
+ {
+ is_degenerate = 1;
+ }
+
+ // verify the winding is consistent
+ if ( is_degenerate==0 )
+ {
+ float prev_edge[2];
+ int is_signed = 0;
+ sub_v2_v2v2(prev_edge, tex_coords[0], tex_coords[3]);
+
+ i = 0;
+ while ( is_degenerate==0 && i<4 )
+ {
+ float cur_edge[2], signed_area;
+ sub_v2_v2v2(cur_edge, tex_coords[(i+1)&0x3], tex_coords[i]);
+ signed_area = prev_edge[0]*cur_edge[1] - prev_edge[1]*cur_edge[0];
+ if ( i==0 ) is_signed = signed_area<0.0f ? 1 : 0;
+ else if((is_signed!=0)!=(signed_area<0.0f)) is_degenerate=1;
+
+ if ( is_degenerate==0 )
+ {
+ copy_v2_v2(prev_edge, cur_edge);
+ ++i;
+ }
+ }
+ }
+ }
+
+ // proceed if not a degenerate face
+ if ( is_degenerate==0 )
+ {
+ int nr_tris_to_pile=0;
+ // quads split at shortest diagonal
+ int offs = 0; // initial triangulation is 0,1,2 and 0, 2, 3
+ if ( nr_verts==4 )
+ {
+ float pos_len_diag0, pos_len_diag1;
+ float vtmp[3];
+ sub_v3_v3v3(vtmp, verts[2], verts[0]);
+ pos_len_diag0 = dot_v3v3(vtmp, vtmp);
+ sub_v3_v3v3(vtmp, verts[3], verts[1]);
+ pos_len_diag1 = dot_v3v3(vtmp, vtmp);
+
+ if(pos_len_diag1<pos_len_diag0)
+ offs=1; // alter split
+ else if(pos_len_diag0==pos_len_diag1) // do UV check instead
+ {
+ float tex_len_diag0, tex_len_diag1;
+
+ sub_v2_v2v2(vtmp, tex_coords[2], tex_coords[0]);
+ tex_len_diag0 = dot_v2v2(vtmp, vtmp);
+ sub_v2_v2v2(vtmp, tex_coords[3], tex_coords[1]);
+ tex_len_diag1 = dot_v2v2(vtmp, vtmp);
+
+ if(tex_len_diag1<tex_len_diag0)
+ {
+ offs=1; // alter split
+ }
+ }
+ }
+ nr_tris_to_pile = nr_verts-2 ;
+ if ( nr_tris_to_pile==1 || nr_tris_to_pile==2 )
+ {
+ const int indices[] = {offs+0, offs+1, offs+2, offs+0, offs+2, (offs+3)&0x3 };
+ int t;
+ for ( t=0; t<nr_tris_to_pile; t++ )
+ {
+ float f2x_area_uv;
+ float * p0 = verts[indices[t*3+0]];
+ float * p1 = verts[indices[t*3+1]];
+ float * p2 = verts[indices[t*3+2]];
+
+ float edge_t0[2], edge_t1[2];
+ sub_v2_v2v2(edge_t0, tex_coords[indices[t*3+1]], tex_coords[indices[t*3+0]]);
+ sub_v2_v2v2(edge_t1, tex_coords[indices[t*3+2]], tex_coords[indices[t*3+0]]);
+
+ f2x_area_uv = fabsf(edge_t0[0]*edge_t1[1] - edge_t0[1]*edge_t1[0]);
+ if ( f2x_area_uv>FLT_EPSILON )
+ {
+ float norm[3], v0[3], v1[3], f2x_surf_area, fsurf_ratio;
+ sub_v3_v3v3(v0, p1, p0);
+ sub_v3_v3v3(v1, p2, p0);
+ cross_v3_v3v3(norm, v0, v1);
+
+ f2x_surf_area = len_v3(norm);
+ fsurf_ratio = f2x_surf_area/f2x_area_uv; // tri area divided by texture area
+
+ ++nr_accumulated;
+ dsum += (double)(fsurf_ratio);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // finalize
+ {
+ const float avg_area_ratio = (nr_accumulated>0) ? ((float)(dsum / nr_accumulated)) : 1.0f;
+ const float use_as_render_bump_scale = sqrtf(avg_area_ratio); // use width of average surface ratio as your bump scale
+ dm->auto_bump_scale = use_as_render_bump_scale;
+ }
+ }
+ else
+ {
+ dm->auto_bump_scale = 1.0f;
+ }
+ }
+
void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs, DMVertexAttribs *attribs)
{
CustomData *vdata, *fdata, *tfdata = NULL;
memset(attribs, 0, sizeof(DMVertexAttribs));
vdata = &dm->vertData;
- fdata = &dm->faceData;
-
- /* ugly hack, editmesh derivedmesh doesn't copy face data, this way we
- * can use offsets instead */
- if(dm->type == DM_TYPE_EDITMESH)
- tfdata = &((EditMeshDerivedMesh*)dm)->em->fdata;
- else
- tfdata = fdata;
-
+ fdata = tfdata = dm->getTessFaceDataLayout(dm);
+
+ /* calc auto bump scale if necessary */
+ #if 0
+ if(dm->auto_bump_scale<=0.0f)
+ DM_calc_auto_bump_scale(dm);
+ #else
+ dm->auto_bump_scale = 1.0f; // will revert this after release
+ #endif
+
+
/* add a tangent layer if necessary */
for(b = 0; b < gattribs->totlayer; b++)
if(gattribs->layer[b].type == CD_TANGENT)
int (*compareDrawOptions)(void *userData, int cur_index, int next_index),
void *userData, int UNUSED(useColors))
{
- EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
- EditFace *efa;
+ EditDerivedBMesh *bmdm= (EditDerivedBMesh*) dm;
+ BMFace *efa;
- int i, draw;
++ struct BMLoop *(*looptris)[3]= bmdm->tc->looptris;
++ const int tottri= bmdm->tc->tottri;
++ const int lasttri= tottri - 1; /* compare agasint this a lot */
+ int i, draw, flush;
const int skip_normals= !glIsEnabled(GL_LIGHTING); /* could be passed as an arg */
/* GL_ZERO is used to detect if drawing has started or not */
/* currently unused -- each original face is handled separately */
(void)compareDrawOptions;
- if (emdm->vertexCos) {
+ if (bmdm->vertexCos) {
/* add direct access */
- float (*vertexCos)[3]= emdm->vertexCos;
- float (*vertexNos)[3]= emdm->vertexNos;
- float (*faceNos)[3]= emdm->faceNos;
- EditVert *eve;
+ float (*vertexCos)[3]= bmdm->vertexCos;
+ float (*vertexNos)[3]= bmdm->vertexNos;
+ float (*faceNos)[3]= bmdm->faceNos;
+
+ BM_ElemIndex_Ensure(bmdm->tc->bm, BM_VERT | BM_FACE);
- for (i=0; i<bmdm->tc->tottri; i++) {
- BMLoop **l = bmdm->tc->looptris[i];
- for (i=0,eve=emdm->em->verts.first; eve; eve= eve->next)
- eve->tmp.l = (intptr_t) i++;
++ for (i=0; i < tottri; i++) {
++ BMLoop **l = looptris[i];
+ int drawSmooth;
- for (i=0,efa= emdm->em->faces.first; efa; i++,efa= efa->next) {
- int drawSmooth = (efa->flag & ME_SMOOTH);
- draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, i, &drawSmooth);
+ efa = l[0]->f;
+ drawSmooth= BM_TestHFlag(efa, BM_SMOOTH);
+
+ draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_GetIndex(efa), &drawSmooth);
if (draw) {
- const GLenum poly_type= efa->v4 ? GL_QUADS:GL_TRIANGLES;
+ const GLenum poly_type= GL_TRIANGLES; /* BMESH NOTE, this is odd but keep it for now to match trunk */
if (draw==2) { /* enabled with stipple */
if (poly_prev != GL_ZERO) glEnd();
}
}
- if (draw==2) {
+ flush= (draw==2);
- if (!skip_normals && !flush && efa->next)
- flush|= efa->mat_nr != efa->next->mat_nr;
++ if (!skip_normals && !flush && (i != lasttri))
++ flush|= efa->mat_nr != looptris[i + 1][0]->f->mat_nr; /* TODO, make this neater */
+
+ if (flush) {
glEnd();
poly_prev= GL_ZERO; /* force glBegin */
}
}
else {
- for (i=0,efa= emdm->em->faces.first; efa; i++,efa= efa->next) {
- int drawSmooth = (efa->flag & ME_SMOOTH);
- draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, i, &drawSmooth);
+ BM_ElemIndex_Ensure(bmdm->tc->bm, BM_FACE);
+
- for (i=0; i<bmdm->tc->tottri; i++) {
- BMLoop **l = bmdm->tc->looptris[i];
++ for (i=0; i < tottri; i++) {
++ BMLoop **l = looptris[i];
+ int drawSmooth;
+
+ efa = l[0]->f;
+ drawSmooth= BM_TestHFlag(efa, BM_SMOOTH);
+
+ draw = setDrawOptions==NULL ? 1 : setDrawOptions(userData, BM_GetIndex(efa), &drawSmooth);
if (draw) {
- const GLenum poly_type= efa->v4 ? GL_QUADS:GL_TRIANGLES;
+ const GLenum poly_type= GL_TRIANGLES; /* BMESH NOTE, this is odd but keep it for now to match trunk */
if (draw==2) { /* enabled with stipple */
if (poly_prev != GL_ZERO) glEnd();
}
}
- if (!skip_normals && !flush && efa->next)
- flush|= efa->mat_nr != efa->next->mat_nr;
+ flush= (draw==2);
++ if (!skip_normals && !flush && (i != lasttri)) {
++ flush|= efa->mat_nr != looptris[i + 1][0]->f->mat_nr; /* TODO, make this neater */
++ }
- if (draw==2) {
+ if (flush) {
glEnd();
poly_prev= GL_ZERO; /* force glBegin */
static int draw_em_tf_mapped__set_draw(void *userData, int index)
{
- struct {DerivedMesh *dm; BMEditMesh *em; short has_mcol; short has_mtface;} *data = userData;
- struct {EditMesh *em; short has_mcol; short has_mtface; MFace *mf; MTFace *tf;} *data = userData;
- EditMesh *em = data->em;
- EditFace *efa= EM_get_face_for_index(index);
- MTFace *tface;
- int matnr;
++ struct {BMEditMesh *em; short has_mcol; short has_mtface; MFace *mf; MTFace *tf;} *data = userData;
+ BMEditMesh *em = data->em;
+ BMFace *efa= EDBM_get_face_for_index(em, index);
- if (efa->h)
+ if (efa==NULL || BM_TestHFlag(efa, BM_HIDDEN)) {
return 0;
+ }
+ else {
+ MTFace mtf= {{{0}}};
+ int matnr = efa->mat_nr;
+
+ if (data->has_mtface) {
+ MTexPoly *tpoly = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
+ mtf.flag = tpoly->flag;
+ mtf.tpage = tpoly->tpage;
+ mtf.transp = tpoly->transp;
+ mtf.mode = tpoly->mode;
+ mtf.tile = tpoly->tile;
+ mtf.unwrap = tpoly->unwrap;
- tface = data->has_mtface ? CustomData_em_get(&em->fdata, efa->data, CD_MTFACE) : NULL;
- matnr = efa->mat_nr;
+ }
- return draw_tface__set_draw_legacy(tface, data->has_mcol, matnr);
+ return draw_tface__set_draw_legacy(&mtf, data->has_mcol, matnr);
+ }
}
static int wpaint__setSolidDrawOptions(void *userData, int index, int *drawSmooth_r)
static int compareDrawOptionsEm(void *userData, int cur_index, int next_index)
{
- struct {DerivedMesh *dm; EditMesh *em; short has_mcol; short has_mtface;} *data= userData;
- MFace *mf = DM_get_tessface_data_layer(data->dm, CD_MFACE);
- MTFace *tf = DM_get_tessface_data_layer(data->dm, CD_MTFACE);
- struct {EditMesh *em; short has_mcol; short has_mtface; MFace *mf; MTFace *tf;} *data= userData;
++ struct {BMEditMesh *em; short has_mcol; short has_mtface; MFace *mf; MTFace *tf;} *data= userData;
- if(mf && mf[cur_index].mat_nr != mf[next_index].mat_nr)
+ if(data->mf && data->mf[cur_index].mat_nr != data->mf[next_index].mat_nr)
return 0;
- if(tf && tf[cur_index].tpage != tf[next_index].tpage)
+ if(data->tf && data->tf[cur_index].tpage != data->tf[next_index].tpage)
return 0;
return 1;
glColor4f(1.0f,1.0f,1.0f,1.0f);
if(ob->mode & OB_MODE_EDIT) {
- struct {DerivedMesh *dm; BMEditMesh *em; short has_mcol; short has_mtface;} data;
- struct {EditMesh *em; short has_mcol; short has_mtface; MFace *mf; MTFace *tf;} data;
++ struct {BMEditMesh *em; short has_mcol; short has_mtface; MFace *mf; MTFace *tf;} data;
- data.dm = dm;
- data.em= me->edit_mesh;
- data.has_mcol= CustomData_has_layer(&me->edit_mesh->fdata, CD_MCOL);
- data.has_mtface= CustomData_has_layer(&me->edit_mesh->fdata, CD_MTFACE);
- data.mf= DM_get_face_data_layer(dm, CD_MFACE);
- data.tf= DM_get_face_data_layer(dm, CD_MTFACE);
+ data.em= me->edit_btmesh;
+ data.has_mcol= CustomData_has_layer(&me->edit_btmesh->bm->ldata, CD_MLOOPCOL);
+ data.has_mtface= CustomData_has_layer(&me->edit_btmesh->bm->pdata, CD_MTEXPOLY);
++ data.mf= DM_get_tessface_data_layer(dm, CD_MFACE);
++ data.tf= DM_get_tessface_data_layer(dm, CD_MTFACE);
dm->drawMappedFacesTex(dm, draw_em_tf_mapped__set_draw, compareDrawOptionsEm, &data);
}
if(!CustomData_has_layer(&dm->faceData,CD_TEXTURE_MCOL))
add_tface_color_layer(dm);
- dm->drawFacesTex(dm, draw_tface__set_draw, compareDrawOptions, dm);
- userData.mf = DM_get_face_data_layer(dm, CD_MFACE);
- userData.tf = DM_get_face_data_layer(dm, CD_MTFACE);
++ userData.mf = DM_get_tessface_data_layer(dm, CD_MFACE);
++ userData.tf = DM_get_tessface_data_layer(dm, CD_MTFACE);
+
+ dm->drawFacesTex(dm, draw_tface__set_draw, compareDrawOptions, &userData);
}
}
* return 2 for the active face so it renders with stipple enabled */
static int draw_dm_faces_sel__setDrawOptions(void *userData, int index, int *UNUSED(drawSmooth_r))
{
- struct { DerivedMesh *dm; unsigned char *cols[3]; BMEditMesh *em; BMFace *efa_act; Mesh *me;} *data = userData;
- struct { unsigned char *cols[3]; EditFace *efa_act; int *orig_index; } * data = userData;
- EditFace *efa = EM_get_face_for_index(index);
++ struct { DerivedMesh *dm; unsigned char *cols[3]; BMEditMesh *em; BMFace *efa_act; int *orig_index;} *data = userData;
+ BMFace *efa = EDBM_get_face_for_index(data->em, index);
unsigned char *col;
- if (efa->h==0) {
+ if (!efa)
+ return 0;
+
+ if (!BM_TestHFlag(efa, BM_HIDDEN)) {
if (efa == data->efa_act) {
glColor4ubv(data->cols[2]);
return 2; /* stipple */
static int draw_dm_faces_sel__compareDrawOptions(void *userData, int index, int next_index)
{
- struct { DerivedMesh *dm; unsigned char *cols[3]; BMEditMesh *em; BMFace *efa_act; Mesh *me;} * data = userData;
- int *orig_index= DM_get_tessface_data_layer(data->dm, CD_ORIGINDEX);
- struct { unsigned char *cols[3]; EditFace *efa_act; int *orig_index; } *data = userData;
- EditFace *efa;
- EditFace *next_efa;
++
++ struct { DerivedMesh *dm; unsigned char *cols[3]; BMEditMesh *em; BMFace *efa_act; int *orig_index; } * data = userData;
+ BMFace *efa;
+ BMFace *next_efa;
+
unsigned char *col, *next_col;
- if(!orig_index)
+ if(!data->orig_index)
return 0;
- efa= EDBM_get_face_for_index(data->em, orig_index[index]);
- next_efa= EDBM_get_face_for_index(data->em, orig_index[next_index]);
- efa= EM_get_face_for_index(data->orig_index[index]);
- next_efa= EM_get_face_for_index(data->orig_index[next_index]);
++ efa= EDBM_get_face_for_index(data->em, data->orig_index[index]);
++ next_efa= EDBM_get_face_for_index(data->em, data->orig_index[next_index]);
if(efa == next_efa)
return 1;
}
/* also draws the active face */
-static void draw_dm_faces_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditFace *efa_act)
+static void draw_dm_faces_sel(BMEditMesh *em, DerivedMesh *dm, unsigned char *baseCol,
- unsigned char *selCol, unsigned char *actCol, BMFace *efa_act, Mesh *me)
++ unsigned char *selCol, unsigned char *actCol, BMFace *efa_act)
{
- struct { DerivedMesh *dm; unsigned char *cols[3]; BMEditMesh *em; BMFace *efa_act; Mesh *me;} data;
- struct { unsigned char *cols[3]; EditFace *efa_act; int *orig_index; } data;
++ struct { DerivedMesh *dm; unsigned char *cols[3]; BMEditMesh *em; BMFace *efa_act; int *orig_index; } data;
+ data.dm= dm;
data.cols[0] = baseCol;
+ data.em = em;
data.cols[1] = selCol;
data.cols[2] = actCol;
data.efa_act = efa_act;
- data.me = me;
- data.orig_index = DM_get_face_data_layer(dm, CD_ORIGINDEX);
++ data.orig_index = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
dm->drawMappedFaces(dm, draw_dm_faces_sel__setDrawOptions, GPU_enable_material, draw_dm_faces_sel__compareDrawOptions, &data, 0);
}
if CHECK_OB_DRAWTEXTURE(v3d, dt)
col1[3] = 0;
- draw_dm_faces_sel(em, cageDM, col1, col2, col3, efa_act, me);
- draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act);
++ draw_dm_faces_sel(em, cageDM, col1, col2, col3, efa_act);
glDisable(GL_BLEND);
glDepthMask(1); // restore write in zbuffer
glEnable(GL_BLEND);
glDepthMask(0); // disable write in zbuffer, needed for nice transp
- draw_dm_faces_sel(em, cageDM, col1, col2, col3, efa_act, me);
- draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act);
++ draw_dm_faces_sel(em, cageDM, col1, col2, col3, efa_act);
glDisable(GL_BLEND);
glDepthMask(1); // restore write in zbuffer
projects / blender-staging.git / commitdiff