kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

- made some DerivedMesh drawing functions more generic (take callback

Browse Source 
to determine if element should be drawn and to set draw options),
   which meant some could be combined - eases implementation of new
   DerivedMesh types and keeps more app specific logic out of DerivedMesh
   implementations.
This commit is contained in:
Daniel Dunbar 2005-03-30 00:32:10 +00:00
parent 340748fd5c
commit cfd90889e2
4 changed files with 217 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
source/blender/blenkernel/BKE_DerivedMesh.h
View File

@ -94,55 +94,33 @@ struct DerivedMesh {
*/
void (*drawFacesTex)(DerivedMesh *dm, int (*setDrawParams)(TFace *tf, int matnr));
/* Draw single mapped vert as bgl point (no options) */
void (*drawMappedVertEM)(DerivedMesh *dm, void *vert);
/* Draw mapped vertices as bgl points
* o Only if mapped EditVert->h==0
* o Only if !setDrawOptions or setDrawOptions(userData, mapped-vert) returns true
*/
void (*drawMappedVertsEM)(DerivedMesh *dm, int sel);
void (*drawMappedVertsEM)(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *vert), void *userData);
/* Draw single mapped edge as lines (no options) */
void (*drawMappedEdgeEM)(DerivedMesh *dm, void *edge);
/* Draw mapped edges as lines
* o If useColor==0, don't set color
* o If useColor==1, set color based on mapped (EditEdge->f&SELECT)
* o If useColor==2, set color based on mapped (EditVert->f&SELECT)
* - Should interpolate as nicely as possible across edge.
* o If onlySeams, only draw if mapped (EditEdge->seam)
* o Only if mapped EditEdge->h==0
* o Only if !setDrawOptions or setDrawOptions(userData, mapped-edge) returns true
*/
void (*drawMappedEdgesEM)(DerivedMesh *dm, int useColor, unsigned char *baseCol, unsigned char *selCol, int onlySeams);
void (*drawMappedEdgesEM)(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *edge), void *userData);
/* Draw mapped edges as lines with interpolation values
* o Only if !setDrawOptions or setDrawOptions(userData, mapped-edge, mapped-v0, mapped-v1, t) returns true
*
* NOTE: This routine is optional!
*/
void (*drawMappedEdgesInterpEM)(DerivedMesh *dm,
int (*setDrawOptions)(void *userData, void *edge),
void (*setDrawInterpOptions)(void *userData, void *edge, float t),
void *userData);
/* Draw all faces
* o If useColor, set color based on mapped (EditFace->f&SELECT)
* o Only if !setDrawOptions or setDrawOptions(userData, mapped-face) returns true
*/
void (*drawFacesEM)(DerivedMesh *dm, int useColor, unsigned char *baseCol, unsigned char *selCol);
/* Draw mapped verts as bgl points
* o Call setColor(offset+index) for each vert, where index is the
* vert's index in the EditMesh. Return offset+count where count
* is the total number of mapped verts.
* o Only if mapped EditVert->h==0
*/
int (*drawMappedVertsEMSelect)(DerivedMesh *dm, void (*setColor)(int index), int offset);
/* Draw mapped edges as lines
* o Call setColor(offset+index) for each edge, where index is the
* edge's index in the EditMesh. Return offset+count where count
* is the total number of mapped edges.
* o Only if mapped EditEdge->h==0
*/
int (*drawMappedEdgesEMSelect)(DerivedMesh *dm, void (*setColor)(int index), int offset);
/* Draw mapped faces
* o Call setColor(offset+index) for each face, where index is the
* face's index in the EditMesh. Return offset+count where count
* is the total number of mapped faces.
* o Only if mapped EditFace->h==0
*/
int (*drawMappedFacesEMSelect)(DerivedMesh *dm, void (*setColor)(int index), int offset);
void (*drawMappedFacesEM)(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *face), void *userData);
void (*release)(DerivedMesh *dm);
};

218
source/blender/blenkernel/intern/DerivedMesh.c
View File

@ -386,22 +386,18 @@ static DerivedMesh *getMeshDerivedMesh(Object *ob, float *extverts, float *nors)
mdm->dm.convertToDispListMesh = meshDM_convertToDispListMesh;
mdm->dm.drawVerts = meshDM_drawVerts;
mdm->dm.drawMappedVertEM = NULL;
mdm->dm.drawMappedVertsEM = NULL;
mdm->dm.drawMappedVertsEMSelect = NULL;
mdm->dm.drawEdges = meshDM_drawEdges;
mdm->dm.drawMappedEdges = meshDM_drawEdges;
mdm->dm.drawLooseEdges = meshDM_drawLooseEdges;
mdm->dm.drawMappedEdgeEM = NULL;
mdm->dm.drawMappedEdgesEM = NULL;
mdm->dm.drawMappedEdgesEMSelect = NULL;
mdm->dm.drawMappedFacesEMSelect = NULL;
mdm->dm.drawFacesSolid = meshDM_drawFacesSolid;
mdm->dm.drawFacesColored = meshDM_drawFacesColored;
mdm->dm.drawFacesTex = meshDM_drawFacesTex;
mdm->dm.drawFacesEM = NULL;
mdm->dm.drawMappedFacesEM = NULL;
mdm->dm.release = MEM_freeN;
@ -428,43 +424,18 @@ static void emDM_getMappedVertCoEM(DerivedMesh *dm, void *vert, float co_r[3])
co_r[1] = eve->co[1];
co_r[2] = eve->co[2];
}
static void emDM_drawMappedVertEM(DerivedMesh *dm, void *vert)
{
EditVert *eve = vert;
bglBegin(GL_POINTS);
bglVertex3fv(eve->co);
bglEnd();
}
static void emDM_drawMappedVertsEM(DerivedMesh *dm, int sel)
static void emDM_drawMappedVertsEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *vert), void *userData)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
EditVert *eve;
bglBegin(GL_POINTS);
for(eve= emdm->em->verts.first; eve; eve= eve->next) {
if(eve->h==0 && (eve->f & SELECT)==sel )
if(!setDrawOptions || setDrawOptions(userData, eve))
bglVertex3fv(eve->co);
}
bglEnd();
}
static int emDM_drawMappedVertsEMSelect(DerivedMesh *dm, void (*setColor)(int index), int offset)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
EditVert *eve;
int i = offset;
bglBegin(GL_POINTS);
for(eve= emdm->em->verts.first; eve; eve= eve->next, i++) {
if(eve->h==0) {
setColor(i);
bglVertex3fv(eve->co);
}
}
bglEnd();
return i;
}
static void emDM_drawMappedEdgeEM(DerivedMesh *dm, void *edge)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
@ -475,58 +446,43 @@ static void emDM_drawMappedEdgeEM(DerivedMesh *dm, void *edge)
glVertex3fv(eed->v2->co);
glEnd();
}
static void emDM_drawMappedEdgesEM(DerivedMesh *dm, int useColor, char *baseCol, char *selCol, int onlySeams)
static void emDM_drawMappedEdgesEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *edge), void *userData)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
EditEdge *eed;
glBegin(GL_LINES);
for(eed= emdm->em->edges.first; eed; eed= eed->next) {
if(eed->h==0 && (!onlySeams || eed->seam)) {
if (useColor==1) {
glColor4ubv((eed->f&SELECT)?selCol:baseCol);
} else if (useColor==2) {
glColor4ubv((eed->v1->f&SELECT)?selCol:baseCol);
}
if(!setDrawOptions || setDrawOptions(userData, eed)) {
glVertex3fv(eed->v1->co);
if (useColor==2) {
glColor4ubv((eed->v2->f&SELECT)?selCol:baseCol);
}
glVertex3fv(eed->v2->co);
}
}
glEnd();
}
static int emDM_drawMappedEdgesEMSelect(DerivedMesh *dm, void (*setColor)(int index), int offset)
static void emDM_drawMappedEdgesInterpEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *edge), void (*setDrawInterpOptions)(void *userData, void *edge, float t), void *userData)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
EditEdge *eed;
int i;
i = offset;
glBegin(GL_LINES);
for(eed= emdm->em->edges.first; eed; eed= eed->next, i++) {
if (eed->h==0) {
setColor(i);
for(eed= emdm->em->edges.first; eed; eed= eed->next) {
if(!setDrawOptions || setDrawOptions(userData, eed)) {
setDrawInterpOptions(userData, eed, 0.0);
glVertex3fv(eed->v1->co);
setDrawInterpOptions(userData, eed, 1.0);
glVertex3fv(eed->v2->co);
}
}
glEnd();
return i;
}
static void emDM_drawFacesEM(DerivedMesh *dm, int useColor, unsigned char *baseCol, unsigned char *selCol)
static void emDM_drawMappedFacesEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *face), void *userData)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
EditFace *efa;
for (efa= emdm->em->faces.first; efa; efa= efa->next) {
if(efa->h==0) {
if (useColor) {
glColor4ubv((efa->f & SELECT)?selCol:baseCol);
}
if(!setDrawOptions || setDrawOptions(userData, efa)) {
glBegin(efa->v4?GL_QUADS:GL_TRIANGLES);
glVertex3fv(efa->v1->co);
glVertex3fv(efa->v2->co);
@ -555,27 +511,6 @@ static void emDM_drawFacesSolid(DerivedMesh *dm, void (*setMaterial)(int))
}
}
}
static int emDM_drawMappedFacesEMSelect(DerivedMesh *dm, void (*setColor)(int index), int offset)
{
EditMeshDerivedMesh *emdm= (EditMeshDerivedMesh*) dm;
EditFace *efa;
int i = offset;
for (efa= emdm->em->faces.first; efa; efa= efa->next, i++) {
if (efa->h==0) {
setColor(i);
glBegin(efa->v4?GL_QUADS:GL_TRIANGLES);
glVertex3fv(efa->v1->co);
glVertex3fv(efa->v2->co);
glVertex3fv(efa->v3->co);
if(efa->v4) glVertex3fv(efa->v4->co);
glEnd();
}
}
return i;
}
static int emDM_getNumVerts(DerivedMesh *dm)
{
@ -607,22 +542,19 @@ static DerivedMesh *getEditMeshDerivedMesh(EditMesh *em)
emdm->dm.convertToDispListMesh = emDM_convertToDispListMesh;
emdm->dm.drawVerts = NULL;
emdm->dm.drawMappedVertEM = emDM_drawMappedVertEM;
emdm->dm.drawMappedVertsEM = emDM_drawMappedVertsEM;
emdm->dm.drawMappedVertsEMSelect = emDM_drawMappedVertsEMSelect;
emdm->dm.drawEdges = NULL;
emdm->dm.drawMappedEdges = NULL;
emdm->dm.drawLooseEdges = NULL;
emdm->dm.drawMappedEdgeEM = emDM_drawMappedEdgeEM;
emdm->dm.drawMappedEdgesEM = emDM_drawMappedEdgesEM;
emdm->dm.drawMappedEdgesEMSelect = emDM_drawMappedEdgesEMSelect;
emdm->dm.drawMappedFacesEMSelect = emDM_drawMappedFacesEMSelect;
emdm->dm.drawMappedEdgesInterpEM = emDM_drawMappedEdgesInterpEM;
emdm->dm.drawFacesSolid = emDM_drawFacesSolid;
emdm->dm.drawFacesColored = NULL;
emdm->dm.drawFacesTex = NULL;
emdm->dm.drawFacesEM = emDM_drawFacesEM;
emdm->dm.drawMappedFacesEM = emDM_drawMappedFacesEM;
emdm->dm.release = MEM_freeN;
@ -650,43 +582,18 @@ static void ssDM_getMappedVertCoEM(DerivedMesh *dm, void *vert, float co_r[3])
co_r[1] = eve->ssco[1];
co_r[2] = eve->ssco[2];
}
static void ssDM_drawMappedVertEM(DerivedMesh *dm, void *vert)
{
EditVert *eve = vert;
bglBegin(GL_POINTS);
bglVertex3fv(eve->ssco);
bglEnd();
}
static void ssDM_drawMappedVertsEM(DerivedMesh *dm, int sel)
static void ssDM_drawMappedVertsEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *vert), void *userData)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
EditVert *eve;
bglBegin(GL_POINTS);
for (eve=ssdm->em->verts.first; eve; eve=eve->next) {
if(eve->h==0 && (eve->f & SELECT)==sel && eve->ssco)
if(eve->ssco && (!setDrawOptions || setDrawOptions(userData, eve)))
bglVertex3fv(eve->ssco);
}
bglEnd();
}
static int ssDM_drawMappedVertsEMSelect(DerivedMesh *dm, void (*setColor)(int index), int offset)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
EditVert *eve;
int i = offset;
bglBegin(GL_POINTS);
for(eve= ssdm->em->verts.first; eve; eve= eve->next, i++) {
if(eve->h==0 && eve->ssco) {
setColor(i);
bglVertex3fv(eve->ssco);
}
}
bglEnd();
return i;
}
static void ssDM_drawMappedEdges(DerivedMesh *dm)
{
@ -730,7 +637,7 @@ static void ssDM_drawMappedEdgeEM(DerivedMesh *dm, void *edge)
}
glEnd();
}
static void ssDM_drawMappedEdgesEM(DerivedMesh *dm, int useColor, unsigned char *baseCol, unsigned char *selCol, int onlySeams)
static void ssDM_drawMappedEdgesEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *edge), void *userData)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
DispListMesh *dlm = ssdm->dlm;
@ -743,10 +650,7 @@ static void ssDM_drawMappedEdgesEM(DerivedMesh *dm, int useColor, unsigned char
if (medge->flag&ME_EDGEDRAW) {
EditEdge *eed = dlm->editedge[a];
if (eed && eed->h==0 && (!onlySeams || eed->seam)) {
if (useColor) {
glColor4ubv((eed->f&SELECT)?selCol:baseCol);
}
if (eed && (!setDrawOptions || setDrawOptions(userData, eed))) {
glVertex3fv(mvert[medge->v1].co);
glVertex3fv(mvert[medge->v2].co);
}
@ -754,35 +658,6 @@ static void ssDM_drawMappedEdgesEM(DerivedMesh *dm, int useColor, unsigned char
}
glEnd();
}
static int ssDM_drawMappedEdgesEMSelect(DerivedMesh *dm, void (*setColor)(int index), int offset)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
DispListMesh *dlm = ssdm->dlm;
int i, endOffset;
MVert *mvert= dlm->mvert;
MEdge *medge= dlm->medge;
EditEdge *eed;
i = offset;
for(eed= ssdm->em->edges.first; eed; eed= eed->next)
eed->vn= (EditVert*) i++;
endOffset = i;
glBegin(GL_LINES);
for (i=0; i<dlm->totedge; i++, medge++) {
if(medge->flag & ME_EDGEDRAW) {
EditEdge *eed= dlm->editedge[i];
if(eed && eed->h==0) {
setColor((int) eed->vn);
glVertex3fv(mvert[medge->v1].co);
glVertex3fv(mvert[medge->v2].co);
}
}
}
glEnd();
return endOffset;
}
static void ssDM_drawVerts(DerivedMesh *dm)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
@ -938,7 +813,7 @@ static void ssDM_drawFacesColored(DerivedMesh *dm, int useTwoSided, unsigned cha
#undef PASSVERT
}
static void ssDM_drawFacesEM(DerivedMesh *dm, int useColor, unsigned char *baseCol, unsigned char *selCol)
static void ssDM_drawMappedFacesEM(DerivedMesh *dm, int (*setDrawOptions)(void *userData, void *face), void *userData)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
DispListMesh *dlm = ssdm->dlm;
@ -947,49 +822,17 @@ static void ssDM_drawFacesEM(DerivedMesh *dm, int useColor, unsigned char *baseC
for(a=0; a<dlm->totface; a++, mface++) {
if(mface->v3) {
if (useColor) {
glColor4ubv((dlm->editface[a]->f & SELECT)?selCol:baseCol);
if (!setDrawOptions || setDrawOptions(userData, dlm->editface[a])) {
glBegin(mface->v4?GL_QUADS:GL_TRIANGLES);
glVertex3fv(dlm->mvert[mface->v1].co);
glVertex3fv(dlm->mvert[mface->v2].co);
glVertex3fv(dlm->mvert[mface->v3].co);
if (mface->v4) glVertex3fv(dlm->mvert[mface->v4].co);
glEnd();
}
glBegin(mface->v4?GL_QUADS:GL_TRIANGLES);
glVertex3fv(dlm->mvert[mface->v1].co);
glVertex3fv(dlm->mvert[mface->v2].co);
glVertex3fv(dlm->mvert[mface->v3].co);
if (mface->v4) glVertex3fv(dlm->mvert[mface->v4].co);
glEnd();
}
}
}
static int ssDM_drawMappedFacesEMSelect(DerivedMesh *dm, void (*setColor)(int index), int offset)
{
SSDerivedMesh *ssdm = (SSDerivedMesh*) dm;
DispListMesh *dlm = ssdm->dlm;
MFace *mface= dlm->mface;
int i, endOffset;
EditFace *prevefa, *efa;
for (i=offset, efa=ssdm->em->faces.first; efa; efa= efa->next, i++)
efa->prev = (EditFace*) i;
endOffset = i;
for(i=0; i<dlm->totface; i++, mface++) {
if(mface->v3 && dlm->editface[i]->h==0) {
setColor((int) dlm->editface[i]->prev);
glBegin(mface->v4?GL_QUADS:GL_TRIANGLES);
glVertex3fv(dlm->mvert[mface->v1].co);
glVertex3fv(dlm->mvert[mface->v2].co);
glVertex3fv(dlm->mvert[mface->v3].co);
if (mface->v4) glVertex3fv(dlm->mvert[mface->v4].co);
glEnd();
}
}
for (prevefa= NULL, efa= ssdm->em->faces.first; efa; prevefa= efa, efa= efa->next)
efa->prev= prevefa;
return endOffset;
}
static void ssDM_drawFacesTex(DerivedMesh *dm, int (*setDrawParams)(TFace *tf, int matnr))
{
@ -1087,22 +930,19 @@ DerivedMesh *derivedmesh_from_displistmesh(EditMesh *em, DispListMesh *dlm)
ssdm->dm.convertToDispListMesh = ssDM_convertToDispListMesh;
ssdm->dm.drawVerts = ssDM_drawVerts;
ssdm->dm.drawMappedVertEM = ssDM_drawMappedVertEM;
ssdm->dm.drawMappedVertsEM = ssDM_drawMappedVertsEM;
ssdm->dm.drawMappedVertsEMSelect = ssDM_drawMappedVertsEMSelect;
ssdm->dm.drawEdges = ssDM_drawEdges;
ssdm->dm.drawMappedEdges = ssDM_drawMappedEdges;
ssdm->dm.drawLooseEdges = ssDM_drawLooseEdges;
ssdm->dm.drawMappedEdgeEM = ssDM_drawMappedEdgeEM;
ssdm->dm.drawMappedEdgesEM = ssDM_drawMappedEdgesEM;
ssdm->dm.drawMappedEdgesEMSelect = ssDM_drawMappedEdgesEMSelect;
ssdm->dm.drawMappedFacesEMSelect = ssDM_drawMappedFacesEMSelect;
ssdm->dm.drawMappedEdgesInterpEM = NULL;
ssdm->dm.drawFacesSolid = ssDM_drawFacesSolid;
ssdm->dm.drawFacesColored = ssDM_drawFacesColored;
ssdm->dm.drawFacesTex = ssDM_drawFacesTex;
ssdm->dm.drawFacesEM = ssDM_drawFacesEM;
ssdm->dm.drawMappedFacesEM = ssDM_drawMappedFacesEM;
ssdm->dm.release = ssDM_release;

184
source/blender/src/drawobject.c
View File

@ -1197,10 +1197,6 @@ static unsigned char *calc_weightpaint_colors(Object *ob)
* logic!!!
*/
// draw editmesh face normals as lines
// o no color
// o only if efa->h==0, efa->fgonf!=EM_FGON
// o scale normal by normalLength parameter
static void draw_em_face_normals(EditMesh *em, float normalLength)
{
EditFace *efa;
@ -1218,9 +1214,6 @@ static void draw_em_face_normals(EditMesh *em, float normalLength)
glEnd();
}
// draw editmesh face centers as bgl points
// o no color
// o only if efa->h, efa->fgonf!=EM_FGON, matching sel
static void draw_em_face_centers(EditMesh *em, int sel) {
EditFace *efa;
@ -1233,6 +1226,101 @@ static void draw_em_face_centers(EditMesh *em, int sel) {
bglEnd();
}
/* Draw verts with color set based on selection */
static int draw_dm_verts__setDrawOptions(void *userData, void *vert)
{
EditVert *eve = vert;
int sel = *((int*) userData);
return (eve->h==0 && (eve->f&SELECT)==sel);
}
static void draw_dm_verts(DerivedMesh *dm, int sel)
{
dm->drawMappedVertsEM(dm, draw_dm_verts__setDrawOptions, &sel);
}
/* Draw edges with color set based on selection */
static int draw_dm_edges_sel__setDrawOptions(void *userData, void *edge)
{
EditEdge *eed = edge;
unsigned char **cols = userData;
if (eed->h==0) {
glColor4ubv(cols[(eed->f&SELECT)?1:0]);
return 1;
} else {
return 0;
}
}
static void draw_dm_edges_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol)
{
unsigned char *cols[2];
cols[0] = baseCol;
cols[1] = selCol;
dm->drawMappedEdgesEM(dm, draw_dm_edges_sel__setDrawOptions, cols);
}
/* Draw edges with color interpolated based on selection */
static int draw_dm_edges_sel_interp__setDrawOptions(void *userData, void *edge)
{
EditEdge *eed = edge;
return (eed->h==0);
}
static void draw_dm_edges_sel_interp__setDrawInterpOptions(void *userData, void *edge, float t)
{
EditEdge *eed = edge;
unsigned char **cols = userData;
unsigned char *col0 = cols[(eed->v1->f&SELECT)?1:0];
unsigned char *col1 = cols[(eed->v2->f&SELECT)?1:0];
glColor4ub( col0[0] + (col1[0]-col0[0])*t,
col0[1] + (col1[1]-col0[1])*t,
col0[2] + (col1[2]-col0[2])*t,
col0[3] + (col1[3]-col0[3])*t);
}
static void draw_dm_edges_sel_interp(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol)
{
unsigned char *cols[2];
cols[0] = baseCol;
cols[1] = selCol;
dm->drawMappedEdgesInterpEM(dm, draw_dm_edges_sel_interp__setDrawOptions, draw_dm_edges_sel_interp__setDrawInterpOptions, cols);
}
/* Draw only seam edges */
static int draw_dm_edges_seams__setDrawOptions(void *userData, void *edge)
{
EditEdge *eed = edge;
return (eed->h==0 && eed->seam);
}
static void draw_dm_edges_seams(DerivedMesh *dm)
{
dm->drawMappedVertsEM(dm, draw_dm_edges_seams__setDrawOptions, NULL);
}
/* Draw faces with color set based on selection */
static int draw_dm_faces_sel__setDrawOptions(void *userData, void *face)
{
EditFace *efa = face;
unsigned char **cols = userData;
if (efa->h==0) {
glColor4ubv(cols[(efa->f&SELECT)?1:0]);
return 1;
} else {
return 0;
}
}
static void draw_dm_faces_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol)
{
unsigned char *cols[2];
cols[0] = baseCol;
cols[1] = selCol;
dm->drawMappedFacesEM(dm, draw_dm_faces_sel__setDrawOptions, cols);
}
/* Second section of routines: Combine first sets to form fancy
* drawing routines (for example rendering twice to get overlays).
*
@ -1279,7 +1367,7 @@ static void draw_em_fancy_verts(EditMesh *em, DerivedMesh *cageDM)
if(G.scene->selectmode & SCE_SELECT_VERTEX) {
glPointSize(size);
glColor4ubv(col);
cageDM->drawMappedVertsEM(cageDM, sel);
draw_dm_verts(cageDM, sel);
}
if(G.scene->selectmode & SCE_SELECT_FACE) {
@ -1325,20 +1413,20 @@ static void draw_em_fancy_edges(DerivedMesh *cageDM)
}
if(G.scene->selectmode == SCE_SELECT_FACE) {
cageDM->drawMappedEdgesEM(cageDM, 1, wire, sel, 0);
draw_dm_edges_sel(cageDM, wire, sel);
}
else if( (G.f & G_DRAWEDGES) || (G.scene->selectmode & SCE_SELECT_EDGE) ) {
if(G.scene->selectmode & SCE_SELECT_VERTEX) {
if(cageDM->drawMappedEdgesInterpEM && (G.scene->selectmode & SCE_SELECT_VERTEX)) {
glShadeModel(GL_SMOOTH);
cageDM->drawMappedEdgesEM(cageDM, 2, wire, sel, 0);
draw_dm_edges_sel_interp(cageDM, wire, sel);
glShadeModel(GL_FLAT);
} else {
cageDM->drawMappedEdgesEM(cageDM, 1, wire, sel, 0);
draw_dm_edges_sel(cageDM, wire, sel);
}
}
else {
glColor4ubv(wire);
cageDM->drawMappedEdgesEM(cageDM, 0, NULL, NULL, 0);
cageDM->drawMappedEdgesEM(cageDM, NULL, NULL);
}
if (pass==0) {
@ -1533,7 +1621,7 @@ static void draw_em_fancy(Object *ob, EditMesh *em, DerivedMesh *baseDM, Derived
if (realDM) {
BIF_ThemeColorBlend(TH_WIRE, TH_BACK, 0.7);
if (me->flag&ME_OPT_EDGES) {
realDM->drawMappedEdgesEM(realDM, 0, NULL, NULL, 0);
realDM->drawMappedEdgesEM(realDM, NULL, NULL);
} else {
realDM->drawEdges(realDM);
}
@ -1550,7 +1638,7 @@ static void draw_em_fancy(Object *ob, EditMesh *em, DerivedMesh *baseDM, Derived
glEnable(GL_BLEND);
glDepthMask(0); // disable write in zbuffer, needed for nice transp
cageDM->drawFacesEM(cageDM, 1, col1, col2);
draw_dm_faces_sel(cageDM, col1, col2);
glDisable(GL_BLEND);
glDepthMask(1); // restore write in zbuffer
@ -1562,7 +1650,7 @@ static void draw_em_fancy(Object *ob, EditMesh *em, DerivedMesh *baseDM, Derived
BIF_ThemeColor(TH_EDGE_SEAM);
glLineWidth(2);
cageDM->drawMappedEdgesEM(cageDM, 0, NULL, NULL, 1);
draw_dm_edges_seams(cageDM);
glColor3ub(0,0,0);
glLineWidth(1);
@ -3630,22 +3718,68 @@ void draw_object_ext(Base *base)
/* ***************** BACKBUF SEL (BBS) ********* */
static int bbs_mesh_verts__setDrawOptions(void *userData, void *vert)
{
EditVert *eve = vert;
if (eve->h==0) {
set_framebuffer_index_color((int) eve->prev);
return 1;
} else {
return 0;
}
}
static int bbs_mesh_verts(DerivedMesh *dm, int offset)
{
int retval;
EditVert *eve, *preveve;
for (eve=G.editMesh->verts.first; eve; eve= eve->next)
eve->prev = (EditVert*) offset++;
glPointSize( BIF_GetThemeValuef(TH_VERTEX_SIZE) );
retval = dm->drawMappedVertsEMSelect(dm, set_framebuffer_index_color, offset);
dm->drawMappedVertsEM(dm, bbs_mesh_verts__setDrawOptions, NULL);
glPointSize(1.0);
return retval;
for (preveve=NULL, eve=G.editMesh->verts.first; eve; preveve=eve, eve= eve->next)
eve->prev = eve;
return offset;
}
static int bbs_mesh_wire__setDrawOptions(void *userData, void *edge)
{
EditEdge *eed = edge;
if (eed->h==0) {
set_framebuffer_index_color((int) eed->vn);
return 1;
} else {
return 0;
}
}
static int bbs_mesh_wire(DerivedMesh *dm, int offset)
{
return dm->drawMappedEdgesEMSelect(dm, set_framebuffer_index_color, offset);
EditEdge *eed;
for(eed= G.editMesh->edges.first; eed; eed= eed->next)
eed->vn= (EditVert*) offset++;
dm->drawMappedEdgesEM(dm, bbs_mesh_wire__setDrawOptions, NULL);
return offset;
}
static int bbs_mesh_solid__setDrawOptions(void *userData, void *face)
{
EditFace *efa = face;
if (efa->h==0) {
set_framebuffer_index_color((int) efa->prev);
return 1;
} else {
return 0;
}
}
/* two options, facecolors or black */
static int bbs_mesh_solid(Object *ob, DerivedMesh *dm, int facecol)
{
@ -3658,13 +3792,13 @@ static int bbs_mesh_solid(Object *ob, DerivedMesh *dm, int facecol)
EditFace *efa, *prevefa;
int b;
dm->drawMappedFacesEMSelect(dm, set_framebuffer_index_color, 1);
// tuck original indices in efa->prev
for(b=1, efa= G.editMesh->faces.first; efa; efa= efa->next, b++)
efa->prev= (EditFace *)(b);
a = b;
dm->drawMappedFacesEM(dm, bbs_mesh_solid__setDrawOptions, NULL);
if(G.scene->selectmode & SCE_SELECT_FACE) {
glPointSize(BIF_GetThemeValuef(TH_FACEDOT_SIZE));
@ -3682,7 +3816,7 @@ static int bbs_mesh_solid(Object *ob, DerivedMesh *dm, int facecol)
efa->prev= prevefa;
return a;
} else {
dm->drawFacesEM(dm, 0, NULL, NULL);
dm->drawMappedFacesEM(dm, NULL, NULL);
return 1;
}
}

16
source/blender/src/editmesh_mods.c
View File

@ -685,21 +685,31 @@ static void unified_select_draw(EditVert *eve, EditEdge *eed, EditFace *efa)
dm->drawMappedEdgeEM(dm, eed);
}
if(G.scene->selectmode & SCE_SELECT_VERTEX) {
float co[3];
glPointSize(BIF_GetThemeValuef(TH_VERTEX_SIZE));
BIF_ThemeColor((eed->f & SELECT)?TH_VERTEX_SELECT:TH_VERTEX);
dm->drawMappedVertEM(dm, eed->v1);
dm->drawMappedVertEM(dm, eed->v2);
bglBegin(GL_POINTS);
dm->getMappedVertCoEM(dm, eed->v1, co);
bglVertex3fv(co);
dm->getMappedVertCoEM(dm, eed->v2, co);
bglVertex3fv(co);
bglEnd();
}
}
if(eve) {
if(G.scene->selectmode & SCE_SELECT_VERTEX) {
float co[3];
glPointSize(BIF_GetThemeValuef(TH_VERTEX_SIZE));
BIF_ThemeColor((eve->f & SELECT)?TH_VERTEX_SELECT:TH_VERTEX);
dm->drawMappedVertEM(dm, eve);
bglBegin(GL_POINTS);
dm->getMappedVertCoEM(dm, eve, co);
bglVertex3fv(co);
bglEnd();
}
}