griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

style cleanup: operator/whitespace

Browse Source
This commit is contained in:
Campbell Barton
2012-03-24 11:27:52 +00:00
parent 6378606d64
commit e99a23fc6b
1 changed files with 449 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

896
source/blender/editors/sculpt_paint/paint_vertex.c
View File

@@ -131,10 +131,10 @@ int vertex_paint_poll(bContext *C)
{
if (vertex_paint_mode_poll(C) &&
paint_brush(&CTX_data_tool_settings(C)->vpaint->paint)) {
ScrArea *sa= CTX_wm_area(C);
if (sa->spacetype==SPACE_VIEW3D) {
ARegion *ar= CTX_wm_region(C);
if (ar->regiontype==RGN_TYPE_WINDOW)
ScrArea *sa = CTX_wm_area(C);
if (sa->spacetype == SPACE_VIEW3D) {
ARegion *ar = CTX_wm_region(C);
if (ar->regiontype == RGN_TYPE_WINDOW)
return 1;
}
}
@@ -150,17 +150,17 @@ int weight_paint_mode_poll(bContext *C)
int weight_paint_poll(bContext *C)
{
Object *ob= CTX_data_active_object(C);
Object *ob = CTX_data_active_object(C);
ScrArea *sa;
if ( (ob != NULL) &&
(ob->mode & OB_MODE_WEIGHT_PAINT) &&
(paint_brush(&CTX_data_tool_settings(C)->wpaint->paint) != NULL) &&
(sa= CTX_wm_area(C)) &&
(sa->spacetype == SPACE_VIEW3D)
) {
ARegion *ar= CTX_wm_region(C);
if (ar->regiontype==RGN_TYPE_WINDOW) {
if ((ob != NULL) &&
(ob->mode & OB_MODE_WEIGHT_PAINT) &&
(paint_brush(&CTX_data_tool_settings(C)->wpaint->paint) != NULL) &&
(sa = CTX_wm_area(C)) &&
(sa->spacetype == SPACE_VIEW3D))
{
ARegion *ar = CTX_wm_region(C);
if (ar->regiontype == RGN_TYPE_WINDOW) {
return 1;
}
}
@@ -169,19 +169,19 @@ int weight_paint_poll(bContext *C)
static VPaint *new_vpaint(int wpaint)
{
VPaint *vp= MEM_callocN(sizeof(VPaint), "VPaint");
VPaint *vp = MEM_callocN(sizeof(VPaint), "VPaint");
vp->flag= VP_AREA+VP_SPRAY;
vp->flag = VP_AREA + VP_SPRAY;
if (wpaint)
vp->flag= VP_AREA;
vp->flag = VP_AREA;
return vp;
}
static int *get_indexarray(Mesh *me)
{
return MEM_mallocN(sizeof(int)*(me->totpoly+1), "vertexpaint");
return MEM_mallocN(sizeof(int) * (me->totpoly + 1), "vertexpaint");
}
unsigned int vpaint_get_current_col(VPaint *vp)
@@ -203,54 +203,54 @@ static void do_shared_vertex_tesscol(Mesh *me)
short *scolmain, *scol;
char *mcol;
if (me->mcol==NULL || me->totvert==0 || me->totface==0) return;
if (me->mcol == NULL || me->totvert == 0 || me->totface == 0) return;
scolmain= MEM_callocN(4*sizeof(short)*me->totvert, "colmain");
scolmain = MEM_callocN(4 * sizeof(short) * me->totvert, "colmain");
tface= me->mtface;
mface= me->mface;
mcol= (char *)me->mcol;
for (a=me->totface; a>0; a--, mface++, mcol+=16) {
if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK)==0) {
scol= scolmain+4*mface->v1;
scol[0]++; scol[1]+= mcol[1]; scol[2]+= mcol[2]; scol[3]+= mcol[3];
scol= scolmain+4*mface->v2;
scol[0]++; scol[1]+= mcol[5]; scol[2]+= mcol[6]; scol[3]+= mcol[7];
scol= scolmain+4*mface->v3;
scol[0]++; scol[1]+= mcol[9]; scol[2]+= mcol[10]; scol[3]+= mcol[11];
tface = me->mtface;
mface = me->mface;
mcol = (char *)me->mcol;
for (a = me->totface; a > 0; a--, mface++, mcol += 16) {
if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK) == 0) {
scol = scolmain + 4 * mface->v1;
scol[0]++; scol[1] += mcol[1]; scol[2] += mcol[2]; scol[3] += mcol[3];
scol = scolmain + 4 * mface->v2;
scol[0]++; scol[1] += mcol[5]; scol[2] += mcol[6]; scol[3] += mcol[7];
scol = scolmain + 4 * mface->v3;
scol[0]++; scol[1] += mcol[9]; scol[2] += mcol[10]; scol[3] += mcol[11];
if (mface->v4) {
scol= scolmain+4*mface->v4;
scol[0]++; scol[1]+= mcol[13]; scol[2]+= mcol[14]; scol[3]+= mcol[15];
scol = scolmain + 4 * mface->v4;
scol[0]++; scol[1] += mcol[13]; scol[2] += mcol[14]; scol[3] += mcol[15];
}
}
if (tface) tface++;
}
a= me->totvert;
scol= scolmain;
a = me->totvert;
scol = scolmain;
while (a--) {
if (scol[0]>1) {
scol[1]/= scol[0];
scol[2]/= scol[0];
scol[3]/= scol[0];
if (scol[0] > 1) {
scol[1] /= scol[0];
scol[2] /= scol[0];
scol[3] /= scol[0];
}
scol+= 4;
scol += 4;
}
tface= me->mtface;
mface= me->mface;
mcol= (char *)me->mcol;
for (a=me->totface; a>0; a--, mface++, mcol+=16) {
if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK)==0) {
scol= scolmain+4*mface->v1;
mcol[1]= scol[1]; mcol[2]= scol[2]; mcol[3]= scol[3];
scol= scolmain+4*mface->v2;
mcol[5]= scol[1]; mcol[6]= scol[2]; mcol[7]= scol[3];
scol= scolmain+4*mface->v3;
mcol[9]= scol[1]; mcol[10]= scol[2]; mcol[11]= scol[3];
tface = me->mtface;
mface = me->mface;
mcol = (char *)me->mcol;
for (a = me->totface; a > 0; a--, mface++, mcol += 16) {
if ((tface && tface->mode & TF_SHAREDCOL) || (me->editflag & ME_EDIT_PAINT_MASK) == 0) {
scol = scolmain + 4 * mface->v1;
mcol[1] = scol[1]; mcol[2] = scol[2]; mcol[3] = scol[3];
scol = scolmain + 4 * mface->v2;
mcol[5] = scol[1]; mcol[6] = scol[2]; mcol[7] = scol[3];
scol = scolmain + 4 * mface->v3;
mcol[9] = scol[1]; mcol[10] = scol[2]; mcol[11] = scol[3];
if (mface->v4) {
scol= scolmain+4*mface->v4;
mcol[13]= scol[1]; mcol[14]= scol[2]; mcol[15]= scol[3];
scol = scolmain + 4 * mface->v4;
mcol[13] = scol[1]; mcol[14] = scol[2]; mcol[15] = scol[3];
}
}
if (tface) tface++;
@@ -271,17 +271,17 @@ void do_shared_vertexcol(Mesh *me, int do_tessface)
/* if no mloopcol: do not do */
/* if mtexpoly: only the involved faces, otherwise all */
if (me->mloopcol==0 || me->totvert==0 || me->totpoly==0) return;
if (me->mloopcol == 0 || me->totvert == 0 || me->totpoly == 0) return;
scol = MEM_callocN(sizeof(float)*me->totvert*5, "scol");
scol = MEM_callocN(sizeof(float) * me->totvert * 5, "scol");
for (i=0; i<me->totloop; i++, ml++, lcol++) {
for (i = 0; i < me->totloop; i++, ml++, lcol++) {
if (i >= mp->loopstart + mp->totloop) {
mp++;
if (mtp) mtp++;
}
if (!(mtp && (mtp->mode & TF_SHAREDCOL)) && (me->editflag & ME_EDIT_PAINT_MASK)!=0)
if (!(mtp && (mtp->mode & TF_SHAREDCOL)) && (me->editflag & ME_EDIT_PAINT_MASK) != 0)
continue;
scol[ml->v][0] += lcol->r;
@@ -293,7 +293,7 @@ void do_shared_vertexcol(Mesh *me, int do_tessface)
}
if (has_shared) {
for (i=0; i<me->totvert; i++) {
for (i = 0; i < me->totvert; i++) {
if (!scol[i][4]) continue;
scol[i][0] /= scol[i][4];
@@ -304,7 +304,7 @@ void do_shared_vertexcol(Mesh *me, int do_tessface)
ml = me->mloop;
lcol = me->mloopcol;
for (i=0; i<me->totloop; i++, ml++, lcol++) {
for (i = 0; i < me->totloop; i++, ml++, lcol++) {
if (!scol[ml->v][4]) continue;
lcol->r = scol[ml->v][0];
@@ -325,8 +325,8 @@ static void make_vertexcol(Object *ob) /* single ob */
{
Mesh *me;
if (!ob || ob->id.lib) return;
me= get_mesh(ob);
if (me==NULL) return;
me = get_mesh(ob);
if (me == NULL) return;
if (me->edit_btmesh) return;
/* copies from shadedisplist to mcol */
@@ -345,10 +345,10 @@ static void make_vertexcol(Object *ob) /* single ob */
if (!me->mcol || !me->mface) {
/* should always be true */
if (me->mcol) {
memset(me->mcol, 255, 4*sizeof(MCol)*me->totface);
memset(me->mcol, 255, 4 * sizeof(MCol) * me->totface);
}
/* create tessfaces because they will be used for drawing & fast updates*/
/* create tessfaces because they will be used for drawing & fast updates */
BKE_mesh_tessface_calc(me); /* does own call to update pointers */
}
}
@@ -370,7 +370,7 @@ static void make_vertexcol(Object *ob) /* single ob */
/* mirror_vgroup is set to -1 when invalid */
static int wpaint_mirror_vgroup_ensure(Object *ob, const int vgroup_active)
{
bDeformGroup *defgroup= BLI_findlink(&ob->defbase, vgroup_active);
bDeformGroup *defgroup = BLI_findlink(&ob->defbase, vgroup_active);
if (defgroup) {
bDeformGroup *curdef;
@@ -380,16 +380,16 @@ static int wpaint_mirror_vgroup_ensure(Object *ob, const int vgroup_active)
flip_side_name(name, defgroup->name, FALSE);
if (strcmp(name, defgroup->name) != 0) {
for (curdef= ob->defbase.first, mirrdef= 0; curdef; curdef=curdef->next, mirrdef++) {
for (curdef = ob->defbase.first, mirrdef = 0; curdef; curdef = curdef->next, mirrdef++) {
if (!strcmp(curdef->name, name)) {
break;
}
}
if (curdef==NULL) {
int olddef= ob->actdef; /* tsk, ED_vgroup_add sets the active defgroup */
curdef= ED_vgroup_add_name(ob, name);
ob->actdef= olddef;
if (curdef == NULL) {
int olddef = ob->actdef; /* tsk, ED_vgroup_add sets the active defgroup */
curdef = ED_vgroup_add_name(ob, name);
ob->actdef = olddef;
}
/* curdef should never be NULL unless this is
@@ -407,14 +407,14 @@ static void copy_vpaint_prev(VPaint *vp, unsigned int *lcol, int tot)
{
if (vp->vpaint_prev) {
MEM_freeN(vp->vpaint_prev);
vp->vpaint_prev= NULL;
vp->vpaint_prev = NULL;
}
vp->tot= tot;
vp->tot = tot;
if (lcol==NULL || tot==0) return;
if (lcol == NULL || tot == 0) return;
vp->vpaint_prev= MEM_mallocN(sizeof(int)*tot, "vpaint_prev");
memcpy(vp->vpaint_prev, lcol, sizeof(int)*tot);
vp->vpaint_prev = MEM_mallocN(sizeof(int) * tot, "vpaint_prev");
memcpy(vp->vpaint_prev, lcol, sizeof(int) * tot);
}
@@ -422,12 +422,12 @@ static void copy_wpaint_prev (VPaint *wp, MDeformVert *dverts, int dcount)
{
if (wp->wpaint_prev) {
free_dverts(wp->wpaint_prev, wp->tot);
wp->wpaint_prev= NULL;
wp->wpaint_prev = NULL;
}
if (dverts && dcount) {
wp->wpaint_prev = MEM_mallocN (sizeof(MDeformVert)*dcount, "wpaint prev");
wp->wpaint_prev = MEM_mallocN (sizeof(MDeformVert) * dcount, "wpaint prev");
wp->tot = dcount;
copy_dverts (wp->wpaint_prev, dverts, dcount);
}
@@ -441,23 +441,23 @@ void vpaint_fill(Object *ob, unsigned int paintcol)
MLoopCol *lcol;
int i, j, selected;
me= get_mesh(ob);
if (me==NULL || me->totpoly==0) return;
me = get_mesh(ob);
if (me == NULL || me->totpoly == 0) return;
if (!me->mloopcol) make_vertexcol(ob);
if (!me->mloopcol) return; /* possible we can't make mcol's */
selected= (me->editflag & ME_EDIT_PAINT_MASK);
selected = (me->editflag & ME_EDIT_PAINT_MASK);
mp = me->mpoly;
for (i=0; i<me->totpoly; i++, mp++) {
for (i = 0; i < me->totpoly; i++, mp++) {
if (!(!selected || mp->flag & ME_FACE_SEL))
continue;
lcol = me->mloopcol + mp->loopstart;
for (j=0; j<mp->totloop; j++, lcol++) {
*(int*)lcol = paintcol;
for (j = 0; j < mp->totloop; j++, lcol++) {
*(int *)lcol = paintcol;
}
}
@@ -471,74 +471,74 @@ void vpaint_fill(Object *ob, unsigned int paintcol)
/* fills in the selected faces with the current weight and vertex group */
void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
{
Mesh *me= ob->data;
Mesh *me = ob->data;
MPoly *mf;
MDeformWeight *dw, *dw_prev;
int vgroup_active, vgroup_mirror= -1;
int vgroup_active, vgroup_mirror = -1;
unsigned int index;
/* mutually exclusive, could be made into a */
const short paint_selmode= ME_EDIT_PAINT_SEL_MODE(me);
const short paint_selmode = ME_EDIT_PAINT_SEL_MODE(me);
if (me->totpoly==0 || me->dvert==NULL || !me->mpoly) return;
if (me->totpoly == 0 || me->dvert == NULL || !me->mpoly) return;
vgroup_active = ob->actdef - 1;
/* if mirror painting, find the other group */
if (me->editflag & ME_EDIT_MIRROR_X) {
vgroup_mirror= wpaint_mirror_vgroup_ensure(ob, vgroup_active);
vgroup_mirror = wpaint_mirror_vgroup_ensure(ob, vgroup_active);
}
copy_wpaint_prev(wp, me->dvert, me->totvert);
for (index=0, mf= me->mpoly; index < me->totpoly; index++, mf++) {
unsigned int fidx= mf->totloop - 1;
for (index = 0, mf = me->mpoly; index < me->totpoly; index++, mf++) {
unsigned int fidx = mf->totloop - 1;
if ((paint_selmode == SCE_SELECT_FACE) && !(mf->flag & ME_FACE_SEL)) {
continue;
}
do {
unsigned int vidx= me->mloop[mf->loopstart + fidx].v;
unsigned int vidx = me->mloop[mf->loopstart + fidx].v;
if (!me->dvert[vidx].flag) {
if ((paint_selmode == SCE_SELECT_VERTEX) && !(me->mvert[vidx].flag & SELECT)) {
continue;
}
dw= defvert_verify_index(&me->dvert[vidx], vgroup_active);
dw = defvert_verify_index(&me->dvert[vidx], vgroup_active);
if (dw) {
dw_prev= defvert_verify_index(wp->wpaint_prev+vidx, vgroup_active);
dw_prev->weight= dw->weight; /* set the undo weight */
dw->weight= paintweight;
dw_prev = defvert_verify_index(wp->wpaint_prev + vidx, vgroup_active);
dw_prev->weight = dw->weight; /* set the undo weight */
dw->weight = paintweight;
if (me->editflag & ME_EDIT_MIRROR_X) { /* x mirror painting */
int j= mesh_get_x_mirror_vert(ob, vidx);
if (j>=0) {
int j = mesh_get_x_mirror_vert(ob, vidx);
if (j >= 0) {
/* copy, not paint again */
if (vgroup_mirror != -1) {
dw= defvert_verify_index(me->dvert+j, vgroup_mirror);
dw_prev= defvert_verify_index(wp->wpaint_prev+j, vgroup_mirror);
dw = defvert_verify_index(me->dvert + j, vgroup_mirror);
dw_prev = defvert_verify_index(wp->wpaint_prev + j, vgroup_mirror);
}
else {
dw= defvert_verify_index(me->dvert+j, vgroup_active);
dw_prev= defvert_verify_index(wp->wpaint_prev+j, vgroup_active);
dw = defvert_verify_index(me->dvert + j, vgroup_active);
dw_prev = defvert_verify_index(wp->wpaint_prev + j, vgroup_active);
}
dw_prev->weight= dw->weight; /* set the undo weight */
dw->weight= paintweight;
dw_prev->weight = dw->weight; /* set the undo weight */
dw->weight = paintweight;
}
}
}
me->dvert[vidx].flag= 1;
me->dvert[vidx].flag = 1;
}
} while (fidx--);
}
{
MDeformVert *dv= me->dvert;
for (index= me->totvert; index != 0; index--, dv++) {
dv->flag= 0;
MDeformVert *dv = me->dvert;
for (index = me->totvert; index != 0; index--, dv++) {
dv->flag = 0;
}
}
@@ -551,41 +551,41 @@ void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
#if 0
void vpaint_dogamma(Scene *scene)
{
VPaint *vp= scene->toolsettings->vpaint;
VPaint *vp = scene->toolsettings->vpaint;
Mesh *me;
Object *ob;
float igam, fac;
int a, temp;
unsigned char *cp, gamtab[256];
ob= OBACT;
me= get_mesh(ob);
ob = OBACT;
me = get_mesh(ob);
if (!(ob->mode & OB_MODE_VERTEX_PAINT)) return;
if (me==0 || me->mcol==0 || me->totface==0) return;
if (me == 0 || me->mcol == 0 || me->totface == 0) return;
igam= 1.0/vp->gamma;
for (a=0; a<256; a++) {
igam = 1.0 / vp->gamma;
for (a = 0; a < 256; a++) {
fac= ((float)a)/255.0;
fac= vp->mul*pow( fac, igam);
fac = ((float)a) / 255.0;
fac = vp->mul * pow( fac, igam);
temp= 255.9*fac;
temp = 255.9 * fac;
if (temp<=0) gamtab[a]= 0;
else if (temp>=255) gamtab[a]= 255;
else gamtab[a]= temp;
if (temp <= 0) gamtab[a] = 0;
else if (temp >= 255) gamtab[a] = 255;
else gamtab[a] = temp;
}
a= 4*me->totface;
cp= (unsigned char *)me->mcol;
a = 4 * me->totface;
cp = (unsigned char *)me->mcol;
while (a--) {
cp[1]= gamtab[ cp[1] ];
cp[2]= gamtab[ cp[2] ];
cp[3]= gamtab[ cp[3] ];
cp[1] = gamtab[ cp[1] ];
cp[2] = gamtab[ cp[2] ];
cp[3] = gamtab[ cp[3] ];
cp+= 4;
cp += 4;
}
}
#endif
@@ -788,24 +788,24 @@ static unsigned int vpaint_blend(VPaint *vp, unsigned int col, unsigned int colo
col = vpaint_blend_tool(tool, col, paintcol, alpha_i);
/* if no spray, clip color adding with colorig & orig alpha */
if ((vp->flag & VP_SPRAY)==0) {
if ((vp->flag & VP_SPRAY) == 0) {
unsigned int testcol, a;
char *cp, *ct, *co;
testcol = vpaint_blend_tool(tool, colorig, paintcol, brush_alpha_value_i);
cp= (char *)&col;
ct= (char *)&testcol;
co= (char *)&colorig;
cp = (char *)&col;
ct = (char *)&testcol;
co = (char *)&colorig;
for (a=0; a<4; a++) {
if ( ct[a]<co[a] ) {
if ( cp[a]<ct[a] ) cp[a]= ct[a];
else if ( cp[a]>co[a] ) cp[a]= co[a];
for (a = 0; a < 4; a++) {
if ( ct[a] < co[a] ) {
if ( cp[a] < ct[a] ) cp[a] = ct[a];
else if ( cp[a] > co[a] ) cp[a] = co[a];
}
else {
if ( cp[a]<co[a] ) cp[a]= co[a];
else if ( cp[a]>ct[a] ) cp[a]= ct[a];
if ( cp[a] < co[a] ) cp[a] = co[a];
else if ( cp[a] > ct[a] ) cp[a] = ct[a];
}
}
}
@@ -817,32 +817,32 @@ static unsigned int vpaint_blend(VPaint *vp, unsigned int col, unsigned int colo
static int sample_backbuf_area(ViewContext *vc, int *indexar, int totface, int x, int y, float size)
{
struct ImBuf *ibuf;
int a, tot=0, index;
int a, tot = 0, index;
/* brecht: disabled this because it obviously fails for
* brushes with size > 64, why is this here? */
/*if(size>64.0) size= 64.0;*/
/*if(size > 64.0) size = 64.0;*/
ibuf= view3d_read_backbuf(vc, x-size, y-size, x+size, y+size);
ibuf = view3d_read_backbuf(vc, x - size, y - size, x + size, y + size);
if (ibuf) {
unsigned int *rt= ibuf->rect;
unsigned int *rt = ibuf->rect;
memset(indexar, 0, sizeof(int)*(totface+1));
memset(indexar, 0, sizeof(int) * (totface + 1));
size= ibuf->x*ibuf->y;
size = ibuf->x * ibuf->y;
while (size--) {
if (*rt) {
index= WM_framebuffer_to_index(*rt);
if (index>0 && index<=totface)
index = WM_framebuffer_to_index(*rt);
if (index > 0 && index <= totface)
indexar[index] = 1;
}
rt++;
}
for (a=1; a<=totface; a++) {
if (indexar[a]) indexar[tot++]= a;
for (a = 1; a <= totface; a++) {
if (indexar[a]) indexar[tot++] = a;
}
IMB_freeImBuf(ibuf);
@@ -861,7 +861,7 @@ static float calc_vp_strength_dl(VPaint *vp, ViewContext *vc, const float *vert_
project_float_noclip(vc->ar, vert_nor, vertco);
sub_v2_v2v2(delta, mval, vertco);
dist_squared= dot_v2v2(delta, delta); /* len squared */
dist_squared = dot_v2v2(delta, delta); /* len squared */
if (dist_squared > brush_size_pressure * brush_size_pressure) {
return 0.0f;
}
@@ -879,11 +879,11 @@ static float calc_vp_alpha_dl(VPaint *vp, ViewContext *vc,
float strength = calc_vp_strength_dl(vp, vc, vert_nor, mval, brush_size_pressure);
if (strength > 0.0f) {
float alpha= brush_alpha_pressure * strength;
float alpha = brush_alpha_pressure * strength;
if (vp->flag & VP_NORMALS) {
float dvec[3];
const float *no= vert_nor + 3;
const float *no = vert_nor + 3;
/* transpose ! */
dvec[2] = dot_v3v3(vpimat[2], no);
@@ -966,13 +966,13 @@ static float wpaint_blend(VPaint *wp, float weight, float weight_prev,
case PAINT_BLEND_MIX:
paintval = 1.f - paintval; break;
case PAINT_BLEND_ADD:
tool= PAINT_BLEND_SUB; break;
tool = PAINT_BLEND_SUB; break;
case PAINT_BLEND_SUB:
tool= PAINT_BLEND_ADD; break;
tool = PAINT_BLEND_ADD; break;
case PAINT_BLEND_LIGHTEN:
tool= PAINT_BLEND_DARKEN; break;
tool = PAINT_BLEND_DARKEN; break;
case PAINT_BLEND_DARKEN:
tool= PAINT_BLEND_LIGHTEN; break;
tool = PAINT_BLEND_LIGHTEN; break;
}
}
@@ -1012,52 +1012,52 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
{
ViewContext vc;
Mesh *me;
short change= FALSE;
short change = FALSE;
view3d_set_viewcontext(C, &vc);
me= get_mesh(vc.obact);
me = get_mesh(vc.obact);
if (me && me->dvert && vc.v3d && vc.rv3d) {
int index;
view3d_operator_needs_opengl(C);
index= view3d_sample_backbuf(&vc, event->mval[0], event->mval[1]);
index = view3d_sample_backbuf(&vc, event->mval[0], event->mval[1]);
if (index && index<=me->totpoly) {
DerivedMesh *dm= mesh_get_derived_final(vc.scene, vc.obact, CD_MASK_BAREMESH);
if (index && index <= me->totpoly) {
DerivedMesh *dm = mesh_get_derived_final(vc.scene, vc.obact, CD_MASK_BAREMESH);
if (dm->getVertCo==NULL) {
if (dm->getVertCo == NULL) {
BKE_report(op->reports, RPT_WARNING, "The modifier used does not support deformed locations");
}
else {
MPoly *mf= ((MPoly *)me->mpoly) + index-1;
const int vgroup_active= vc.obact->actdef - 1;
ToolSettings *ts= vc.scene->toolsettings;
MPoly *mf = ((MPoly *)me->mpoly) + index - 1;
const int vgroup_active = vc.obact->actdef - 1;
ToolSettings *ts = vc.scene->toolsettings;
float mval_f[2];
int v_idx_best= -1;
int v_idx_best = -1;
int fidx;
float len_best= FLT_MAX;
float len_best = FLT_MAX;
mval_f[0]= (float)event->mval[0];
mval_f[1]= (float)event->mval[1];
mval_f[0] = (float)event->mval[0];
mval_f[1] = (float)event->mval[1];
fidx= mf->totloop - 1;
fidx = mf->totloop - 1;
do {
float co[3], sco[3], len;
const int v_idx= me->mloop[mf->loopstart + fidx].v;
const int v_idx = me->mloop[mf->loopstart + fidx].v;
dm->getVertCo(dm, v_idx, co);
project_float_noclip(vc.ar, co, sco);
len= len_squared_v2v2(mval_f, sco);
len = len_squared_v2v2(mval_f, sco);
if (len < len_best) {
len_best= len;
v_idx_best= v_idx;
len_best = len;
v_idx_best = v_idx;
}
} while (fidx--);
if (v_idx_best != -1) { /* should always be valid */
ts->vgroup_weight= defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
change= TRUE;
ts->vgroup_weight = defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
change = TRUE;
}
}
dm->release(dm);
@@ -1093,59 +1093,59 @@ void PAINT_OT_weight_sample(wmOperatorType *ot)
static EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free)
{
if (C) {
wmWindow *win= CTX_wm_window(C);
wmWindow *win = CTX_wm_window(C);
if (win && win->eventstate) {
ViewContext vc;
Mesh *me;
view3d_set_viewcontext(C, &vc);
me= get_mesh(vc.obact);
me = get_mesh(vc.obact);
if (me && me->dvert && vc.v3d && vc.rv3d) {
int index;
view3d_operator_needs_opengl(C);
index= view3d_sample_backbuf(&vc, win->eventstate->x - vc.ar->winrct.xmin, win->eventstate->y - vc.ar->winrct.ymin);
index = view3d_sample_backbuf(&vc, win->eventstate->x - vc.ar->winrct.xmin, win->eventstate->y - vc.ar->winrct.ymin);
if (index && index<=me->totpoly) {
const int defbase_tot= BLI_countlist(&vc.obact->defbase);
if (index && index <= me->totpoly) {
const int defbase_tot = BLI_countlist(&vc.obact->defbase);
if (defbase_tot) {
MPoly *mf= ((MPoly *)me->mpoly) + index-1;
unsigned int fidx= mf->totloop - 1;
int *groups= MEM_callocN(defbase_tot*sizeof(int), "groups");
int found= FALSE;
MPoly *mf = ((MPoly *)me->mpoly) + index - 1;
unsigned int fidx = mf->totloop - 1;
int *groups = MEM_callocN(defbase_tot * sizeof(int), "groups");
int found = FALSE;
do {
MDeformVert *dvert= me->dvert + me->mloop[mf->loopstart + fidx].v;
int i= dvert->totweight;
MDeformVert *dvert = me->dvert + me->mloop[mf->loopstart + fidx].v;
int i = dvert->totweight;
MDeformWeight *dw;
for (dw= dvert->dw; i > 0; dw++, i--) {
for (dw = dvert->dw; i > 0; dw++, i--) {
if (dw->def_nr < defbase_tot) {
groups[dw->def_nr]= TRUE;
found= TRUE;
groups[dw->def_nr] = TRUE;
found = TRUE;
}
}
} while (fidx--);
if (found==FALSE) {
if (found == FALSE) {
MEM_freeN(groups);
}
else {
EnumPropertyItem *item= NULL, item_tmp= {0};
int totitem= 0;
int i= 0;
EnumPropertyItem *item = NULL, item_tmp = {0};
int totitem = 0;
int i = 0;
bDeformGroup *dg;
for (dg= vc.obact->defbase.first; dg && i<defbase_tot; i++, dg= dg->next) {
for (dg = vc.obact->defbase.first; dg && i < defbase_tot; i++, dg = dg->next) {
if (groups[i]) {
item_tmp.identifier= item_tmp.name= dg->name;
item_tmp.value= i;
item_tmp.identifier = item_tmp.name = dg->name;
item_tmp.value = i;
RNA_enum_item_add(&item, &totitem, &item_tmp);
}
}
RNA_enum_item_end(&item, &totitem);
*free= 1;
*free = 1;
MEM_freeN(groups);
return item;
@@ -1161,12 +1161,12 @@ static EnumPropertyItem *weight_paint_sample_enum_itemf(bContext *C, PointerRNA
static int weight_sample_group_exec(bContext *C, wmOperator *op)
{
int type= RNA_enum_get(op->ptr, "group");
int type = RNA_enum_get(op->ptr, "group");
ViewContext vc;
view3d_set_viewcontext(C, &vc);
BLI_assert(type + 1 >= 0);
vc.obact->actdef= type + 1;
vc.obact->actdef = type + 1;
DAG_id_tag_update(&vc.obact->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, vc.obact);
@@ -1176,7 +1176,7 @@ static int weight_sample_group_exec(bContext *C, wmOperator *op)
/* TODO, we could make this a menu into OBJECT_OT_vertex_group_set_active rather than its own operator */
void PAINT_OT_weight_sample_group(wmOperatorType *ot)
{
PropertyRNA *prop= NULL;
PropertyRNA *prop = NULL;
/* identifiers */
ot->name = "Weight Paint Sample Group";
@@ -1191,18 +1191,18 @@ void PAINT_OT_weight_sample_group(wmOperatorType *ot)
ot->flag = OPTYPE_UNDO;
/* keyingset to use (dynamic enum) */
prop= RNA_def_enum(ot->srna, "group", DummyRNA_DEFAULT_items, 0, "Keying Set", "The Keying Set to use");
prop = RNA_def_enum(ot->srna, "group", DummyRNA_DEFAULT_items, 0, "Keying Set", "The Keying Set to use");
RNA_def_enum_funcs(prop, weight_paint_sample_enum_itemf);
ot->prop = prop;
}
static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_tot, const char *vgroup_validmap)
{
float sum= 0.0f, fac;
unsigned int i, tot=0;
float sum = 0.0f, fac;
unsigned int i, tot = 0;
MDeformWeight *dw;
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
tot++;
sum += dw->weight;
@@ -1214,9 +1214,9 @@ static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_
}
if (sum != 0.0f) {
fac= 1.0f / sum;
fac = 1.0f / sum;
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
dw->weight *= fac;
}
@@ -1226,7 +1226,7 @@ static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_
/* hrmf, not a factor in this case */
fac = 1.0f / tot;
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
dw->weight = fac;
}
@@ -1241,12 +1241,12 @@ static void do_weight_paint_normalize_all(MDeformVert *dvert, const int defbase_
static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int defbase_tot, const char *vgroup_validmap,
const int vgroup_active)
{
float sum= 0.0f, fac;
unsigned int i, tot=0;
float sum = 0.0f, fac;
unsigned int i, tot = 0;
MDeformWeight *dw;
float act_weight = 0.0f;
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
if (dw->def_nr != vgroup_active) {
sum += dw->weight;
@@ -1265,7 +1265,7 @@ static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int d
if (sum != 0.0f) {
fac = (1.0f / sum) * (1.0f - act_weight);
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
if (dw->def_nr != vgroup_active) {
dw->weight *= fac;
@@ -1285,7 +1285,7 @@ static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int d
/* paranoid but possibly with float error */
CLAMP(fac, 0.0f, 1.0f);
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot && vgroup_validmap[dw->def_nr]) {
if (dw->def_nr != vgroup_active) {
dw->weight = fac;
@@ -1304,7 +1304,7 @@ static char has_locked_group(MDeformVert *dvert, const int defbase_tot,
int i;
MDeformWeight *dw;
for (i= dvert->totweight, dw= dvert->dw; i != 0; i--, dw++) {
for (i = dvert->totweight, dw = dvert->dw; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot) {
if (bone_groups[dw->def_nr] && lock_flags[dw->def_nr] && dw->weight > 0.0f) {
return TRUE;
@@ -1317,12 +1317,12 @@ static char has_locked_group(MDeformVert *dvert, const int defbase_tot,
* gen_lck_flags gets the status of "flag" for each bDeformGroup
*in ob->defbase and returns an array containing them
*/
static char *gen_lock_flags(Object* ob, int defbase_tot)
static char *gen_lock_flags(Object *ob, int defbase_tot)
{
char is_locked = FALSE;
int i;
//int defbase_tot = BLI_countlist(&ob->defbase);
char *lock_flags = MEM_mallocN(defbase_tot*sizeof(char), "defflags");
char *lock_flags = MEM_mallocN(defbase_tot * sizeof(char), "defflags");
bDeformGroup *defgroup;
for (i = 0, defgroup = ob->defbase.first; i < defbase_tot && defgroup; defgroup = defgroup->next, i++) {
@@ -1381,7 +1381,7 @@ static void multipaint_selection(MDeformVert *dvert, const int defbase_tot, floa
/* TODO: when the change is reduced, you need to recheck
* the earlier values to make sure they are not 0
* (precision error) */
change = 1.0f/dw->weight;
change = 1.0f / dw->weight;
}
/* the value should never reach zero while multi-painting if it
* was nonzero beforehand */
@@ -1419,9 +1419,9 @@ static float redistribute_change(MDeformVert *ndv, const int defbase_tot,
/* assume there is no change until you see one */
was_change = FALSE;
/* change each group by the same amount each time */
change = totchange/total_valid;
change = totchange / total_valid;
for (i = 0; i < ndv->totweight && total_valid && totchange; i++) {
ndw = (ndv->dw+i);
ndw = (ndv->dw + i);
/* ignore anything outside the value range */
if (ndw->def_nr < defbase_tot) {
@@ -1431,8 +1431,8 @@ static float redistribute_change(MDeformVert *ndv, const int defbase_tot,
oldval = ndw->weight;
/* if auto normalize is active, don't worry about upper bounds */
if (do_auto_normalize == FALSE && ndw->weight + change > 1) {
totchange -= 1-ndw->weight;
ndw->weight = 1;
totchange -= 1.0f - ndw->weight;
ndw->weight = 1.0f;
/* stop the changes to this group */
change_status[ndw->def_nr] = changeto;
total_valid--;
@@ -1487,7 +1487,7 @@ static void enforce_locks(MDeformVert *odv, MDeformVert *ndv,
return;
}
/* record if a group was changed, unlocked and not changed, or locked */
change_status = MEM_callocN(sizeof(char)*defbase_tot, "unlocked_unchanged");
change_status = MEM_callocN(sizeof(char) * defbase_tot, "unlocked_unchanged");
for (i = 0; i < defbase_tot; i++) {
ndw = defvert_find_index(ndv, i);
@@ -1524,7 +1524,7 @@ static void enforce_locks(MDeformVert *odv, MDeformVert *ndv,
if (vgroup_validmap && total_changed < 0 && total_valid) {
totchange_allowed = total_valid;
}
/* the way you modify the unlocked+unchanged groups is different depending
/* the way you modify the unlocked + unchanged groups is different depending
* on whether or not you are painting the weight(s) up or down */
if (totchange < 0) {
totchange_allowed = total_valid - totchange_allowed;
@@ -1564,11 +1564,11 @@ static void enforce_locks(MDeformVert *odv, MDeformVert *ndv,
else {
/* reset the weights */
unsigned int i;
MDeformWeight *dw_old= odv->dw;
MDeformWeight *dw_new= ndv->dw;
MDeformWeight *dw_old = odv->dw;
MDeformWeight *dw_new = ndv->dw;
for (i= odv->totweight; i != 0; i--, dw_old++, dw_new++) {
dw_new->weight= dw_old->weight;
for (i = odv->totweight; i != 0; i--, dw_old++, dw_new++) {
dw_new->weight = dw_old->weight;
}
}
}
@@ -1581,17 +1581,17 @@ static float get_mp_change(MDeformVert *odv, const int defbase_tot, const char *
{
float selwsum = 0.0f;
unsigned int i;
MDeformWeight *dw= odv->dw;
MDeformWeight *dw = odv->dw;
for (i= odv->totweight; i != 0; i--, dw++) {
for (i = odv->totweight; i != 0; i--, dw++) {
if (dw->def_nr < defbase_tot) {
if (defbase_sel[dw->def_nr]) {
selwsum += dw->weight;
}
}
}
if (selwsum && selwsum+brush_change > 0) {
return (selwsum+brush_change)/selwsum;
if (selwsum && selwsum + brush_change > 0) {
return (selwsum + brush_change) / selwsum;
}
return 0.0f;
}
@@ -1600,11 +1600,11 @@ static float get_mp_change(MDeformVert *odv, const int defbase_tot, const char *
* it assumes you already have the correct pointer index */
static void defvert_reset_to_prev(MDeformVert *dv_prev, MDeformVert *dv)
{
MDeformWeight *dw= dv->dw;
MDeformWeight *dw = dv->dw;
MDeformWeight *dw_prev;
unsigned int i;
for (i= dv->totweight; i != 0; i--, dw++) {
dw_prev= defvert_find_index(dv_prev, dw->def_nr);
for (i = dv->totweight; i != 0; i--, dw++) {
dw_prev = defvert_find_index(dv_prev, dw->def_nr);
/* if there was no w when there is a d, then the old weight was 0 */
dw->weight = dw_prev ? dw_prev->weight : 0.0f;
}
@@ -1612,9 +1612,9 @@ static void defvert_reset_to_prev(MDeformVert *dv_prev, MDeformVert *dv)
static void clamp_weights(MDeformVert *dvert)
{
MDeformWeight *dw= dvert->dw;
MDeformWeight *dw = dvert->dw;
unsigned int i;
for (i= dvert->totweight; i != 0; i--, dw++) {
for (i = dvert->totweight; i != 0; i--, dw++) {
CLAMP(dw->weight, 0.0f, 1.0f);
}
}
@@ -1661,10 +1661,10 @@ static int apply_mp_locks_normalize(Mesh *me, const WeightPaintInfo *wpi,
float change, float oldChange,
float oldw, float neww)
{
MDeformVert *dv= &me->dvert[index];
MDeformVert dv_test= {NULL};
MDeformVert *dv = &me->dvert[index];
MDeformVert dv_test = {NULL};
dv_test.dw= MEM_dupallocN(dv->dw);
dv_test.dw = MEM_dupallocN(dv->dw);
dv_test.flag = dv->flag;
dv_test.totweight = dv->totweight;
/* do not multi-paint if a locked group is selected or the active group is locked
@@ -1674,7 +1674,7 @@ static int apply_mp_locks_normalize(Mesh *me, const WeightPaintInfo *wpi,
has_locked_group_selected(wpi->defbase_tot, wpi->defbase_sel, wpi->lock_flags) == FALSE))
{
if (wpi->do_multipaint && wpi->defbase_tot_sel > 1) {
if (change && change!=1) {
if (change && change != 1) {
multipaint_selection(dv, wpi->defbase_tot, change, wpi->defbase_sel);
}
}
@@ -1716,8 +1716,8 @@ static int apply_mp_locks_normalize(Mesh *me, const WeightPaintInfo *wpi,
static int get_first_selected_nonzero_weight(MDeformVert *dvert, const int defbase_tot, const char *defbase_sel)
{
int i;
MDeformWeight *dw= dvert->dw;
for (i=0; i< dvert->totweight; i++, dw++) {
MDeformWeight *dw = dvert->dw;
for (i = 0; i < dvert->totweight; i++, dw++) {
if (dw->def_nr < defbase_tot) {
if (defbase_sel[dw->def_nr] && dw->weight > 0.0f) {
return i;
@@ -1737,8 +1737,8 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
const unsigned int index, float alpha, float paintweight
)
{
Mesh *me= ob->data;
MDeformVert *dv= &me->dvert[index];
Mesh *me = ob->data;
MDeformVert *dv = &me->dvert[index];
MDeformWeight *dw, *dw_prev;
@@ -1752,15 +1752,15 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
const short do_multipaint_totsel = (wpi->do_multipaint && wpi->defbase_tot_sel > 1);
if (wp->flag & VP_ONLYVGROUP) {
dw= defvert_find_index(dv, wpi->vgroup_active);
dw_prev= defvert_find_index(wp->wpaint_prev+index, wpi->vgroup_active);
dw = defvert_find_index(dv, wpi->vgroup_active);
dw_prev = defvert_find_index(wp->wpaint_prev + index, wpi->vgroup_active);
}
else {
dw= defvert_verify_index(dv, wpi->vgroup_active);
dw_prev= defvert_verify_index(wp->wpaint_prev+index, wpi->vgroup_active);
dw = defvert_verify_index(dv, wpi->vgroup_active);
dw_prev = defvert_verify_index(wp->wpaint_prev + index, wpi->vgroup_active);
}
if (dw==NULL || dw_prev==NULL) {
if (dw == NULL || dw_prev == NULL) {
return;
}
@@ -1881,12 +1881,12 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
/* use locks and/or multipaint */
float oldw;
float neww;
float testw=0;
float testw = 0;
float change = 0;
float oldChange = 0;
int i;
MDeformWeight *tdw = NULL, *tdw_prev;
MDeformVert dv_copy= {NULL};
MDeformVert dv_copy = {NULL};
oldw = dw->weight;
neww = wpaint_blend(wp, dw->weight, dw_prev->weight, alpha, paintweight,
@@ -1894,7 +1894,7 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
/* setup multi-paint */
if (do_multipaint_totsel) {
dv_copy.dw= MEM_dupallocN(dv->dw);
dv_copy.dw = MEM_dupallocN(dv->dw);
dv_copy.flag = dv->flag;
dv_copy.totweight = dv->totweight;
tdw = dw;
@@ -1903,7 +1903,7 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
if (change) {
if (!tdw->weight) {
i = get_first_selected_nonzero_weight(dv, wpi->defbase_tot, wpi->defbase_sel);
if (i>=0) {
if (i >= 0) {
tdw = &(dv->dw[i]);
tdw_prev = defvert_verify_index(&wp->wpaint_prev[index], tdw->def_nr);
}
@@ -1913,12 +1913,12 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
}
if (change && tdw_prev->weight && tdw_prev->weight * change) {
if (tdw->weight != tdw_prev->weight) {
oldChange = tdw->weight/tdw_prev->weight;
testw = tdw_prev->weight*change;
oldChange = tdw->weight / tdw_prev->weight;
testw = tdw_prev->weight * change;
if ( testw > tdw_prev->weight ) {
if (change > oldChange) {
/* reset the weights and use the new change */
defvert_reset_to_prev(wp->wpaint_prev+index, dv);
defvert_reset_to_prev(wp->wpaint_prev + index, dv);
}
else {
/* the old change was more significant, so set
@@ -1928,7 +1928,7 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
}
else {
if (change < oldChange) {
defvert_reset_to_prev(wp->wpaint_prev+index, dv);
defvert_reset_to_prev(wp->wpaint_prev + index, dv);
}
else {
change = 0;
@@ -1974,13 +1974,13 @@ static void do_weight_paint_vertex(/* vars which remain the same for every vert
static int set_wpaint(bContext *C, wmOperator *UNUSED(op)) /* toggle */
{
Object *ob= CTX_data_active_object(C);
Scene *scene= CTX_data_scene(C);
VPaint *wp= scene->toolsettings->wpaint;
Object *ob = CTX_data_active_object(C);
Scene *scene = CTX_data_scene(C);
VPaint *wp = scene->toolsettings->wpaint;
Mesh *me;
me= get_mesh(ob);
if (ob->id.lib || me==NULL) return OPERATOR_PASS_THROUGH;
me = get_mesh(ob);
if (ob->id.lib || me == NULL) return OPERATOR_PASS_THROUGH;
if (ob->mode & OB_MODE_WEIGHT_PAINT) ob->mode &= ~OB_MODE_WEIGHT_PAINT;
else ob->mode |= OB_MODE_WEIGHT_PAINT;
@@ -1996,8 +1996,8 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op)) /* toggle */
if (ob->mode & OB_MODE_WEIGHT_PAINT) {
Object *par;
if (wp==NULL)
wp= scene->toolsettings->wpaint= new_vpaint(1);
if (wp == NULL)
wp = scene->toolsettings->wpaint = new_vpaint(1);
paint_init(&wp->paint, PAINT_CURSOR_WEIGHT_PAINT);
paint_cursor_start(C, weight_paint_poll);
@@ -2005,9 +2005,9 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op)) /* toggle */
mesh_octree_table(ob, NULL, NULL, 's');
/* verify if active weight group is also active bone */
par= modifiers_isDeformedByArmature(ob);
par = modifiers_isDeformedByArmature(ob);
if (par && (par->mode & OB_MODE_POSE)) {
bArmature *arm= par->data;
bArmature *arm = par->data;
if (arm->act_bone)
ED_vgroup_select_by_name(ob, arm->act_bone->name);
@@ -2026,10 +2026,10 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op)) /* toggle */
/* for switching to/from mode */
static int paint_poll_test(bContext *C)
{
Object *ob= CTX_data_active_object(C);
Object *ob = CTX_data_active_object(C);
if (CTX_data_edit_object(C))
return 0;
if (CTX_data_active_object(C)==NULL)
if (CTX_data_active_object(C) == NULL)
return 0;
if (!ob->data || ((ID *)ob->data)->lib)
return 0;
@@ -2062,8 +2062,8 @@ struct WPaintData {
float *vertexcosnos;
float wpimat[3][3];
/*variables for auto normalize*/
const char *vgroup_validmap; /*stores if vgroups tie to deforming bones or not*/
/* variables for auto normalize */
const char *vgroup_validmap; /* stores if vgroups tie to deforming bones or not */
const char *lock_flags;
int defbase_tot;
};
@@ -2074,32 +2074,32 @@ static char *wpaint_make_validmap(Object *ob)
ModifierData *md;
char *vgroup_validmap;
GHash *gh;
int i, step1=1;
int i, step1 = 1;
if (ob->defbase.first == NULL) {
return NULL;
}
gh= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "wpaint_make_validmap gh");
gh = BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "wpaint_make_validmap gh");
/*add all names to a hash table*/
for (dg=ob->defbase.first; dg; dg=dg->next) {
/* add all names to a hash table */
for (dg = ob->defbase.first; dg; dg = dg->next) {
BLI_ghash_insert(gh, dg->name, NULL);
}
/*now loop through the armature modifiers and identify deform bones*/
for (md = ob->modifiers.first; md; md= !md->next && step1 ? (step1=0), modifiers_getVirtualModifierList(ob) : md->next) {
/* now loop through the armature modifiers and identify deform bones */
for (md = ob->modifiers.first; md; md = !md->next && step1 ? (step1 = 0), modifiers_getVirtualModifierList(ob) : md->next) {
if (!(md->mode & (eModifierMode_Realtime|eModifierMode_Virtual)))
continue;
if (md->type == eModifierType_Armature) {
ArmatureModifierData *amd= (ArmatureModifierData*) md;
ArmatureModifierData *amd = (ArmatureModifierData *) md;
if (amd->object && amd->object->pose) {
bPose *pose= amd->object->pose;
bPose *pose = amd->object->pose;
bPoseChannel *chan;
for (chan=pose->chanbase.first; chan; chan=chan->next) {
for (chan = pose->chanbase.first; chan; chan = chan->next) {
if (chan->bone->flag & BONE_NO_DEFORM)
continue;
@@ -2112,11 +2112,11 @@ static char *wpaint_make_validmap(Object *ob)
}
}
vgroup_validmap= MEM_mallocN(BLI_ghash_size(gh), "wpaint valid map");
vgroup_validmap = MEM_mallocN(BLI_ghash_size(gh), "wpaint valid map");
/*add all names to a hash table*/
for (dg=ob->defbase.first, i=0; dg; dg=dg->next, i++) {
vgroup_validmap[i]= (BLI_ghash_lookup(gh, dg->name) != NULL);
/* add all names to a hash table */
for (dg = ob->defbase.first, i = 0; dg; dg = dg->next, i++) {
vgroup_validmap[i] = (BLI_ghash_lookup(gh, dg->name) != NULL);
}
BLI_assert(i == BLI_ghash_size(gh));
@@ -2128,11 +2128,11 @@ static char *wpaint_make_validmap(Object *ob)
static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
{
Scene *scene= CTX_data_scene(C);
Scene *scene = CTX_data_scene(C);
struct PaintStroke *stroke = op->customdata;
ToolSettings *ts= scene->toolsettings;
VPaint *wp= ts->wpaint;
Object *ob= CTX_data_active_object(C);
ToolSettings *ts = scene->toolsettings;
VPaint *wp = ts->wpaint;
Object *ob = CTX_data_active_object(C);
struct WPaintData *wpd;
Mesh *me;
bDeformGroup *dg;
@@ -2143,8 +2143,8 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
return FALSE;
}
me= get_mesh(ob);
if (me==NULL || me->totpoly==0) return OPERATOR_PASS_THROUGH;
me = get_mesh(ob);
if (me == NULL || me->totpoly == 0) return OPERATOR_PASS_THROUGH;
/* if nothing was added yet, we make dverts and a vertex deform group */
if (!me->dvert) {
@@ -2156,25 +2156,25 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
if (ob->actdef <= 0) {
Object *modob;
if ((modob = modifiers_isDeformedByArmature(ob))) {
Bone *actbone= ((bArmature *)modob->data)->act_bone;
Bone *actbone = ((bArmature *)modob->data)->act_bone;
if (actbone) {
bPoseChannel *pchan= get_pose_channel(modob->pose, actbone->name);
bPoseChannel *pchan = get_pose_channel(modob->pose, actbone->name);
if (pchan) {
bDeformGroup *dg= defgroup_find_name(ob, pchan->name);
if (dg==NULL) {
dg= ED_vgroup_add_name(ob, pchan->name); /* sets actdef */
bDeformGroup *dg = defgroup_find_name(ob, pchan->name);
if (dg == NULL) {
dg = ED_vgroup_add_name(ob, pchan->name); /* sets actdef */
}
else {
int actdef = 1 + BLI_findindex(&ob->defbase, dg);
BLI_assert(actdef >= 0);
ob->actdef= actdef;
ob->actdef = actdef;
}
}
}
}
}
if (ob->defbase.first==NULL) {
if (ob->defbase.first == NULL) {
ED_vgroup_add(ob);
}
@@ -2186,7 +2186,7 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
/* check if we are attempting to paint onto a locked vertex group,
* and other options disallow it from doing anything useful */
dg = BLI_findlink(&ob->defbase, (ob->actdef-1));
dg = BLI_findlink(&ob->defbase, (ob->actdef - 1));
if (dg->flag & DG_LOCK_WEIGHT) {
BKE_report(op->reports, RPT_WARNING, "Active group is locked, aborting");
return FALSE;
@@ -2194,7 +2194,7 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
/* ALLOCATIONS! no return after this line */
/* make mode data storage */
wpd= MEM_callocN(sizeof(struct WPaintData), "WPaintData");
wpd = MEM_callocN(sizeof(struct WPaintData), "WPaintData");
paint_stroke_set_mode_data(stroke, wpd);
view3d_set_viewcontext(C, &wpd->vc);
@@ -2202,7 +2202,7 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
wpd->vgroup_mirror = -1;
/* set up auto-normalize, and generate map for detecting which
* vgroups affect deform bones*/
* vgroups affect deform bones */
wpd->defbase_tot = BLI_countlist(&ob->defbase);
wpd->lock_flags = gen_lock_flags(ob, wpd->defbase_tot);
if (ts->auto_normalize || ts->multipaint || wpd->lock_flags) {
@@ -2210,8 +2210,8 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
}
/* painting on subsurfs should give correct points too, this returns me->totvert amount */
wpd->vertexcosnos= mesh_get_mapped_verts_nors(scene, ob);
wpd->indexar= get_indexarray(me);
wpd->vertexcosnos = mesh_get_mapped_verts_nors(scene, ob);
wpd->indexar = get_indexarray(me);
copy_wpaint_prev(wp, me->dvert, me->totvert);
/* imat for normals */
@@ -2229,11 +2229,11 @@ static int wpaint_stroke_test_start(bContext *C, wmOperator *op, wmEvent *UNUSED
static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, PointerRNA *itemptr)
{
Scene *scene= CTX_data_scene(C);
ToolSettings *ts= CTX_data_tool_settings(C);
VPaint *wp= ts->wpaint;
Scene *scene = CTX_data_scene(C);
ToolSettings *ts = CTX_data_tool_settings(C);
VPaint *wp = ts->wpaint;
Brush *brush = paint_brush(&wp->paint);
struct WPaintData *wpd= paint_stroke_mode_data(stroke);
struct WPaintData *wpd = paint_stroke_mode_data(stroke);
ViewContext *vc;
Object *ob;
Mesh *me;
@@ -2263,10 +2263,10 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
return;
}
vc= &wpd->vc;
ob= vc->obact;
me= ob->data;
indexar= wpd->indexar;
vc = &wpd->vc;
ob = vc->obact;
me = ob->data;
indexar = wpd->indexar;
view3d_operator_needs_opengl(C);
@@ -2274,93 +2274,93 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
mult_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
RNA_float_get_array(itemptr, "mouse", mval);
mval[0]-= vc->ar->winrct.xmin;
mval[1]-= vc->ar->winrct.ymin;
mval[0] -= vc->ar->winrct.xmin;
mval[1] -= vc->ar->winrct.ymin;
/* *** setup WeightPaintInfo - pass onto do_weight_paint_vertex *** */
wpi.defbase_tot= wpd->defbase_tot;
defbase_sel= MEM_mallocN(wpi.defbase_tot*sizeof(char), "wpi.defbase_sel");
wpi.defbase_tot_sel= get_selected_defgroups(ob, defbase_sel, wpi.defbase_tot);
wpi.defbase_sel= defbase_sel; /* so we can stay const */
wpi.defbase_tot = wpd->defbase_tot;
defbase_sel = MEM_mallocN(wpi.defbase_tot * sizeof(char), "wpi.defbase_sel");
wpi.defbase_tot_sel = get_selected_defgroups(ob, defbase_sel, wpi.defbase_tot);
wpi.defbase_sel = defbase_sel; /* so we can stay const */
if (wpi.defbase_tot_sel == 0 && ob->actdef > 0) wpi.defbase_tot_sel = 1;
wpi.defbase_tot_unsel= wpi.defbase_tot - wpi.defbase_tot_sel;
wpi.vgroup_active= wpd->vgroup_active;
wpi.vgroup_mirror= wpd->vgroup_mirror;
wpi.lock_flags= wpd->lock_flags;
wpi.vgroup_validmap= wpd->vgroup_validmap;
wpi.do_flip= RNA_boolean_get(itemptr, "pen_flip");
wpi.do_multipaint= (ts->multipaint != 0);
wpi.do_auto_normalize= ((ts->auto_normalize != 0) && (wpi.vgroup_validmap != NULL));
wpi.brush_alpha_value= brush_alpha_value;
wpi.defbase_tot_unsel = wpi.defbase_tot - wpi.defbase_tot_sel;
wpi.vgroup_active = wpd->vgroup_active;
wpi.vgroup_mirror = wpd->vgroup_mirror;
wpi.lock_flags = wpd->lock_flags;
wpi.vgroup_validmap = wpd->vgroup_validmap;
wpi.do_flip = RNA_boolean_get(itemptr, "pen_flip");
wpi.do_multipaint = (ts->multipaint != 0);
wpi.do_auto_normalize = ((ts->auto_normalize != 0) && (wpi.vgroup_validmap != NULL));
wpi.brush_alpha_value = brush_alpha_value;
/* *** done setting up WeightPaintInfo *** */
swap_m4m4(wpd->vc.rv3d->persmat, mat);
use_vert_sel= (me->editflag & ME_EDIT_VERT_SEL) != 0;
use_vert_sel = (me->editflag & ME_EDIT_VERT_SEL) != 0;
/* which faces are involved */
if (wp->flag & VP_AREA) {
/* Ugly hack, to avoid drawing vertex index when getting the face index buffer - campbell */
me->editflag &= ~ME_EDIT_VERT_SEL;
totindex= sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
totindex = sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
me->editflag |= use_vert_sel ? ME_EDIT_VERT_SEL : 0;
}
else {
indexar[0]= view3d_sample_backbuf(vc, mval[0], mval[1]);
if (indexar[0]) totindex= 1;
else totindex= 0;
indexar[0] = view3d_sample_backbuf(vc, mval[0], mval[1]);
if (indexar[0]) totindex = 1;
else totindex = 0;
}
if (wp->flag & VP_COLINDEX) {
for (index=0; index<totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index] <= me->totpoly) {
MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
if (mpoly->mat_nr!=ob->actcol-1) {
indexar[index]= 0;
if (mpoly->mat_nr != ob->actcol - 1) {
indexar[index] = 0;
}
}
}
}
if ((me->editflag & ME_EDIT_PAINT_MASK) && me->mpoly) {
for (index=0; index<totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index] <= me->totpoly) {
MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
if ((mpoly->flag & ME_FACE_SEL)==0) {
indexar[index]= 0;
if ((mpoly->flag & ME_FACE_SEL) == 0) {
indexar[index] = 0;
}
}
}
}
}
/* make sure each vertex gets treated only once */
/* and calculate filter weight */
totw= 0.0f;
totw = 0.0f;
if (brush->vertexpaint_tool == PAINT_BLEND_BLUR)
paintweight= 0.0f;
paintweight = 0.0f;
else
paintweight= ts->vgroup_weight;
paintweight = ts->vgroup_weight;
for (index=0; index<totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
MPoly *mpoly= me->mpoly + (indexar[index]-1);
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index] <= me->totpoly) {
MPoly *mpoly = me->mpoly + (indexar[index] - 1);
MLoop *ml = me->mloop + mpoly->loopstart;
int i;
if (use_vert_sel) {
for (i=0; i<mpoly->totloop; i++, ml++) {
for (i = 0; i < mpoly->totloop; i++, ml++) {
me->dvert[ml->v].flag = (me->mvert[ml->v].flag & SELECT);
}
}
else {
for (i=0; i<mpoly->totloop; i++, ml++) {
for (i = 0; i < mpoly->totloop; i++, ml++) {
me->dvert[ml->v].flag = 1;
}
}
@@ -2369,14 +2369,14 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
MDeformWeight *dw, *(*dw_func)(MDeformVert *, const int);
if (wp->flag & VP_ONLYVGROUP)
dw_func= (MDeformWeight *(*)(MDeformVert *, const int))defvert_find_index;
dw_func = (MDeformWeight *(*)(MDeformVert *, const int))defvert_find_index;
else
dw_func= defvert_verify_index;
dw_func = defvert_verify_index;
ml = me->mloop + mpoly->loopstart;
for (i=0; i<mpoly->totloop; i++, ml++) {
unsigned int vidx= ml->v;
const float fac = calc_vp_strength_dl(wp, vc, wpd->vertexcosnos+6*vidx, mval, brush_size_pressure);
for (i = 0; i < mpoly->totloop; i++, ml++) {
unsigned int vidx = ml->v;
const float fac = calc_vp_strength_dl(wp, vc, wpd->vertexcosnos + 6 * vidx, mval, brush_size_pressure);
if (fac > 0.0f) {
dw = dw_func(&me->dvert[vidx], wpi.vgroup_active);
paintweight += dw ? (dw->weight * fac) : 0.0f;
@@ -2391,23 +2391,23 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
paintweight /= totw;
}
for (index=0; index<totindex; index++) {
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
MPoly *mpoly= me->mpoly + (indexar[index]-1);
MLoop *ml=me->mloop+mpoly->loopstart;
if (indexar[index] && indexar[index] <= me->totpoly) {
MPoly *mpoly = me->mpoly + (indexar[index] - 1);
MLoop *ml = me->mloop + mpoly->loopstart;
int i;
for (i=0; i<mpoly->totloop; i++, ml++) {
unsigned int vidx= ml->v;
for (i = 0; i < mpoly->totloop; i++, ml++) {
unsigned int vidx = ml->v;
if (me->dvert[vidx].flag) {
alpha= calc_vp_alpha_dl(wp, vc, wpd->wpimat, wpd->vertexcosnos+6*vidx,
alpha = calc_vp_alpha_dl(wp, vc, wpd->wpimat, wpd->vertexcosnos + 6 * vidx,
mval, brush_size_pressure, brush_alpha_pressure);
if (alpha) {
do_weight_paint_vertex(wp, ob, &wpi, vidx, alpha, paintweight);
}
me->dvert[vidx].flag= 0;
me->dvert[vidx].flag = 0;
}
}
}
@@ -2427,9 +2427,9 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
static void wpaint_stroke_done(bContext *C, struct PaintStroke *stroke)
{
ToolSettings *ts= CTX_data_tool_settings(C);
Object *ob= CTX_data_active_object(C);
struct WPaintData *wpd= paint_stroke_mode_data(stroke);
ToolSettings *ts = CTX_data_tool_settings(C);
Object *ob = CTX_data_active_object(C);
struct WPaintData *wpd = paint_stroke_mode_data(stroke);
if (wpd) {
if (wpd->vertexcosnos)
@@ -2452,9 +2452,9 @@ static void wpaint_stroke_done(bContext *C, struct PaintStroke *stroke)
ParticleSystem *psys;
int i;
for (psys= ob->particlesystem.first; psys; psys= psys->next) {
for (i=0; i<PSYS_TOT_VG; i++) {
if (psys->vgroup[i]==ob->actdef) {
for (psys = ob->particlesystem.first; psys; psys = psys->next) {
for (i = 0; i < PSYS_TOT_VG; i++) {
if (psys->vgroup[i] == ob->actdef) {
psys->recalc |= PSYS_RECALC_RESET;
break;
}
@@ -2510,7 +2510,7 @@ void PAINT_OT_weight_paint(wmOperatorType *ot)
static int weight_paint_set_exec(bContext *C, wmOperator *UNUSED(op))
{
struct Scene *scene= CTX_data_scene(C);
struct Scene *scene = CTX_data_scene(C);
Object *obact = CTX_data_active_object(C);
wpaint_fill(scene->toolsettings->wpaint, obact, scene->toolsettings->vgroup_weight);
@@ -2537,19 +2537,21 @@ void PAINT_OT_weight_set(wmOperatorType *ot)
static int set_vpaint(bContext *C, wmOperator *op) /* toggle */
{
Object *ob= CTX_data_active_object(C);
Scene *scene= CTX_data_scene(C);
VPaint *vp= scene->toolsettings->vpaint;
Object *ob = CTX_data_active_object(C);
Scene *scene = CTX_data_scene(C);
VPaint *vp = scene->toolsettings->vpaint;
Mesh *me;
me= get_mesh(ob);
me = get_mesh(ob);
if (me==NULL || object_data_is_libdata(ob)) {
if (me == NULL || object_data_is_libdata(ob)) {
ob->mode &= ~OB_MODE_VERTEX_PAINT;
return OPERATOR_PASS_THROUGH;
}
if (me && me->mloopcol==NULL) make_vertexcol(ob);
if (me && me->mloopcol == NULL) {
make_vertexcol(ob);
}
/* toggle: end vpaint */
if (ob->mode & OB_MODE_VERTEX_PAINT) {
@@ -2562,8 +2564,8 @@ static int set_vpaint(bContext *C, wmOperator *op) /* toggle */
if (ob->mode & OB_MODE_WEIGHT_PAINT)
set_wpaint(C, op);
if (vp==NULL)
vp= scene->toolsettings->vpaint= new_vpaint(0);
if (vp == NULL)
vp = scene->toolsettings->vpaint = new_vpaint(0);
paint_cursor_start(C, vertex_paint_poll);
@@ -2632,7 +2634,7 @@ typedef struct VPaintData {
* otherwise we need to refresh the modifier stack */
int use_fast_update;
/*mpoly -> mface mapping*/
/* mpoly -> mface mapping */
MemArena *polyfacemap_arena;
ListBase *polyfacemap;
} VPaintData;
@@ -2644,10 +2646,10 @@ static void vpaint_build_poly_facemap(struct VPaintData *vd, Mesh *me)
int *origIndex;
int i;
vd->polyfacemap_arena = BLI_memarena_new(1<<13, "vpaint tmp");
vd->polyfacemap_arena = BLI_memarena_new(1 << 13, "vpaint tmp");
BLI_memarena_use_calloc(vd->polyfacemap_arena);
vd->polyfacemap = BLI_memarena_alloc(vd->polyfacemap_arena, sizeof(ListBase)*me->totpoly);
vd->polyfacemap = BLI_memarena_alloc(vd->polyfacemap_arena, sizeof(ListBase) * me->totpoly);
origIndex = CustomData_get_layer(&me->fdata, CD_POLYINDEX);
mf = me->mface;
@@ -2655,7 +2657,7 @@ static void vpaint_build_poly_facemap(struct VPaintData *vd, Mesh *me)
if (!origIndex)
return;
for (i=0; i<me->totface; i++, mf++, origIndex++) {
for (i = 0; i < me->totface; i++, mf++, origIndex++) {
if (*origIndex == ORIGINDEX_NONE)
continue;
@@ -2668,32 +2670,32 @@ static void vpaint_build_poly_facemap(struct VPaintData *vd, Mesh *me)
static int vpaint_stroke_test_start(bContext *C, struct wmOperator *op, wmEvent *UNUSED(event))
{
ToolSettings *ts= CTX_data_tool_settings(C);
ToolSettings *ts = CTX_data_tool_settings(C);
struct PaintStroke *stroke = op->customdata;
VPaint *vp= ts->vpaint;
VPaint *vp = ts->vpaint;
struct VPaintData *vpd;
Object *ob= CTX_data_active_object(C);
Object *ob = CTX_data_active_object(C);
Mesh *me;
float mat[4][4], imat[4][4];
/* context checks could be a poll() */
me= get_mesh(ob);
if (me==NULL || me->totpoly==0)
me = get_mesh(ob);
if (me == NULL || me->totpoly == 0)
return OPERATOR_PASS_THROUGH;
if (me->mloopcol==NULL)
if (me->mloopcol == NULL)
make_vertexcol(ob);
if (me->mloopcol==NULL)
if (me->mloopcol == NULL)
return OPERATOR_CANCELLED;
/* make mode data storage */
vpd= MEM_callocN(sizeof(struct VPaintData), "VPaintData");
vpd = MEM_callocN(sizeof(struct VPaintData), "VPaintData");
paint_stroke_set_mode_data(stroke, vpd);
view3d_set_viewcontext(C, &vpd->vc);
vpd->vertexcosnos= mesh_get_mapped_verts_nors(vpd->vc.scene, ob);
vpd->indexar= get_indexarray(me);
vpd->paintcol= vpaint_get_current_col(vp);
vpd->vertexcosnos = mesh_get_mapped_verts_nors(vpd->vc.scene, ob);
vpd->indexar = get_indexarray(me);
vpd->paintcol = vpaint_get_current_col(vp);
/* are we painting onto a modified mesh?,
@@ -2726,36 +2728,36 @@ static void vpaint_paint_face(VPaint *vp, VPaintData *vpd, Object *ob,
ViewContext *vc = &vpd->vc;
Brush *brush = paint_brush(&vp->paint);
Mesh *me = get_mesh(ob);
MFace *mface= &me->mface[index];
unsigned int *mcol= ((unsigned int*)me->mcol) + 4*index;
unsigned int *mcolorig= ((unsigned int*)vp->vpaint_prev) + 4*index;
MFace *mface = &me->mface[index];
unsigned int *mcol = ((unsigned int *)me->mcol) + 4 * index;
unsigned int *mcolorig = ((unsigned int *)vp->vpaint_prev) + 4 * index;
float alpha;
int i;
int brush_alpha_pressure_i;
if ((vp->flag & VP_COLINDEX && mface->mat_nr!=ob->actcol-1) ||
if ((vp->flag & VP_COLINDEX && mface->mat_nr != ob->actcol - 1) ||
((me->editflag & ME_EDIT_PAINT_MASK) && !(mface->flag & ME_FACE_SEL)))
return;
if (brush->vertexpaint_tool == PAINT_BLEND_BLUR) {
unsigned int fcol1= mcol_blend( mcol[0], mcol[1], 128);
unsigned int fcol1 = mcol_blend( mcol[0], mcol[1], 128);
if (mface->v4) {
unsigned int fcol2= mcol_blend( mcol[2], mcol[3], 128);
vpd->paintcol= mcol_blend( fcol1, fcol2, 128);
unsigned int fcol2 = mcol_blend( mcol[2], mcol[3], 128);
vpd->paintcol = mcol_blend( fcol1, fcol2, 128);
}
else {
vpd->paintcol= mcol_blend( mcol[2], fcol1, 170);
vpd->paintcol = mcol_blend( mcol[2], fcol1, 170);
}
}
brush_alpha_pressure_i = (int)(brush_alpha_pressure*255.0f);
brush_alpha_pressure_i = (int)(brush_alpha_pressure * 255.0f);
for (i = 0; i < (mface->v4 ? 4 : 3); ++i) {
alpha = calc_vp_alpha_dl(vp, vc, vpd->vpimat, vpd->vertexcosnos+6*(&mface->v1)[i],
alpha = calc_vp_alpha_dl(vp, vc, vpd->vpimat, vpd->vertexcosnos + 6 * (&mface->v1)[i],
mval, brush_size_pressure, brush_alpha_pressure);
if (alpha) {
const int alpha_i = (int)(alpha*255.0f);
const int alpha_i = (int)(alpha * 255.0f);
mcol[i] = vpaint_blend(vp, mcol[i], mcolorig[i], vpd->paintcol, alpha_i, brush_alpha_pressure_i);
}
}
@@ -2773,25 +2775,25 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
ViewContext *vc = &vpd->vc;
Brush *brush = paint_brush(&vp->paint);
Mesh *me = get_mesh(ob);
MPoly *mpoly= &me->mpoly[index];
MPoly *mpoly = &me->mpoly[index];
MFace *mf;
MCol *mc;
MLoop *ml;
MLoopCol *mlc;
polyfacemap_e *e;
unsigned int *lcol = ((unsigned int*)me->mloopcol) + mpoly->loopstart;
unsigned int *lcolorig = ((unsigned int*)vp->vpaint_prev) + mpoly->loopstart;
unsigned int *lcol = ((unsigned int *)me->mloopcol) + mpoly->loopstart;
unsigned int *lcolorig = ((unsigned int *)vp->vpaint_prev) + mpoly->loopstart;
float alpha;
int i, j;
int brush_alpha_pressure_i = (int)(brush_alpha_pressure*255.0f);
int brush_alpha_pressure_i = (int)(brush_alpha_pressure * 255.0f);
if (brush->vertexpaint_tool == PAINT_BLEND_BLUR) {
unsigned int blend[4] = {0};
unsigned int tcol;
char *col;
for (j=0; j<mpoly->totloop; j++) {
for (j = 0; j < mpoly->totloop; j++) {
col = (char *)(lcol + j);
blend[0] += col[0];
blend[1] += col[1];
@@ -2813,12 +2815,12 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
}
ml = me->mloop + mpoly->loopstart;
for (i=0; i<mpoly->totloop; i++, ml++) {
alpha= calc_vp_alpha_dl(vp, vc, vpd->vpimat,
vpd->vertexcosnos+6*ml->v, mval,
brush_size_pressure, brush_alpha_pressure);
for (i = 0; i < mpoly->totloop; i++, ml++) {
alpha = calc_vp_alpha_dl(vp, vc, vpd->vpimat,
vpd->vertexcosnos + 6 * ml->v, mval,
brush_size_pressure, brush_alpha_pressure);
if (alpha > 0.0f) {
const int alpha_i = (int)(alpha*255.0f);
const int alpha_i = (int)(alpha * 255.0f);
lcol[i] = vpaint_blend(vp, lcol[i], lcolorig[i], vpd->paintcol, alpha_i, brush_alpha_pressure_i);
}
}
@@ -2834,19 +2836,19 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
* rather then regenerating the tessellation altogether */
for (e = vpd->polyfacemap[index].first; e; e = e->next) {
mf = me->mface + e->facenr;
mc = me->mcol + e->facenr*4;
mc = me->mcol + e->facenr * 4;
ml = me->mloop + mpoly->loopstart;
mlc = me->mloopcol + mpoly->loopstart;
for (j=0; j<mpoly->totloop; j++, ml++, mlc++) {
for (j = 0; j < mpoly->totloop; j++, ml++, mlc++) {
if (ml->v == mf->v1)
CPYCOL(mc, mlc);
else if (ml->v == mf->v2)
CPYCOL(mc+1, mlc);
CPYCOL(mc + 1, mlc);
else if (ml->v == mf->v3)
CPYCOL(mc+2, mlc);
CPYCOL(mc + 2, mlc);
else if (mf->v4 && ml->v == mf->v4)
CPYCOL(mc+3, mlc);
CPYCOL(mc + 3, mlc);
}
}
@@ -2857,16 +2859,16 @@ static void vpaint_paint_poly(VPaint *vp, VPaintData *vpd, Object *ob,
static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, PointerRNA *itemptr)
{
Scene *scene= CTX_data_scene(C);
ToolSettings *ts= CTX_data_tool_settings(C);
Scene *scene = CTX_data_scene(C);
ToolSettings *ts = CTX_data_tool_settings(C);
struct VPaintData *vpd = paint_stroke_mode_data(stroke);
VPaint *vp= ts->vpaint;
VPaint *vp = ts->vpaint;
Brush *brush = paint_brush(&vp->paint);
ViewContext *vc= &vpd->vc;
Object *ob= vc->obact;
Mesh *me= ob->data;
ViewContext *vc = &vpd->vc;
Object *ob = vc->obact;
Mesh *me = ob->data;
float mat[4][4];
int *indexar= vpd->indexar;
int *indexar = vpd->indexar;
int totindex, index, flip;
float mval[2];
@@ -2884,40 +2886,40 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
/* load projection matrix */
mult_m4_m4m4(mat, vc->rv3d->persmat, ob->obmat);
mval[0]-= vc->ar->winrct.xmin;
mval[1]-= vc->ar->winrct.ymin;
mval[0] -= vc->ar->winrct.xmin;
mval[1] -= vc->ar->winrct.ymin;
/* which faces are involved */
if (vp->flag & VP_AREA) {
totindex= sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
totindex = sample_backbuf_area(vc, indexar, me->totpoly, mval[0], mval[1], brush_size_pressure);
}
else {
indexar[0]= view3d_sample_backbuf(vc, mval[0], mval[1]);
if (indexar[0]) totindex= 1;
else totindex= 0;
indexar[0] = view3d_sample_backbuf(vc, mval[0], mval[1]);
if (indexar[0]) totindex = 1;
else totindex = 0;
}
if (vp->flag & VP_COLINDEX) {
for (index=0; index<totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index] <= me->totpoly) {
MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
if (mpoly->mat_nr!=ob->actcol-1) {
indexar[index]= 0;
if (mpoly->mat_nr != ob->actcol - 1) {
indexar[index] = 0;
}
}
}
}
if ((me->editflag & ME_EDIT_PAINT_MASK) && me->mpoly) {
for (index=0; index<totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
MPoly *mpoly= ((MPoly *)me->mpoly) + (indexar[index]-1);
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index] <= me->totpoly) {
MPoly *mpoly = ((MPoly *)me->mpoly) + (indexar[index] - 1);
if ((mpoly->flag & ME_FACE_SEL)==0)
indexar[index]= 0;
if ((mpoly->flag & ME_FACE_SEL) == 0)
indexar[index] = 0;
}
}
}
@@ -2925,10 +2927,10 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
swap_m4m4(vc->rv3d->persmat, mat);
for (index=0; index<totindex; index++) {
for (index = 0; index < totindex; index++) {
if (indexar[index] && indexar[index]<=me->totpoly) {
vpaint_paint_poly(vp, vpd, ob, indexar[index]-1, mval, brush_size_pressure, brush_alpha_pressure, flip);
if (indexar[index] && indexar[index] <= me->totpoly) {
vpaint_paint_poly(vp, vpd, ob, indexar[index] - 1, mval, brush_size_pressure, brush_alpha_pressure, flip);
}
}
@@ -2951,8 +2953,8 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
static void vpaint_stroke_done(bContext *C, struct PaintStroke *stroke)
{
ToolSettings *ts= CTX_data_tool_settings(C);
struct VPaintData *vpd= paint_stroke_mode_data(stroke);
ToolSettings *ts = CTX_data_tool_settings(C);
struct VPaintData *vpd = paint_stroke_mode_data(stroke);
if (vpd->vertexcosnos)
MEM_freeN(vpd->vertexcosnos);
@@ -3013,18 +3015,18 @@ void PAINT_OT_vertex_paint(wmOperatorType *ot)
static int weight_from_bones_poll(bContext *C)
{
Object *ob= CTX_data_active_object(C);
Object *ob = CTX_data_active_object(C);
return (ob && (ob->mode & OB_MODE_WEIGHT_PAINT) && modifiers_isDeformedByArmature(ob));
}
static int weight_from_bones_exec(bContext *C, wmOperator *op)
{
Scene *scene= CTX_data_scene(C);
Object *ob= CTX_data_active_object(C);
Object *armob= modifiers_isDeformedByArmature(ob);
Mesh *me= ob->data;
int type= RNA_enum_get(op->ptr, "type");
Scene *scene = CTX_data_scene(C);
Object *ob = CTX_data_active_object(C);
Object *armob = modifiers_isDeformedByArmature(ob);
Mesh *me = ob->data;
int type = RNA_enum_get(op->ptr, "type");
create_vgroups_from_armature(op->reports, scene, ob, armob, type, (me->editflag & ME_EDIT_MIRROR_X));
@@ -3036,7 +3038,7 @@ static int weight_from_bones_exec(bContext *C, wmOperator *op)
void PAINT_OT_weight_from_bones(wmOperatorType *ot)
{
static EnumPropertyItem type_items[]= {
static EnumPropertyItem type_items[] = {
{ARM_GROUPS_AUTO, "AUTOMATIC", 0, "Automatic", "Automatic weights froms bones"},
{ARM_GROUPS_ENVELOPE, "ENVELOPES", 0, "From Envelopes", "Weights from envelopes with user defined radius"},
{0, NULL, 0, NULL, NULL}};