From ffed654ff2a1349b735026aafde6f8937a4a3f15 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sun, 6 May 2012 17:22:54 +0000 Subject: style cleanup: blenkernel --- source/blender/blenkernel/intern/anim.c | 718 +++++----- source/blender/blenkernel/intern/blender.c | 244 ++-- source/blender/blenkernel/intern/bvhutils.c | 115 +- source/blender/blenkernel/intern/cdderivedmesh.c | 498 +++---- source/blender/blenkernel/intern/colortools.c | 726 +++++----- source/blender/blenkernel/intern/constraint.c | 1650 +++++++++++----------- source/blender/blenkernel/intern/context.c | 236 ++-- source/blender/blenkernel/intern/depsgraph.c | 898 ++++++------ source/blender/blenkernel/intern/displist.c | 830 +++++------ source/blender/blenkernel/intern/fcurve.c | 798 +++++------ source/blender/blenkernel/intern/fmodifier.c | 450 +++--- source/blender/blenkernel/intern/idprop.c | 134 +- source/blender/blenkernel/intern/image_gen.c | 214 +-- source/blender/blenkernel/intern/library.c | 513 +++---- source/blender/blenkernel/intern/modifier.c | 116 +- source/blender/blenkernel/intern/multires.c | 486 +++---- source/blender/blenkernel/intern/packedFile.c | 70 +- source/blender/blenkernel/intern/property.c | 182 +-- source/blender/blenkernel/intern/texture.c | 14 +- 19 files changed, 4444 insertions(+), 4448 deletions(-) (limited to 'source/blender') diff --git a/source/blender/blenkernel/intern/anim.c b/source/blender/blenkernel/intern/anim.c index f3b106efe33..ed6eceb036b 100644 --- a/source/blender/blenkernel/intern/anim.c +++ b/source/blender/blenkernel/intern/anim.c @@ -88,23 +88,23 @@ void animviz_settings_init(bAnimVizSettings *avs) return; /* ghosting settings */ - avs->ghost_bc= avs->ghost_ac= 10; + avs->ghost_bc = avs->ghost_ac = 10; - avs->ghost_sf= 1; // xxx - take from scene instead? - avs->ghost_ef= 250; // xxx - take from scene instead? + avs->ghost_sf = 1; // xxx - take from scene instead? + avs->ghost_ef = 250; // xxx - take from scene instead? - avs->ghost_step= 1; + avs->ghost_step = 1; /* path settings */ - avs->path_bc= avs->path_ac= 10; + avs->path_bc = avs->path_ac = 10; - avs->path_sf= 1; // xxx - take from scene instead? - avs->path_ef= 250; // xxx - take from scene instead? + avs->path_sf = 1; // xxx - take from scene instead? + avs->path_ef = 250; // xxx - take from scene instead? - avs->path_viewflag= (MOTIONPATH_VIEW_KFRAS|MOTIONPATH_VIEW_KFNOS); + avs->path_viewflag = (MOTIONPATH_VIEW_KFRAS | MOTIONPATH_VIEW_KFNOS); - avs->path_step= 1; + avs->path_step = 1; } /* ------------------- */ @@ -121,8 +121,8 @@ void animviz_free_motionpath_cache(bMotionPath *mpath) MEM_freeN(mpath->points); /* reset the relevant parameters */ - mpath->points= NULL; - mpath->length= 0; + mpath->points = NULL; + mpath->length = 0; } /* Free the given motion path instance and its data @@ -162,22 +162,22 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports, Scene *scene, Objec /* get destination data */ if (pchan) { /* paths for posechannel - assume that posechannel belongs to the object */ - avs= &ob->pose->avs; - dst= &pchan->mpath; + avs = &ob->pose->avs; + dst = &pchan->mpath; } else { /* paths for object */ - avs= &ob->avs; - dst= &ob->mpath; + avs = &ob->avs; + dst = &ob->mpath; } /* avoid 0 size allocs */ if (avs->path_sf >= avs->path_ef) { BKE_reportf(reports, RPT_ERROR, - "Motion Path frame extents invalid for %s (%d to %d).%s\n", - (pchan)? pchan->name : ob->id.name, - avs->path_sf, avs->path_ef, - (avs->path_sf == avs->path_ef)? " Cannot have single-frame paths." : ""); + "Motion Path frame extents invalid for %s (%d to %d).%s\n", + (pchan) ? pchan->name : ob->id.name, + avs->path_sf, avs->path_ef, + (avs->path_sf == avs->path_ef) ? " Cannot have single-frame paths." : ""); return NULL; } @@ -187,7 +187,7 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports, Scene *scene, Objec if (*dst != NULL) { int expected_length = avs->path_ef - avs->path_sf; - mpath= *dst; + mpath = *dst; /* path is "valid" if length is valid, but must also be of the same length as is being requested */ if ((mpath->start_frame != mpath->end_frame) && (mpath->length > 0)) { @@ -204,15 +204,15 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports, Scene *scene, Objec } else { /* create a new motionpath, and assign it */ - mpath= MEM_callocN(sizeof(bMotionPath), "bMotionPath"); - *dst= mpath; + mpath = MEM_callocN(sizeof(bMotionPath), "bMotionPath"); + *dst = mpath; } /* set settings from the viz settings */ - mpath->start_frame= avs->path_sf; - mpath->end_frame= avs->path_ef; + mpath->start_frame = avs->path_sf; + mpath->end_frame = avs->path_ef; - mpath->length= mpath->end_frame - mpath->start_frame; + mpath->length = mpath->end_frame - mpath->start_frame; if (avs->path_bakeflag & MOTIONPATH_BAKE_HEADS) mpath->flag |= MOTIONPATH_FLAG_BHEAD; @@ -220,7 +220,7 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports, Scene *scene, Objec mpath->flag &= ~MOTIONPATH_FLAG_BHEAD; /* allocate a cache */ - mpath->points= MEM_callocN(sizeof(bMotionPathVert)*mpath->length, "bMotionPathVerts"); + mpath->points = MEM_callocN(sizeof(bMotionPathVert) * mpath->length, "bMotionPathVerts"); /* tag viz settings as currently having some path(s) which use it */ avs->path_bakeflag |= MOTIONPATH_BAKE_HAS_PATHS; @@ -235,16 +235,16 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports, Scene *scene, Objec typedef struct MPathTarget { struct MPathTarget *next, *prev; - bMotionPath *mpath; /* motion path in question */ + bMotionPath *mpath; /* motion path in question */ - Object *ob; /* source object */ - bPoseChannel *pchan; /* source posechannel (if applicable) */ + Object *ob; /* source object */ + bPoseChannel *pchan; /* source posechannel (if applicable) */ } MPathTarget; /* ........ */ /* get list of motion paths to be baked for the given object - * - assumes the given list is ready to be used + * - assumes the given list is ready to be used */ // TODO: it would be nice in future to be able to update objects dependent on these bones too? void animviz_get_object_motionpaths(Object *ob, ListBase *targets) @@ -254,27 +254,27 @@ void animviz_get_object_motionpaths(Object *ob, ListBase *targets) /* object itself first */ if ((ob->avs.recalc & ANIMVIZ_RECALC_PATHS) && (ob->mpath)) { /* new target for object */ - mpt= MEM_callocN(sizeof(MPathTarget), "MPathTarget Ob"); + mpt = MEM_callocN(sizeof(MPathTarget), "MPathTarget Ob"); BLI_addtail(targets, mpt); - mpt->mpath= ob->mpath; - mpt->ob= ob; + mpt->mpath = ob->mpath; + mpt->ob = ob; } /* bones */ if ((ob->pose) && (ob->pose->avs.recalc & ANIMVIZ_RECALC_PATHS)) { - bArmature *arm= ob->data; + bArmature *arm = ob->data; bPoseChannel *pchan; - for (pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) { + for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) { if ((pchan->bone) && (arm->layer & pchan->bone->layer) && (pchan->mpath)) { /* new target for bone */ - mpt= MEM_callocN(sizeof(MPathTarget), "MPathTarget PoseBone"); + mpt = MEM_callocN(sizeof(MPathTarget), "MPathTarget PoseBone"); BLI_addtail(targets, mpt); - mpt->mpath= pchan->mpath; - mpt->ob= ob; - mpt->pchan= pchan; + mpt->mpath = pchan->mpath; + mpt->ob = ob; + mpt->pchan = pchan; } } } @@ -296,12 +296,12 @@ static void motionpaths_calc_optimise_depsgraph(Scene *scene, ListBase *targets) MPathTarget *mpt; /* make sure our temp-tag isn't already in use */ - for (base= scene->base.first; base; base= base->next) + for (base = scene->base.first; base; base = base->next) base->object->flag &= ~BA_TEMP_TAG; /* for each target, dump its object to the start of the list if it wasn't moved already */ - for (mpt= targets->first; mpt; mpt= mpt->next) { - for (base=scene->base.first; base; base=baseNext) { + for (mpt = targets->first; mpt; mpt = mpt->next) { + for (base = scene->base.first; base; base = baseNext) { baseNext = base->next; if ((base->object == mpt->ob) && !(mpt->ob->flag & BA_TEMP_TAG)) { @@ -322,7 +322,7 @@ static void motionpaths_calc_optimise_depsgraph(Scene *scene, ListBase *targets) static void motionpaths_calc_update_scene(Scene *scene) { #if 1 // 'production' optimisations always on - Base *base, *last=NULL; + Base *base, *last = NULL; /* only stuff that moves or needs display still */ DAG_scene_update_flags(G.main, scene, scene->lay, TRUE); @@ -331,7 +331,7 @@ static void motionpaths_calc_update_scene(Scene *scene) * - all those afterwards are assumed to not be relevant for our calculations */ // optimize further by moving out... - for (base=scene->base.first; base; base=base->next) { + for (base = scene->base.first; base; base = base->next) { if (base->object->flag & BA_TEMP_TAG) last = base; } @@ -339,7 +339,7 @@ static void motionpaths_calc_update_scene(Scene *scene) /* perform updates for tagged objects */ // XXX: this will break if rigs depend on scene or other data that // is animated but not attached to/updatable from objects - for (base=scene->base.first; base; base=base->next) { + for (base = scene->base.first; base; base = base->next) { /* update this object */ BKE_object_handle_update(scene, base->object); @@ -348,11 +348,11 @@ static void motionpaths_calc_update_scene(Scene *scene) break; } #else // original, 'always correct' version - /* do all updates - * - if this is too slow, resort to using a more efficient way - * that doesn't force complete update, but for now, this is the - * most accurate way! - */ + /* do all updates + * - if this is too slow, resort to using a more efficient way + * that doesn't force complete update, but for now, this is the + * most accurate way! + */ BKE_scene_update_for_newframe(G.main, scene, scene->lay); // XXX this is the best way we can get anything moving #endif } @@ -365,8 +365,8 @@ static void motionpaths_calc_bake_targets(Scene *scene, ListBase *targets) MPathTarget *mpt; /* for each target, check if it can be baked on the current frame */ - for (mpt= targets->first; mpt; mpt= mpt->next) { - bMotionPath *mpath= mpt->mpath; + for (mpt = targets->first; mpt; mpt = mpt->next) { + bMotionPath *mpath = mpt->mpath; bMotionPathVert *mpv; /* current frame must be within the range the cache works for @@ -376,7 +376,7 @@ static void motionpaths_calc_bake_targets(Scene *scene, ListBase *targets) continue; /* get the relevant cache vert to write to */ - mpv= mpath->points + (CFRA - mpath->start_frame); + mpv = mpath->points + (CFRA - mpath->start_frame); /* pose-channel or object path baking? */ if (mpt->pchan) { @@ -421,10 +421,10 @@ void animviz_calc_motionpaths(Scene *scene, ListBase *targets) // TODO: this method could be improved... // 1) max range for standard baking // 2) minimum range for recalc baking (i.e. between keyframes, but how?) - for (mpt= targets->first; mpt; mpt= mpt->next) { + for (mpt = targets->first; mpt; mpt = mpt->next) { /* try to increase area to do (only as much as needed) */ - sfra= MIN2(sfra, mpt->mpath->start_frame); - efra= MAX2(efra, mpt->mpath->end_frame); + sfra = MIN2(sfra, mpt->mpath->start_frame); + efra = MAX2(efra, mpt->mpath->end_frame); } if (efra <= sfra) return; @@ -433,7 +433,7 @@ void animviz_calc_motionpaths(Scene *scene, ListBase *targets) motionpaths_calc_optimise_depsgraph(scene, targets); /* calculate path over requested range */ - for (CFRA=sfra; CFRA<=efra; CFRA++) { + for (CFRA = sfra; CFRA <= efra; CFRA++) { /* update relevant data for new frame */ motionpaths_calc_update_scene(scene); @@ -442,18 +442,18 @@ void animviz_calc_motionpaths(Scene *scene, ListBase *targets) } /* reset original environment */ - CFRA= cfra; + CFRA = cfra; motionpaths_calc_update_scene(scene); /* clear recalc flags from targets */ - for (mpt= targets->first; mpt; mpt= mpt->next) { + for (mpt = targets->first; mpt; mpt = mpt->next) { bAnimVizSettings *avs; /* get pointer to animviz settings for each target */ if (mpt->pchan) - avs= &mpt->ob->pose->avs; + avs = &mpt->ob->pose->avs; else - avs= &mpt->ob->avs; + avs = &mpt->ob->avs; /* clear the flag requesting recalculation of targets */ avs->recalc &= ~ANIMVIZ_RECALC_PATHS; @@ -474,7 +474,7 @@ void free_path(Path *path) } /* calculate a curve-deform path for a curve - * - only called from displist.c -> do_makeDispListCurveTypes + * - only called from displist.c -> do_makeDispListCurveTypes */ void calc_curvepath(Object *ob) { @@ -485,92 +485,92 @@ void calc_curvepath(Object *ob) Nurb *nu; Path *path; float *fp, *dist, *maxdist, xyz[3]; - float fac, d=0, fac1, fac2; - int a, tot, cycl=0; + float fac, d = 0, fac1, fac2; + int a, tot, cycl = 0; ListBase *nurbs; /* in a path vertices are with equal differences: path->len = number of verts */ /* NOW WITH BEVELCURVE!!! */ - if (ob==NULL || ob->type != OB_CURVE) return; - cu= ob->data; + if (ob == NULL || ob->type != OB_CURVE) return; + cu = ob->data; - nurbs= BKE_curve_nurbs_get(cu); - nu= nurbs->first; + nurbs = BKE_curve_nurbs_get(cu); + nu = nurbs->first; if (cu->path) free_path(cu->path); - cu->path= NULL; + cu->path = NULL; - bl= cu->bev.first; - if (bl==NULL || !bl->nr) return; + bl = cu->bev.first; + if (bl == NULL || !bl->nr) return; - cu->path=path= MEM_callocN(sizeof(Path), "calc_curvepath"); + cu->path = path = MEM_callocN(sizeof(Path), "calc_curvepath"); /* if POLY: last vertice != first vertice */ - cycl= (bl->poly!= -1); + cycl = (bl->poly != -1); - if (cycl) tot= bl->nr; - else tot= bl->nr-1; + if (cycl) tot = bl->nr; + else tot = bl->nr - 1; - path->len= tot+1; + path->len = tot + 1; /* exception: vector handle paths and polygon paths should be subdivided at least a factor resolu */ - if (path->lenresolu*SEGMENTSU(nu)) path->len= nu->resolu*SEGMENTSU(nu); + if (path->len < nu->resolu * SEGMENTSU(nu)) path->len = nu->resolu * SEGMENTSU(nu); - dist= (float *)MEM_mallocN((tot+1)*4, "calcpathdist"); + dist = (float *)MEM_mallocN((tot + 1) * 4, "calcpathdist"); - /* all lengths in *dist */ - bevp= bevpfirst= (BevPoint *)(bl+1); - fp= dist; - *fp= 0; - for (a=0; avec, bevp->vec); else - sub_v3_v3v3(xyz, (bevp+1)->vec, bevp->vec); + sub_v3_v3v3(xyz, (bevp + 1)->vec, bevp->vec); - *fp= *(fp-1)+len_v3(xyz); + *fp = *(fp - 1) + len_v3(xyz); bevp++; } - path->totdist= *fp; - - /* the path verts in path->data */ - /* now also with TILT value */ - pp= path->data = (PathPoint *)MEM_callocN(sizeof(PathPoint)*path->len, "pathdata"); + path->totdist = *fp; - bevp= bevpfirst; - bevpn= bevp+1; - bevplast= bevpfirst + (bl->nr-1); - fp= dist+1; - maxdist= dist+tot; - fac= 1.0f/((float)path->len-1.0f); - fac = fac * path->totdist; + /* the path verts in path->data */ + /* now also with TILT value */ + pp = path->data = (PathPoint *)MEM_callocN(sizeof(PathPoint) * path->len, "pathdata"); + + bevp = bevpfirst; + bevpn = bevp + 1; + bevplast = bevpfirst + (bl->nr - 1); + fp = dist + 1; + maxdist = dist + tot; + fac = 1.0f / ((float)path->len - 1.0f); + fac = fac * path->totdist; - for (a=0; alen; a++) { + for (a = 0; a < path->len; a++) { - d= ((float)a)*fac; + d = ((float)a) * fac; /* we're looking for location (distance) 'd' in the array */ - while ((d>= *fp) && fp= *fp) && fp < maxdist) { fp++; - if (bevpbevplast) { - if (cycl) bevpn= bevpfirst; - else bevpn= bevplast; + if (bevp < bevplast) bevp++; + bevpn = bevp + 1; + if (bevpn > bevplast) { + if (cycl) bevpn = bevpfirst; + else bevpn = bevplast; } } - fac1= *(fp)- *(fp-1); - fac2= *(fp)-d; - fac1= fac2/fac1; - fac2= 1.0f-fac1; + fac1 = *(fp) - *(fp - 1); + fac2 = *(fp) - d; + fac1 = fac2 / fac1; + fac2 = 1.0f - fac1; interp_v3_v3v3(pp->vec, bevp->vec, bevpn->vec, fac2); - pp->vec[3]= fac1*bevp->alfa + fac2*bevpn->alfa; - pp->radius= fac1*bevp->radius + fac2*bevpn->radius; - pp->weight= fac1*bevp->weight + fac2*bevpn->weight; + pp->vec[3] = fac1 * bevp->alfa + fac2 * bevpn->alfa; + pp->radius = fac1 * bevp->radius + fac2 * bevpn->radius; + pp->weight = fac1 * bevp->weight + fac2 * bevpn->weight; interp_qt_qtqt(pp->quat, bevp->quat, bevpn->quat, fac2); normalize_qt(pp->quat); @@ -586,13 +586,13 @@ int interval_test(int min, int max, int p1, int cycl) { if (cycl) { if (p1 < min) - p1= ((p1 -min) % (max-min+1)) + max+1; + p1 = ((p1 - min) % (max - min + 1)) + max + 1; else if (p1 > max) - p1= ((p1 -min) % (max-min+1)) + min; + p1 = ((p1 - min) % (max - min + 1)) + min; } else { - if (p1 < min) p1= min; - else if (p1 > max) p1= max; + if (p1 < min) p1 = min; + else if (p1 > max) p1 = max; } return p1; } @@ -614,84 +614,84 @@ int where_on_path(Object *ob, float ctime, float vec[4], float dir[3], float qua PathPoint *pp, *p0, *p1, *p2, *p3; float fac; float data[4]; - int cycl=0, s0, s1, s2, s3; + int cycl = 0, s0, s1, s2, s3; - if (ob==NULL || ob->type != OB_CURVE) return 0; - cu= ob->data; - if (cu->path==NULL || cu->path->data==NULL) { + if (ob == NULL || ob->type != OB_CURVE) return 0; + cu = ob->data; + if (cu->path == NULL || cu->path->data == NULL) { printf("no path!\n"); return 0; } - path= cu->path; - pp= path->data; + path = cu->path; + pp = path->data; /* test for cyclic */ - bl= cu->bev.first; + bl = cu->bev.first; if (!bl) return 0; if (!bl->nr) return 0; - if (bl->poly> -1) cycl= 1; + if (bl->poly > -1) cycl = 1; - ctime *= (path->len-1); + ctime *= (path->len - 1); - s1= (int)floor(ctime); - fac= (float)(s1+1)-ctime; + s1 = (int)floor(ctime); + fac = (float)(s1 + 1) - ctime; /* path->len is corected for cyclic */ - s0= interval_test(0, path->len-1-cycl, s1-1, cycl); - s1= interval_test(0, path->len-1-cycl, s1, cycl); - s2= interval_test(0, path->len-1-cycl, s1+1, cycl); - s3= interval_test(0, path->len-1-cycl, s1+2, cycl); + s0 = interval_test(0, path->len - 1 - cycl, s1 - 1, cycl); + s1 = interval_test(0, path->len - 1 - cycl, s1, cycl); + s2 = interval_test(0, path->len - 1 - cycl, s1 + 1, cycl); + s3 = interval_test(0, path->len - 1 - cycl, s1 + 2, cycl); - p0= pp + s0; - p1= pp + s1; - p2= pp + s2; - p3= pp + s3; + p0 = pp + s0; + p1 = pp + s1; + p2 = pp + s2; + p3 = pp + s3; /* note, commented out for follow constraint */ //if (cu->flag & CU_FOLLOW) { - key_curve_tangent_weights(1.0f-fac, data, KEY_BSPLINE); + key_curve_tangent_weights(1.0f - fac, data, KEY_BSPLINE); - interp_v3_v3v3v3v3(dir, p0->vec, p1->vec, p2->vec, p3->vec, data); + interp_v3_v3v3v3v3(dir, p0->vec, p1->vec, p2->vec, p3->vec, data); - /* make compatible with vectoquat */ - negate_v3(dir); + /* make compatible with vectoquat */ + negate_v3(dir); //} - nu= cu->nurb.first; + nu = cu->nurb.first; /* make sure that first and last frame are included in the vectors here */ - if (nu->type == CU_POLY) key_curve_position_weights(1.0f-fac, data, KEY_LINEAR); - else if (nu->type == CU_BEZIER) key_curve_position_weights(1.0f-fac, data, KEY_LINEAR); - else if (s0==s1 || p2==p3) key_curve_position_weights(1.0f-fac, data, KEY_CARDINAL); - else key_curve_position_weights(1.0f-fac, data, KEY_BSPLINE); + if (nu->type == CU_POLY) key_curve_position_weights(1.0f - fac, data, KEY_LINEAR); + else if (nu->type == CU_BEZIER) key_curve_position_weights(1.0f - fac, data, KEY_LINEAR); + else if (s0 == s1 || p2 == p3) key_curve_position_weights(1.0f - fac, data, KEY_CARDINAL); + else key_curve_position_weights(1.0f - fac, data, KEY_BSPLINE); - vec[0]= data[0]*p0->vec[0] + data[1]*p1->vec[0] + data[2]*p2->vec[0] + data[3]*p3->vec[0] ; /* X */ - vec[1]= data[0]*p0->vec[1] + data[1]*p1->vec[1] + data[2]*p2->vec[1] + data[3]*p3->vec[1] ; /* Y */ - vec[2]= data[0]*p0->vec[2] + data[1]*p1->vec[2] + data[2]*p2->vec[2] + data[3]*p3->vec[2] ; /* Z */ - vec[3]= data[0]*p0->vec[3] + data[1]*p1->vec[3] + data[2]*p2->vec[3] + data[3]*p3->vec[3] ; /* Tilt, should not be needed since we have quat still used */ + vec[0] = data[0] * p0->vec[0] + data[1] * p1->vec[0] + data[2] * p2->vec[0] + data[3] * p3->vec[0]; /* X */ + vec[1] = data[0] * p0->vec[1] + data[1] * p1->vec[1] + data[2] * p2->vec[1] + data[3] * p3->vec[1]; /* Y */ + vec[2] = data[0] * p0->vec[2] + data[1] * p1->vec[2] + data[2] * p2->vec[2] + data[3] * p3->vec[2]; /* Z */ + vec[3] = data[0] * p0->vec[3] + data[1] * p1->vec[3] + data[2] * p2->vec[3] + data[3] * p3->vec[3]; /* Tilt, should not be needed since we have quat still used */ if (quat) { float totfac, q1[4], q2[4]; - totfac= data[0]+data[3]; - if (totfac>FLT_EPSILON) interp_qt_qtqt(q1, p0->quat, p3->quat, data[3] / totfac); - else copy_qt_qt(q1, p1->quat); + totfac = data[0] + data[3]; + if (totfac > FLT_EPSILON) interp_qt_qtqt(q1, p0->quat, p3->quat, data[3] / totfac); + else copy_qt_qt(q1, p1->quat); - totfac= data[1]+data[2]; - if (totfac>FLT_EPSILON) interp_qt_qtqt(q2, p1->quat, p2->quat, data[2] / totfac); - else copy_qt_qt(q2, p3->quat); + totfac = data[1] + data[2]; + if (totfac > FLT_EPSILON) interp_qt_qtqt(q2, p1->quat, p2->quat, data[2] / totfac); + else copy_qt_qt(q2, p3->quat); - totfac = data[0]+data[1]+data[2]+data[3]; - if (totfac>FLT_EPSILON) interp_qt_qtqt(quat, q1, q2, (data[1]+data[2]) / totfac); - else copy_qt_qt(quat, q2); + totfac = data[0] + data[1] + data[2] + data[3]; + if (totfac > FLT_EPSILON) interp_qt_qtqt(quat, q1, q2, (data[1] + data[2]) / totfac); + else copy_qt_qt(quat, q2); } if (radius) - *radius= data[0]*p0->radius + data[1]*p1->radius + data[2]*p2->radius + data[3]*p3->radius; + *radius = data[0] * p0->radius + data[1] * p1->radius + data[2] * p2->radius + data[3] * p3->radius; if (weight) - *weight= data[0]*p0->weight + data[1]*p1->weight + data[2]*p2->weight + data[3]*p3->weight; + *weight = data[0] * p0->weight + data[1] * p1->weight + data[2] * p2->weight + data[3] * p3->weight; return 1; } @@ -701,17 +701,17 @@ int where_on_path(Object *ob, float ctime, float vec[4], float dir[3], float qua static DupliObject *new_dupli_object(ListBase *lb, Object *ob, float mat[][4], int lay, int index, int type, int animated) { - DupliObject *dob= MEM_callocN(sizeof(DupliObject), "dupliobject"); + DupliObject *dob = MEM_callocN(sizeof(DupliObject), "dupliobject"); BLI_addtail(lb, dob); - dob->ob= ob; + dob->ob = ob; copy_m4_m4(dob->mat, mat); copy_m4_m4(dob->omat, ob->obmat); - dob->origlay= ob->lay; - dob->index= index; - dob->type= type; - dob->animated= (type == OB_DUPLIGROUP) && animated; - ob->lay= lay; + dob->origlay = ob->lay; + dob->index = index; + dob->type = type; + dob->animated = (type == OB_DUPLIGROUP) && animated; + ob->lay = lay; return dob; } @@ -723,20 +723,20 @@ static void group_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, i GroupObject *go; float mat[4][4], tmat[4][4]; - if (ob->dup_group==NULL) return; - group= ob->dup_group; + if (ob->dup_group == NULL) return; + group = ob->dup_group; /* simple preventing of too deep nested groups */ - if (level>MAX_DUPLI_RECUR) return; + if (level > MAX_DUPLI_RECUR) return; /* handles animated groups, and */ /* we need to check update for objects that are not in scene... */ group_handle_recalc_and_update(scene, ob, group); - animated= animated || group_is_animated(ob, group); + animated = animated || group_is_animated(ob, group); - for (go= group->gobject.first; go; go= go->next) { + for (go = group->gobject.first; go; go = go->next) { /* note, if you check on layer here, render goes wrong... it still deforms verts and uses parent imat */ - if (go->ob!=ob) { + if (go->ob != ob) { /* group dupli offset, should apply after everything else */ if (!is_zero_v3(group->dupli_ofs)) { @@ -748,22 +748,22 @@ static void group_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, i mult_m4_m4m4(mat, ob->obmat, go->ob->obmat); } - dob= new_dupli_object(lb, go->ob, mat, ob->lay, 0, OB_DUPLIGROUP, animated); + dob = new_dupli_object(lb, go->ob, mat, ob->lay, 0, OB_DUPLIGROUP, animated); /* check the group instance and object layers match, also that the object visible flags are ok. */ - if ( (dob->origlay & group->layer)==0 || - (G.rendering==0 && dob->ob->restrictflag & OB_RESTRICT_VIEW) || - (G.rendering && dob->ob->restrictflag & OB_RESTRICT_RENDER) - ) { - dob->no_draw= 1; + if ( (dob->origlay & group->layer) == 0 || + (G.rendering == 0 && dob->ob->restrictflag & OB_RESTRICT_VIEW) || + (G.rendering && dob->ob->restrictflag & OB_RESTRICT_RENDER) + ) { + dob->no_draw = 1; } else { - dob->no_draw= 0; + dob->no_draw = 0; } if (go->ob->transflag & OB_DUPLI) { copy_m4_m4(dob->ob->obmat, dob->mat); - object_duplilist_recursive(&group->id, scene, go->ob, lb, ob->obmat, level+1, animated); + object_duplilist_recursive(&group->id, scene, go->ob, lb, ob->obmat, level + 1, animated); copy_m4_m4(dob->ob->obmat, dob->omat); } } @@ -772,7 +772,7 @@ static void group_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, i static void frames_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, int animated) { - extern int enable_cu_speed; /* object.c */ + extern int enable_cu_speed; /* object.c */ Object copyob; int cfrao = scene->r.cfra; int dupend = ob->dupend; @@ -783,7 +783,7 @@ static void frames_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, /* if we don't have any data/settings which will lead to object movement, * don't waste time trying, as it will all look the same... */ - if (ob->parent==NULL && ob->constraints.first==NULL && ob->adt==NULL) + if (ob->parent == NULL && ob->constraints.first == NULL && ob->adt == NULL) return; /* make a copy of the object's original data (before any dupli-data overwrites it) @@ -794,18 +794,18 @@ static void frames_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, copyob = *ob; /* duplicate over the required range */ - if (ob->transflag & OB_DUPLINOSPEED) enable_cu_speed= 0; + if (ob->transflag & OB_DUPLINOSPEED) enable_cu_speed = 0; - for (scene->r.cfra= ob->dupsta; scene->r.cfra<=dupend; scene->r.cfra++) { - short ok= 1; + for (scene->r.cfra = ob->dupsta; scene->r.cfra <= dupend; scene->r.cfra++) { + short ok = 1; /* - dupoff = how often a frames within the range shouldn't be made into duplis * - dupon = the length of each "skipping" block in frames */ if (ob->dupoff) { - ok= scene->r.cfra - ob->dupsta; - ok= ok % (ob->dupon+ob->dupoff); - ok= (ok < ob->dupon); + ok = scene->r.cfra - ob->dupsta; + ok = ok % (ob->dupon + ob->dupoff); + ok = (ok < ob->dupon); } if (ok) { @@ -818,17 +818,17 @@ static void frames_duplilist(ListBase *lb, Scene *scene, Object *ob, int level, BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, (float)scene->r.cfra, ADT_RECALC_ANIM); /* ob-eval will do drivers, so we don't need to do them */ BKE_object_where_is_calc_time(scene, ob, (float)scene->r.cfra); - dob= new_dupli_object(lb, ob, ob->obmat, ob->lay, scene->r.cfra, OB_DUPLIFRAMES, animated); + dob = new_dupli_object(lb, ob, ob->obmat, ob->lay, scene->r.cfra, OB_DUPLIFRAMES, animated); copy_m4_m4(dob->omat, copyob.obmat); } } - enable_cu_speed= 1; + enable_cu_speed = 1; /* reset frame to original frame, then re-evaluate animation as above * as 2.5 animation data may have far-reaching consequences */ - scene->r.cfra= cfrao; + scene->r.cfra = cfrao; BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, (float)scene->r.cfra, ADT_RECALC_ANIM); /* ob-eval will do drivers, so we don't need to do them */ BKE_object_where_is_calc_time(scene, ob, (float)scene->r.cfra); @@ -857,7 +857,7 @@ static void vertex_dupli__mapFunc(void *userData, int index, const float co[3], const float no_f[3], const short no_s[3]) { DupliObject *dob; - vertexDupliData *vdd= userData; + vertexDupliData *vdd = userData; float vec[3], q2[4], mat[3][3], tmat[4][4], obmat[4][4]; int origlay; @@ -870,10 +870,10 @@ static void vertex_dupli__mapFunc(void *userData, int index, const float co[3], if (vdd->par->transflag & OB_DUPLIROT) { if (no_f) { - vec[0]= -no_f[0]; vec[1]= -no_f[1]; vec[2]= -no_f[2]; + vec[0] = -no_f[0]; vec[1] = -no_f[1]; vec[2] = -no_f[2]; } else if (no_s) { - vec[0]= -no_s[0]; vec[1]= -no_s[1]; vec[2]= -no_s[2]; + vec[0] = -no_s[0]; vec[1] = -no_s[1]; vec[2] = -no_s[2]; } vec_to_quat(q2, vec, vdd->ob->trackflag, vdd->ob->upflag); @@ -885,7 +885,7 @@ static void vertex_dupli__mapFunc(void *userData, int index, const float co[3], origlay = vdd->ob->lay; - dob= new_dupli_object(vdd->lb, vdd->ob, obmat, vdd->par->lay, index, OB_DUPLIVERTS, vdd->animated); + dob = new_dupli_object(vdd->lb, vdd->ob, obmat, vdd->par->lay, index, OB_DUPLIVERTS, vdd->animated); /* restore the original layer so that each dupli will have proper dob->origlay */ vdd->ob->lay = origlay; @@ -897,7 +897,7 @@ static void vertex_dupli__mapFunc(void *userData, int index, const float co[3], float tmpmat[4][4]; copy_m4_m4(tmpmat, vdd->ob->obmat); copy_m4_m4(vdd->ob->obmat, obmat); /* pretend we are really this mat */ - object_duplilist_recursive((ID *)vdd->id, vdd->scene, vdd->ob, vdd->lb, obmat, vdd->level+1, vdd->animated); + object_duplilist_recursive((ID *)vdd->id, vdd->scene, vdd->ob, vdd->lb, obmat, vdd->level + 1, vdd->animated); copy_m4_m4(vdd->ob->obmat, tmpmat); } } @@ -905,13 +905,13 @@ static void vertex_dupli__mapFunc(void *userData, int index, const float co[3], static void vertex_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, float par_space_mat[][4], int level, int animated) { Object *ob, *ob_iter; - Mesh *me= par->data; + Mesh *me = par->data; Base *base = NULL; DerivedMesh *dm; vertexDupliData vdd; Scene *sce = NULL; Group *group = NULL; - GroupObject * go = NULL; + GroupObject *go = NULL; BMEditMesh *em; float vec[3], no[3], pmat[4][4]; int totvert, a, oblay; @@ -920,54 +920,54 @@ static void vertex_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, fl copy_m4_m4(pmat, par->obmat); /* simple preventing of too deep nested groups */ - if (level>MAX_DUPLI_RECUR) return; + if (level > MAX_DUPLI_RECUR) return; em = me->edit_btmesh; if (em) { - dm= editbmesh_get_derived_cage(scene, par, em, CD_MASK_BAREMESH); + dm = editbmesh_get_derived_cage(scene, par, em, CD_MASK_BAREMESH); } else - dm= mesh_get_derived_deform(scene, par, CD_MASK_BAREMESH); + dm = mesh_get_derived_deform(scene, par, CD_MASK_BAREMESH); if (G.rendering) { - vdd.orco= (float(*)[3])BKE_mesh_orco_verts_get(par); + vdd.orco = (float(*)[3])BKE_mesh_orco_verts_get(par); BKE_mesh_orco_verts_transform(me, vdd.orco, me->totvert, 0); } else - vdd.orco= NULL; + vdd.orco = NULL; totvert = dm->getNumVerts(dm); /* having to loop on scene OR group objects is NOT FUN */ if (GS(id->name) == ID_SCE) { sce = (Scene *)id; - lay= sce->lay; - base= sce->base.first; + lay = sce->lay; + base = sce->base.first; } else { group = (Group *)id; - lay= group->layer; + lay = group->layer; go = group->gobject.first; } /* Start looping on Scene OR Group objects */ while (base || go) { if (sce) { - ob_iter= base->object; + ob_iter = base->object; oblay = base->lay; } else { - ob_iter= go->ob; + ob_iter = go->ob; oblay = ob_iter->lay; } - if (lay & oblay && scene->obedit!=ob_iter) { - ob=ob_iter->parent; + if (lay & oblay && scene->obedit != ob_iter) { + ob = ob_iter->parent; while (ob) { - if (ob==par) { + if (ob == par) { ob = ob_iter; - /* End Scene/Group object loop, below is generic */ + /* End Scene/Group object loop, below is generic */ /* par_space_mat - only used for groups so we can modify the space dupli's are in @@ -978,23 +978,23 @@ static void vertex_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, fl else copy_m4_m4(vdd.obmat, ob->obmat); - vdd.id= id; - vdd.level= level; - vdd.animated= animated; - vdd.lb= lb; - vdd.ob= ob; - vdd.scene= scene; - vdd.par= par; + vdd.id = id; + vdd.level = level; + vdd.animated = animated; + vdd.lb = lb; + vdd.ob = ob; + vdd.scene = scene; + vdd.par = par; copy_m4_m4(vdd.pmat, pmat); /* mballs have a different dupli handling */ - if (ob->type!=OB_MBALL) ob->flag |= OB_DONE; /* doesnt render */ + if (ob->type != OB_MBALL) ob->flag |= OB_DONE; /* doesnt render */ if (me->edit_btmesh) { - dm->foreachMappedVert(dm, vertex_dupli__mapFunc, (void*) &vdd); + dm->foreachMappedVert(dm, vertex_dupli__mapFunc, (void *) &vdd); } else { - for (a=0; agetVertCo(dm, a, vec); dm->getVertNo(dm, a, no); @@ -1012,11 +1012,11 @@ static void vertex_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, fl break; } - ob= ob->parent; + ob = ob->parent; } } - if (sce) base= base->next; /* scene loop */ - else go= go->next; /* group loop */ + if (sce) base = base->next; /* scene loop */ + else go = go->next; /* group loop */ } if (vdd.orco) @@ -1030,7 +1030,7 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa Base *base = NULL; DupliObject *dob; DerivedMesh *dm; - Mesh *me= par->data; + Mesh *me = par->data; MLoopUV *mloopuv; MPoly *mpoly, *mp; MLoop *mloop; @@ -1044,63 +1044,63 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa float ob__obmat[4][4]; /* needed for groups where the object matrix needs to be modified */ /* simple preventing of too deep nested groups */ - if (level>MAX_DUPLI_RECUR) return; + if (level > MAX_DUPLI_RECUR) return; copy_m4_m4(pmat, par->obmat); em = me->edit_btmesh; if (em) { - dm= editbmesh_get_derived_cage(scene, par, em, CD_MASK_BAREMESH); + dm = editbmesh_get_derived_cage(scene, par, em, CD_MASK_BAREMESH); } else { dm = mesh_get_derived_deform(scene, par, CD_MASK_BAREMESH); } - totface= dm->getNumPolys(dm); - mpoly= dm->getPolyArray(dm); - mloop= dm->getLoopArray(dm); - mvert= dm->getVertArray(dm); + totface = dm->getNumPolys(dm); + mpoly = dm->getPolyArray(dm); + mloop = dm->getLoopArray(dm); + mvert = dm->getVertArray(dm); if (G.rendering) { - orco= (float(*)[3])BKE_mesh_orco_verts_get(par); + orco = (float(*)[3])BKE_mesh_orco_verts_get(par); BKE_mesh_orco_verts_transform(me, orco, me->totvert, 0); - mloopuv= me->mloopuv; + mloopuv = me->mloopuv; } else { - orco= NULL; - mloopuv= NULL; + orco = NULL; + mloopuv = NULL; } /* having to loop on scene OR group objects is NOT FUN */ if (GS(id->name) == ID_SCE) { sce = (Scene *)id; - lay= sce->lay; - base= sce->base.first; + lay = sce->lay; + base = sce->base.first; } else { group = (Group *)id; - lay= group->layer; + lay = group->layer; go = group->gobject.first; } /* Start looping on Scene OR Group objects */ while (base || go) { if (sce) { - ob_iter= base->object; + ob_iter = base->object; oblay = base->lay; } else { - ob_iter= go->ob; + ob_iter = go->ob; oblay = ob_iter->lay; } - if (lay & oblay && scene->obedit!=ob_iter) { - ob=ob_iter->parent; + if (lay & oblay && scene->obedit != ob_iter) { + ob = ob_iter->parent; while (ob) { - if (ob==par) { + if (ob == par) { ob = ob_iter; - /* End Scene/Group object loop, below is generic */ + /* End Scene/Group object loop, below is generic */ /* par_space_mat - only used for groups so we can modify the space dupli's are in * when par_space_mat is NULL ob->obmat can be used instead of ob__obmat @@ -1113,9 +1113,9 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa copy_m3_m4(imat, ob->parentinv); /* mballs have a different dupli handling */ - if (ob->type!=OB_MBALL) ob->flag |= OB_DONE; /* doesnt render */ + if (ob->type != OB_MBALL) ob->flag |= OB_DONE; /* doesnt render */ - for (a=0, mp= mpoly; aloopstart; + MLoop *loopstart = mloop + mp->loopstart; if (mp->totloop < 3) { /* highly unlikely but to be safe */ continue; } else { - v1= mvert[(mv1= loopstart[0].v)].co; - v2= mvert[(mv2= loopstart[1].v)].co; - v3= mvert[(mv3= loopstart[2].v)].co; + v1 = mvert[(mv1 = loopstart[0].v)].co; + v2 = mvert[(mv2 = loopstart[1].v)].co; + v3 = mvert[(mv3 = loopstart[2].v)].co; #if 0 if (mp->totloop > 3) { - v4= mvert[(mv4= loopstart[3].v)].co; + v4 = mvert[(mv4 = loopstart[3].v)].co; } #endif } @@ -1160,8 +1160,8 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa /* scale */ if (par->transflag & OB_DUPLIFACES_SCALE) { - float size= BKE_mesh_calc_poly_area(mp, loopstart, mvert, NULL); - size= sqrtf(size) * par->dupfacesca; + float size = BKE_mesh_calc_poly_area(mp, loopstart, mvert, NULL); + size = sqrtf(size) * par->dupfacesca; mul_m3_fl(mat, size); } @@ -1171,9 +1171,9 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa copy_m4_m4(tmat, obmat); mul_m4_m4m3(obmat, tmat, mat); - dob= new_dupli_object(lb, ob, obmat, par->lay, a, OB_DUPLIFACES, animated); + dob = new_dupli_object(lb, ob, obmat, par->lay, a, OB_DUPLIFACES, animated); if (G.rendering) { - w= 1.0f / (float)mp->totloop; + w = 1.0f / (float)mp->totloop; if (orco) { int j; @@ -1194,18 +1194,18 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa float tmpmat[4][4]; copy_m4_m4(tmpmat, ob->obmat); copy_m4_m4(ob->obmat, obmat); /* pretend we are really this mat */ - object_duplilist_recursive((ID *)id, scene, ob, lb, ob->obmat, level+1, animated); + object_duplilist_recursive((ID *)id, scene, ob, lb, ob->obmat, level + 1, animated); copy_m4_m4(ob->obmat, tmpmat); } } break; } - ob= ob->parent; + ob = ob->parent; } } - if (sce) base= base->next; /* scene loop */ - else go= go->next; /* group loop */ + if (sce) base = base->next; /* scene loop */ + else go = go->next; /* group loop */ } if (orco) @@ -1217,30 +1217,30 @@ static void face_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, floa static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *par, float par_space_mat[][4], ParticleSystem *psys, int level, int animated) { GroupObject *go; - Object *ob=NULL, **oblist=NULL, obcopy, *obcopylist=NULL; + Object *ob = NULL, **oblist = NULL, obcopy, *obcopylist = NULL; DupliObject *dob; ParticleDupliWeight *dw; ParticleSettings *part; ParticleData *pa; - ChildParticle *cpa=NULL; + ChildParticle *cpa = NULL; ParticleKey state; ParticleCacheKey *cache; float ctime, pa_time, scale = 1.0f; - float tmat[4][4], mat[4][4], pamat[4][4], vec[3], size=0.0; + float tmat[4][4], mat[4][4], pamat[4][4], vec[3], size = 0.0; float (*obmat)[4], (*oldobmat)[4]; int a, b, counter, hair = 0; - int totpart, totchild, totgroup=0 /*, pa_num */; + int totpart, totchild, totgroup = 0 /*, pa_num */; int no_draw_flag = PARS_UNEXIST; - if (psys==NULL) return; + if (psys == NULL) return; /* simple preventing of too deep nested groups */ - if (level>MAX_DUPLI_RECUR) return; + if (level > MAX_DUPLI_RECUR) return; - part=psys->part; + part = psys->part; - if (part==NULL) + if (part == NULL) return; if (!psys_check_enabled(par, psys)) @@ -1256,12 +1256,12 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p BLI_srandom(31415926 + psys->seed); - if ((psys->renderdata || part->draw_as==PART_DRAW_REND) && ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) { - ParticleSimulationData sim= {NULL}; - sim.scene= scene; - sim.ob= par; - sim.psys= psys; - sim.psmd= psys_get_modifier(par, psys); + if ((psys->renderdata || part->draw_as == PART_DRAW_REND) && ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) { + ParticleSimulationData sim = {NULL}; + sim.scene = scene; + sim.ob = par; + sim.psys = psys; + sim.psmd = psys_get_modifier(par, psys); /* make sure emitter imat is in global coordinates instead of render view coordinates */ invert_m4_m4(par->imat, par->obmat); @@ -1274,7 +1274,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p if (part->dup_group == NULL || part->dup_group->gobject.first == NULL) return; - for (go=part->dup_group->gobject.first; go; go=go->next) + for (go = part->dup_group->gobject.first; go; go = go->next) if (go->ob == par) return; } @@ -1282,7 +1282,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p /* if we have a hair particle system, use the path cache */ if (part->type == PART_HAIR) { if (psys->flag & PSYS_HAIR_DONE) - hair= (totchild == 0 || psys->childcache) && psys->pathcache; + hair = (totchild == 0 || psys->childcache) && psys->pathcache; if (!hair) return; @@ -1296,29 +1296,29 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p psys->lattice = psys_get_lattice(&sim); /* gather list of objects or single object */ - if (part->ren_as==PART_DRAW_GR) { + if (part->ren_as == PART_DRAW_GR) { group_handle_recalc_and_update(scene, par, part->dup_group); if (part->draw & PART_DRAW_COUNT_GR) { - for (dw=part->dupliweights.first; dw; dw=dw->next) + for (dw = part->dupliweights.first; dw; dw = dw->next) totgroup += dw->count; } else { - for (go=part->dup_group->gobject.first; go; go=go->next) + for (go = part->dup_group->gobject.first; go; go = go->next) totgroup++; } /* we also copy the actual objects to restore afterwards, since * BKE_object_where_is_calc_time will change the object which breaks transform */ - oblist = MEM_callocN(totgroup*sizeof(Object *), "dupgroup object list"); - obcopylist = MEM_callocN(totgroup*sizeof(Object), "dupgroup copy list"); + oblist = MEM_callocN(totgroup * sizeof(Object *), "dupgroup object list"); + obcopylist = MEM_callocN(totgroup * sizeof(Object), "dupgroup copy list"); if (part->draw & PART_DRAW_COUNT_GR && totgroup) { dw = part->dupliweights.first; - for (a=0; anext) { - for (b=0; bcount; b++, a++) { + for (a = 0; a < totgroup; dw = dw->next) { + for (b = 0; b < dw->count; b++, a++) { oblist[a] = dw->ob; obcopylist[a] = *dw->ob; } @@ -1326,7 +1326,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p } else { go = part->dup_group->gobject.first; - for (a=0; anext) { + for (a = 0; a < totgroup; a++, go = go->next) { oblist[a] = go->ob; obcopylist[a] = *go->ob; } @@ -1337,13 +1337,13 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p obcopy = *ob; } - if (totchild==0 || part->draw & PART_DRAW_PARENT) + if (totchild == 0 || part->draw & PART_DRAW_PARENT) a = 0; else a = totpart; - for (pa=psys->particles, counter=0; aparticles, counter = 0; a < totpart + totchild; a++, pa++, counter++) { + if (a < totpart) { /* handle parent particle */ if (pa->flag & no_draw_flag) continue; @@ -1364,29 +1364,29 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p /* some hair paths might be non-existent so they can't be used for duplication */ if (hair && ((a < totpart && psys->pathcache[a]->steps < 0) || - (a >= totpart && psys->childcache[a-totpart]->steps < 0))) + (a >= totpart && psys->childcache[a - totpart]->steps < 0))) { continue; } - if (part->ren_as==PART_DRAW_GR) { + if (part->ren_as == PART_DRAW_GR) { /* prevent divide by zero below [#28336] */ if (totgroup == 0) continue; /* for groups, pick the object based on settings */ - if (part->draw&PART_DRAW_RAND_GR) - b= BLI_rand() % totgroup; + if (part->draw & PART_DRAW_RAND_GR) + b = BLI_rand() % totgroup; else - b= a % totgroup; + b = a % totgroup; ob = oblist[b]; obmat = oblist[b]->obmat; oldobmat = obcopylist[b].obmat; } else { - obmat= ob->obmat; - oldobmat= obcopy.obmat; + obmat = ob->obmat; + oldobmat = obcopy.obmat; } if (hair) { @@ -1396,12 +1396,12 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p psys_get_dupli_path_transform(&sim, pa, NULL, cache, pamat, &scale); } else { - cache = psys->childcache[a-totpart]; + cache = psys->childcache[a - totpart]; psys_get_dupli_path_transform(&sim, NULL, cpa, cache, pamat, &scale); } copy_v3_v3(pamat[3], cache->co); - pamat[3][3]= 1.0f; + pamat[3][3] = 1.0f; } else { @@ -1415,17 +1415,17 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p normalize_qt_qt(tquat, state.rot); quat_to_mat4(pamat, tquat); copy_v3_v3(pamat[3], state.co); - pamat[3][3]= 1.0f; + pamat[3][3] = 1.0f; } } - if (part->ren_as==PART_DRAW_GR && psys->part->draw & PART_DRAW_WHOLE_GR) { - for (go= part->dup_group->gobject.first, b=0; go; go= go->next, b++) { + if (part->ren_as == PART_DRAW_GR && psys->part->draw & PART_DRAW_WHOLE_GR) { + for (go = part->dup_group->gobject.first, b = 0; go; go = go->next, b++) { copy_m4_m4(tmat, oblist[b]->obmat); /* apply particle scale */ - mul_mat3_m4_fl(tmat, size*scale); - mul_v3_fl(tmat[3], size*scale); + mul_mat3_m4_fl(tmat, size * scale); + mul_v3_fl(tmat[3], size * scale); /* group dupli offset, should apply after everything else */ if (!is_zero_v3(part->dup_group->dupli_ofs)) sub_v3_v3v3(tmat[3], tmat[3], part->dup_group->dupli_ofs); @@ -1437,7 +1437,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p else copy_m4_m4(mat, tmat); - dob= new_dupli_object(lb, go->ob, mat, par->lay, counter, OB_DUPLIPARTS, animated); + dob = new_dupli_object(lb, go->ob, mat, par->lay, counter, OB_DUPLIPARTS, animated); copy_m4_m4(dob->omat, obcopylist[b].obmat); if (G.rendering) psys_get_dupli_texture(psys, part, sim.psmd, pa, cpa, dob->uv, dob->orco); @@ -1445,7 +1445,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p } else { /* to give ipos in object correct offset */ - BKE_object_where_is_calc_time(scene, ob, ctime-pa_time); + BKE_object_where_is_calc_time(scene, ob, ctime - pa_time); copy_v3_v3(vec, obmat[3]); obmat[3][0] = obmat[3][1] = obmat[3][2] = 0.0f; @@ -1457,7 +1457,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p xvec[1] = xvec[2] = 0; vec_to_quat(q, xvec, ob->trackflag, ob->upflag); quat_to_mat4(obmat, q); - obmat[3][3]= 1.0f; + obmat[3][3] = 1.0f; } /* Normal particles and cached hair live in global space so we need to @@ -1469,7 +1469,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p copy_m4_m4(mat, pamat); mult_m4_m4m4(tmat, mat, obmat); - mul_mat3_m4_fl(tmat, size*scale); + mul_mat3_m4_fl(tmat, size * scale); if (par_space_mat) mult_m4_m4m4(mat, par_space_mat, tmat); @@ -1479,7 +1479,7 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p if (part->draw & PART_DRAW_GLOBAL_OB) add_v3_v3v3(mat[3], mat[3], vec); - dob= new_dupli_object(lb, ob, mat, ob->lay, counter, GS(id->name) == ID_GR ? OB_DUPLIGROUP : OB_DUPLIPARTS, animated); + dob = new_dupli_object(lb, ob, mat, ob->lay, counter, GS(id->name) == ID_GR ? OB_DUPLIGROUP : OB_DUPLIPARTS, animated); copy_m4_m4(dob->omat, oldobmat); if (G.rendering) psys_get_dupli_texture(psys, part, sim.psmd, pa, cpa, dob->uv, dob->orco); @@ -1487,12 +1487,12 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p } /* restore objects since they were changed in BKE_object_where_is_calc_time */ - if (part->ren_as==PART_DRAW_GR) { - for (a=0; aren_as == PART_DRAW_GR) { + for (a = 0; a < totgroup; a++) + *(oblist[a]) = obcopylist[a]; } else - *ob= obcopy; + *ob = obcopy; } /* clean up */ @@ -1512,19 +1512,19 @@ static Object *find_family_object(Object **obar, char *family, char ch) Object *ob; int flen; - if ( obar[(int)ch] ) return obar[(int)ch]; + if (obar[(int)ch]) return obar[(int)ch]; - flen= strlen(family); + flen = strlen(family); - ob= G.main->object.first; + ob = G.main->object.first; while (ob) { if (ob->id.name[flen + 2] == ch) { - if ( strncmp(ob->id.name+2, family, flen)==0 ) break; + if (strncmp(ob->id.name + 2, family, flen) == 0) break; } - ob= ob->id.next; + ob = ob->id.next; } - obar[(int)ch]= ob; + obar[(int)ch] = ob; return ob; } @@ -1532,37 +1532,37 @@ static Object *find_family_object(Object **obar, char *family, char ch) static void font_duplilist(ListBase *lb, Scene *scene, Object *par, int level, int animated) { - Object *ob, *obar[256]= {NULL}; + Object *ob, *obar[256] = {NULL}; Curve *cu; struct chartrans *ct, *chartransdata; float vec[3], obmat[4][4], pmat[4][4], fsize, xof, yof; int slen, a; /* simple preventing of too deep nested groups */ - if (level>MAX_DUPLI_RECUR) return; + if (level > MAX_DUPLI_RECUR) return; copy_m4_m4(pmat, par->obmat); /* in par the family name is stored, use this to find the other objects */ - chartransdata= BKE_vfont_to_curve(G.main, scene, par, FO_DUPLI); - if (chartransdata==NULL) return; + chartransdata = BKE_vfont_to_curve(G.main, scene, par, FO_DUPLI); + if (chartransdata == NULL) return; - cu= par->data; - slen= strlen(cu->str); - fsize= cu->fsize; - xof= cu->xof; - yof= cu->yof; + cu = par->data; + slen = strlen(cu->str); + fsize = cu->fsize; + xof = cu->xof; + yof = cu->yof; - ct= chartransdata; + ct = chartransdata; - for (a=0; afamily, cu->str[a]); + ob = find_family_object(obar, cu->family, cu->str[a]); if (ob) { - vec[0]= fsize*(ct->xof - xof); - vec[1]= fsize*(ct->yof - yof); - vec[2]= 0.0; + vec[0] = fsize * (ct->xof - xof); + vec[1] = fsize * (ct->yof - yof); + vec[2] = 0.0; mul_m4_v3(pmat, vec); @@ -1580,7 +1580,7 @@ static void font_duplilist(ListBase *lb, Scene *scene, Object *par, int level, i static void object_duplilist_recursive(ID *id, Scene *scene, Object *ob, ListBase *duplilist, float par_space_mat[][4], int level, int animated) { - if ((ob->transflag & OB_DUPLI)==0) + if ((ob->transflag & OB_DUPLI) == 0) return; /* Should the dupli's be generated for this object? - Respect restrict flags */ @@ -1597,35 +1597,35 @@ static void object_duplilist_recursive(ID *id, Scene *scene, Object *ob, ListBas if (ob->transflag & OB_DUPLIPARTS) { ParticleSystem *psys = ob->particlesystem.first; - for (; psys; psys=psys->next) - new_particle_duplilist(duplilist, id, scene, ob, par_space_mat, psys, level+1, animated); + for (; psys; psys = psys->next) + new_particle_duplilist(duplilist, id, scene, ob, par_space_mat, psys, level + 1, animated); } else if (ob->transflag & OB_DUPLIVERTS) { - if (ob->type==OB_MESH) { - vertex_duplilist(duplilist, id, scene, ob, par_space_mat, level+1, animated); + if (ob->type == OB_MESH) { + vertex_duplilist(duplilist, id, scene, ob, par_space_mat, level + 1, animated); } - else if (ob->type==OB_FONT) { - if (GS(id->name)==ID_SCE) { /* TODO - support dupligroups */ - font_duplilist(duplilist, scene, ob, level+1, animated); + else if (ob->type == OB_FONT) { + if (GS(id->name) == ID_SCE) { /* TODO - support dupligroups */ + font_duplilist(duplilist, scene, ob, level + 1, animated); } } } else if (ob->transflag & OB_DUPLIFACES) { - if (ob->type==OB_MESH) - face_duplilist(duplilist, id, scene, ob, par_space_mat, level+1, animated); + if (ob->type == OB_MESH) + face_duplilist(duplilist, id, scene, ob, par_space_mat, level + 1, animated); } else if (ob->transflag & OB_DUPLIFRAMES) { - if (GS(id->name)==ID_SCE) { /* TODO - support dupligroups */ - frames_duplilist(duplilist, scene, ob, level+1, animated); + if (GS(id->name) == ID_SCE) { /* TODO - support dupligroups */ + frames_duplilist(duplilist, scene, ob, level + 1, animated); } } else if (ob->transflag & OB_DUPLIGROUP) { DupliObject *dob; - group_duplilist(duplilist, scene, ob, level+1, animated); /* now recursive */ + group_duplilist(duplilist, scene, ob, level + 1, animated); /* now recursive */ - if (level==0) { - for (dob= duplilist->first; dob; dob= dob->next) + if (level == 0) { + for (dob = duplilist->first; dob; dob = dob->next) if (dob->type == OB_DUPLIGROUP) copy_m4_m4(dob->ob->obmat, dob->mat); } @@ -1636,8 +1636,8 @@ static void object_duplilist_recursive(ID *id, Scene *scene, Object *ob, ListBas * note; group dupli's already set transform matrix. see note in group_duplilist() */ ListBase *object_duplilist(Scene *sce, Object *ob) { - ListBase *duplilist= MEM_mallocN(sizeof(ListBase), "duplilist"); - duplilist->first= duplilist->last= NULL; + ListBase *duplilist = MEM_mallocN(sizeof(ListBase), "duplilist"); + duplilist->first = duplilist->last = NULL; object_duplilist_recursive((ID *)sce, sce, ob, duplilist, NULL, 0, 0); return duplilist; } @@ -1649,8 +1649,8 @@ void free_object_duplilist(ListBase *lb) /* loop in reverse order, if object is instanced multiple times * the original layer may not really be original otherwise, proper * solution is more complicated */ - for (dob= lb->last; dob; dob= dob->prev) { - dob->ob->lay= dob->origlay; + for (dob = lb->last; dob; dob = dob->prev) { + dob->ob->lay = dob->origlay; copy_m4_m4(dob->ob->obmat, dob->omat); } @@ -1662,16 +1662,16 @@ int count_duplilist(Object *ob) { if (ob->transflag & OB_DUPLI) { if (ob->transflag & OB_DUPLIVERTS) { - if (ob->type==OB_MESH) { + if (ob->type == OB_MESH) { if (ob->transflag & OB_DUPLIVERTS) { ParticleSystem *psys = ob->particlesystem.first; - int pdup=0; + int pdup = 0; - for (; psys; psys=psys->next) + for (; psys; psys = psys->next) pdup += psys->totpart; - if (pdup==0) { - Mesh *me= ob->data; + if (pdup == 0) { + Mesh *me = ob->data; return me->totvert; } else @@ -1680,9 +1680,9 @@ int count_duplilist(Object *ob) } } else if (ob->transflag & OB_DUPLIFRAMES) { - int tot= ob->dupend - ob->dupsta; - tot/= (ob->dupon+ob->dupoff); - return tot*ob->dupon; + int tot = ob->dupend - ob->dupsta; + tot /= (ob->dupon + ob->dupoff); + return tot * ob->dupon; } } return 1; diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c index 58ada7b0784..d8ae95e08e2 100644 --- a/source/blender/blenkernel/intern/blender.c +++ b/source/blender/blenkernel/intern/blender.c @@ -95,7 +95,7 @@ Global G; UserDef U; /* ListBase = {NULL, NULL}; */ -char versionstr[48]= ""; +char versionstr[48] = ""; /* ********** free ********** */ @@ -104,9 +104,9 @@ void free_blender(void) { /* samples are in a global list..., also sets G.main->sound->sample NULL */ free_main(G.main); - G.main= NULL; + G.main = NULL; - BKE_spacetypes_free(); /* after free main, it uses space callbacks */ + BKE_spacetypes_free(); /* after free main, it uses space callbacks */ IMB_exit(); @@ -122,18 +122,18 @@ void initglobals(void) { memset(&G, 0, sizeof(Global)); - U.savetime= 1; + U.savetime = 1; - G.main= MEM_callocN(sizeof(Main), "initglobals"); + G.main = MEM_callocN(sizeof(Main), "initglobals"); strcpy(G.ima, "//"); if (BLENDER_SUBVERSION) - BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d.%d", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION); + BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d.%d", BLENDER_VERSION / 100, BLENDER_VERSION % 100, BLENDER_SUBVERSION); else - BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d", BLENDER_VERSION/100, BLENDER_VERSION%100); + BLI_snprintf(versionstr, sizeof(versionstr), "v%d.%02d", BLENDER_VERSION / 100, BLENDER_VERSION % 100); -#ifdef _WIN32 // FULLSCREEN +#ifdef _WIN32 // FULLSCREEN G.windowstate = G_WINDOWSTATE_USERDEF; #endif @@ -154,11 +154,11 @@ static void clear_global(void) { // extern short winqueue_break; /* screen.c */ - free_main(G.main); /* free all lib data */ + free_main(G.main); /* free all lib data */ // free_vertexpaint(); - G.main= NULL; + G.main = NULL; } static int clean_paths_visit_cb(void *UNUSED(userdata), char *path_dst, const char *path_src) @@ -175,7 +175,7 @@ static void clean_paths(Main *main) BLI_bpath_traverse_main(main, clean_paths_visit_cb, BLI_BPATH_TRAVERSE_SKIP_MULTIFILE, NULL); - for (scene= main->scene.first; scene; scene= scene->id.next) { + for (scene = main->scene.first; scene; scene = scene->id.next) { BLI_clean(scene->r.pic); } } @@ -188,17 +188,17 @@ static void clean_paths(Main *main) static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath) { - bScreen *curscreen= NULL; - Scene *curscene= NULL; + bScreen *curscreen = NULL; + Scene *curscene = NULL; int recover; char mode; /* 'u' = undo save, 'n' = no UI load */ - if (bfd->main->screen.first==NULL) mode= 'u'; - else if (G.fileflags & G_FILE_NO_UI) mode= 'n'; - else mode= 0; + if (bfd->main->screen.first == NULL) mode = 'u'; + else if (G.fileflags & G_FILE_NO_UI) mode = 'n'; + else mode = 0; - recover= (G.fileflags & G_FILE_RECOVER); + recover = (G.fileflags & G_FILE_RECOVER); /* Free all render results, without this stale data gets displayed after loading files */ if (mode != 'u') { @@ -222,12 +222,12 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath SWAP(ListBase, G.main->script, bfd->main->script); /* we re-use current screen */ - curscreen= CTX_wm_screen(C); + curscreen = CTX_wm_screen(C); /* but use new Scene pointer */ - curscene= bfd->curscene; - if (curscene==NULL) curscene= bfd->main->scene.first; + curscene = bfd->curscene; + if (curscene == NULL) curscene = bfd->main->scene.first; /* and we enforce curscene to be in current screen */ - if (curscreen) curscreen->scene= curscene; /* can run in bgmode */ + if (curscreen) curscreen->scene = curscene; /* can run in bgmode */ /* clear_global will free G.main, here we can still restore pointers */ lib_link_screen_restore(bfd->main, curscreen, curscene); @@ -240,7 +240,7 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath /* clear old property update cache, in case some old references are left dangling */ RNA_property_update_cache_free(); - G.main= bfd->main; + G.main = bfd->main; CTX_data_main_set(C, G.main); @@ -251,7 +251,7 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath /* only here free userdef themes... */ BKE_userdef_free(); - U= *bfd->user; + U = *bfd->user; MEM_freeN(bfd->user); } @@ -261,9 +261,9 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath CTX_data_scene_set(C, curscene); } else { - G.winpos= bfd->winpos; - G.displaymode= bfd->displaymode; - G.fileflags= bfd->fileflags; + G.winpos = bfd->winpos; + G.displaymode = bfd->displaymode; + G.fileflags = bfd->fileflags; CTX_wm_manager_set(C, bfd->main->wm.first); CTX_wm_screen_set(C, bfd->curscreen); CTX_data_scene_set(C, bfd->curscreen->scene); @@ -273,20 +273,20 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath } /* this can happen when active scene was lib-linked, and doesn't exist anymore */ - if (CTX_data_scene(C)==NULL) { + if (CTX_data_scene(C) == NULL) { CTX_data_scene_set(C, bfd->main->scene.first); - CTX_wm_screen(C)->scene= CTX_data_scene(C); - curscene= CTX_data_scene(C); + CTX_wm_screen(C)->scene = CTX_data_scene(C); + curscene = CTX_data_scene(C); } /* special cases, override loaded flags: */ if (G.f != bfd->globalf) { const int flags_keep = (G_SWAP_EXCHANGE | G_SCRIPT_AUTOEXEC | G_SCRIPT_OVERRIDE_PREF); - bfd->globalf= (bfd->globalf & ~flags_keep) | (G.f & flags_keep); + bfd->globalf = (bfd->globalf & ~flags_keep) | (G.f & flags_keep); } - G.f= bfd->globalf; + G.f = bfd->globalf; if (!G.background) { //setscreen(G.curscreen); @@ -300,12 +300,12 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath if (recover && bfd->filename[0] && G.relbase_valid) { /* in case of autosave or quit.blend, use original filename instead * use relbase_valid to make sure the file is saved, else we get in the filename */ - filepath= bfd->filename; + filepath = bfd->filename; } #if 0 else if (!G.relbase_valid) { /* otherwise, use an empty string as filename, rather than */ - filepath=""; + filepath = ""; } #endif @@ -324,8 +324,8 @@ static void setup_app_data(bContext *C, BlendFileData *bfd, const char *filepath static int handle_subversion_warning(Main *main, ReportList *reports) { if (main->minversionfile > BLENDER_VERSION || - (main->minversionfile == BLENDER_VERSION && - main->minsubversionfile > BLENDER_SUBVERSION)) { + (main->minversionfile == BLENDER_VERSION && + main->minsubversionfile > BLENDER_SUBVERSION)) { BKE_reportf(reports, RPT_ERROR, "File written by newer Blender binary: %d.%d , expect loss of data!", main->minversionfile, main->minsubversionfile); } @@ -348,8 +348,8 @@ void BKE_userdef_free(void) wmKeyMapItem *kmi; wmKeyMapDiffItem *kmdi; - for (km=U.user_keymaps.first; km; km=km->next) { - for (kmdi=km->diff_items.first; kmdi; kmdi=kmdi->next) { + for (km = U.user_keymaps.first; km; km = km->next) { + for (kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) { if (kmdi->add_item) { keymap_item_free(kmdi->add_item); MEM_freeN(kmdi->add_item); @@ -360,7 +360,7 @@ void BKE_userdef_free(void) } } - for (kmi=km->items.first; kmi; kmi=kmi->next) + for (kmi = km->items.first; kmi; kmi = kmi->next) keymap_item_free(kmi); BLI_freelistN(&km->diff_items); @@ -377,41 +377,41 @@ void BKE_userdef_free(void) int BKE_read_file(bContext *C, const char *filepath, ReportList *reports) { BlendFileData *bfd; - int retval= BKE_READ_FILE_OK; + int retval = BKE_READ_FILE_OK; - if (strstr(filepath, BLENDER_STARTUP_FILE)==NULL) /* don't print user-pref loading */ + if (strstr(filepath, BLENDER_STARTUP_FILE) == NULL) /* don't print user-pref loading */ printf("read blend: %s\n", filepath); - bfd= BLO_read_from_file(filepath, reports); + bfd = BLO_read_from_file(filepath, reports); if (bfd) { - if (bfd->user) retval= BKE_READ_FILE_OK_USERPREFS; + if (bfd->user) retval = BKE_READ_FILE_OK_USERPREFS; - if (0==handle_subversion_warning(bfd->main, reports)) { + if (0 == handle_subversion_warning(bfd->main, reports)) { free_main(bfd->main); MEM_freeN(bfd); - bfd= NULL; - retval= BKE_READ_FILE_FAIL; + bfd = NULL; + retval = BKE_READ_FILE_FAIL; } else - setup_app_data(C, bfd, filepath); // frees BFD + setup_app_data(C, bfd, filepath); // frees BFD } else BKE_reports_prependf(reports, "Loading %s failed: ", filepath); - return (bfd?retval:BKE_READ_FILE_FAIL); + return (bfd ? retval : BKE_READ_FILE_FAIL); } -int BKE_read_file_from_memory(bContext *C, char* filebuf, int filelength, ReportList *reports) +int BKE_read_file_from_memory(bContext *C, char *filebuf, int filelength, ReportList *reports) { BlendFileData *bfd; - bfd= BLO_read_from_memory(filebuf, filelength, reports); + bfd = BLO_read_from_memory(filebuf, filelength, reports); if (bfd) setup_app_data(C, bfd, ""); else BKE_reports_prepend(reports, "Loading failed: "); - return (bfd?1:0); + return (bfd ? 1 : 0); } /* memfile is the undo buffer */ @@ -419,13 +419,13 @@ int BKE_read_file_from_memfile(bContext *C, MemFile *memfile, ReportList *report { BlendFileData *bfd; - bfd= BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports); + bfd = BLO_read_from_memfile(CTX_data_main(C), G.main->name, memfile, reports); if (bfd) setup_app_data(C, bfd, ""); else BKE_reports_prepend(reports, "Loading failed: "); - return (bfd?1:0); + return (bfd ? 1 : 0); } @@ -435,7 +435,7 @@ static void (*blender_test_break_cb)(void) = NULL; void set_blender_test_break_cb(void (*func)(void) ) { - blender_test_break_cb= func; + blender_test_break_cb = func; } @@ -446,15 +446,15 @@ int blender_test_break(void) blender_test_break_cb(); } - return (G.afbreek==1); + return (G.afbreek == 1); } /* ***************** GLOBAL UNDO *************** */ -#define UNDO_DISK 0 +#define UNDO_DISK 0 -#define MAXUNDONAME 64 +#define MAXUNDONAME 64 typedef struct UndoElem { struct UndoElem *next, *prev; char str[FILE_MAX]; @@ -463,31 +463,31 @@ typedef struct UndoElem { uintptr_t undosize; } UndoElem; -static ListBase undobase={NULL, NULL}; -static UndoElem *curundo= NULL; +static ListBase undobase = {NULL, NULL}; +static UndoElem *curundo = NULL; static int read_undosave(bContext *C, UndoElem *uel) { char mainstr[sizeof(G.main->name)]; - int success=0, fileflags; + int success = 0, fileflags; /* This is needed so undoing/redoing doesn't crash with threaded previews going */ WM_jobs_stop_all(CTX_wm_manager(C)); - BLI_strncpy(mainstr, G.main->name, sizeof(mainstr)); /* temporal store */ + BLI_strncpy(mainstr, G.main->name, sizeof(mainstr)); /* temporal store */ - fileflags= G.fileflags; + fileflags = G.fileflags; G.fileflags |= G_FILE_NO_UI; if (UNDO_DISK) - success= (BKE_read_file(C, uel->str, NULL) != BKE_READ_FILE_FAIL); + success = (BKE_read_file(C, uel->str, NULL) != BKE_READ_FILE_FAIL); else - success= BKE_read_file_from_memfile(C, &uel->memfile, NULL); + success = BKE_read_file_from_memfile(C, &uel->memfile, NULL); /* restore */ BLI_strncpy(G.main->name, mainstr, sizeof(G.main->name)); /* restore */ - G.fileflags= fileflags; + G.fileflags = fileflags; if (success) { /* important not to update time here, else non keyed tranforms are lost */ @@ -504,33 +504,33 @@ void BKE_write_undo(bContext *C, const char *name) int nr /*, success */ /* UNUSED */; UndoElem *uel; - if ( (U.uiflag & USER_GLOBALUNDO)==0) return; - if ( U.undosteps==0) return; + if ( (U.uiflag & USER_GLOBALUNDO) == 0) return; + if (U.undosteps == 0) return; /* remove all undos after (also when curundo==NULL) */ while (undobase.last != curundo) { - uel= undobase.last; + uel = undobase.last; BLI_remlink(&undobase, uel); BLO_free_memfile(&uel->memfile); MEM_freeN(uel); } /* make new */ - curundo= uel= MEM_callocN(sizeof(UndoElem), "undo file"); + curundo = uel = MEM_callocN(sizeof(UndoElem), "undo file"); BLI_strncpy(uel->name, name, sizeof(uel->name)); BLI_addtail(&undobase, uel); /* and limit amount to the maximum */ - nr= 0; - uel= undobase.last; + nr = 0; + uel = undobase.last; while (uel) { nr++; - if (nr==U.undosteps) break; - uel= uel->prev; + if (nr == U.undosteps) break; + uel = uel->prev; } if (uel) { - while (undobase.first!=uel) { - UndoElem *first= undobase.first; + while (undobase.first != uel) { + UndoElem *first = undobase.first; BLI_remlink(&undobase, first); /* the merge is because of compression */ BLO_merge_memfile(&first->memfile, &first->next->memfile); @@ -541,14 +541,14 @@ void BKE_write_undo(bContext *C, const char *name) /* disk save version */ if (UNDO_DISK) { - static int counter= 0; + static int counter = 0; char filepath[FILE_MAX]; char numstr[32]; int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on undo */ /* calculate current filepath */ counter++; - counter= counter % U.undosteps; + counter = counter % U.undosteps; BLI_snprintf(numstr, sizeof(numstr), "%d.blend", counter); BLI_make_file_string("/", filepath, BLI_temporary_dir(), numstr); @@ -558,34 +558,34 @@ void BKE_write_undo(bContext *C, const char *name) BLI_strncpy(curundo->str, filepath, sizeof(curundo->str)); } else { - MemFile *prevfile=NULL; + MemFile *prevfile = NULL; - if (curundo->prev) prevfile= &(curundo->prev->memfile); + if (curundo->prev) prevfile = &(curundo->prev->memfile); - memused= MEM_get_memory_in_use(); + memused = MEM_get_memory_in_use(); /* success= */ /* UNUSED */ BLO_write_file_mem(CTX_data_main(C), prevfile, &curundo->memfile, G.fileflags); - curundo->undosize= MEM_get_memory_in_use() - memused; + curundo->undosize = MEM_get_memory_in_use() - memused; } if (U.undomemory != 0) { /* limit to maximum memory (afterwards, we can't know in advance) */ - totmem= 0; - maxmem= ((uintptr_t)U.undomemory)*1024*1024; + totmem = 0; + maxmem = ((uintptr_t)U.undomemory) * 1024 * 1024; /* keep at least two (original + other) */ - uel= undobase.last; + uel = undobase.last; while (uel && uel->prev) { - totmem+= uel->undosize; - if (totmem>maxmem) break; - uel= uel->prev; + totmem += uel->undosize; + if (totmem > maxmem) break; + uel = uel->prev; } if (uel) { if (uel->prev && uel->prev->prev) - uel= uel->prev; + uel = uel->prev; - while (undobase.first!=uel) { - UndoElem *first= undobase.first; + while (undobase.first != uel) { + UndoElem *first = undobase.first; BLI_remlink(&undobase, first); /* the merge is because of compression */ BLO_merge_memfile(&first->memfile, &first->next->memfile); @@ -599,25 +599,25 @@ void BKE_write_undo(bContext *C, const char *name) void BKE_undo_step(bContext *C, int step) { - if (step==0) { + if (step == 0) { read_undosave(C, curundo); } - else if (step==1) { + else if (step == 1) { /* curundo should never be NULL, after restart or load file it should call undo_save */ - if (curundo==NULL || curundo->prev==NULL) ; // XXX error("No undo available"); + if (curundo == NULL || curundo->prev == NULL) ; // XXX error("No undo available"); else { if (G.debug & G_DEBUG) printf("undo %s\n", curundo->name); - curundo= curundo->prev; + curundo = curundo->prev; read_undosave(C, curundo); } } else { /* curundo has to remain current situation! */ - if (curundo==NULL || curundo->next==NULL) ; // XXX error("No redo available"); + if (curundo == NULL || curundo->next == NULL) ; // XXX error("No redo available"); else { read_undosave(C, curundo->next); - curundo= curundo->next; + curundo = curundo->next; if (G.debug & G_DEBUG) printf("redo %s\n", curundo->name); } } @@ -627,30 +627,30 @@ void BKE_reset_undo(void) { UndoElem *uel; - uel= undobase.first; + uel = undobase.first; while (uel) { BLO_free_memfile(&uel->memfile); - uel= uel->next; + uel = uel->next; } BLI_freelistN(&undobase); - curundo= NULL; + curundo = NULL; } /* based on index nr it does a restore */ void BKE_undo_number(bContext *C, int nr) { - curundo= BLI_findlink(&undobase, nr); + curundo = BLI_findlink(&undobase, nr); BKE_undo_step(C, 0); } /* go back to the last occurance of name in stack */ void BKE_undo_name(bContext *C, const char *name) { - UndoElem *uel= BLI_rfindstring(&undobase, name, offsetof(UndoElem, name)); + UndoElem *uel = BLI_rfindstring(&undobase, name, offsetof(UndoElem, name)); if (uel && uel->prev) { - curundo= uel->prev; + curundo = uel->prev; BKE_undo_step(C, 0); } } @@ -659,7 +659,7 @@ void BKE_undo_name(bContext *C, const char *name) int BKE_undo_valid(const char *name) { if (name) { - UndoElem *uel= BLI_rfindstring(&undobase, name, offsetof(UndoElem, name)); + UndoElem *uel = BLI_rfindstring(&undobase, name, offsetof(UndoElem, name)); return uel && uel->prev; } @@ -670,13 +670,13 @@ int BKE_undo_valid(const char *name) /* if active pointer, set it to 1 if true */ const char *BKE_undo_get_name(int nr, int *active) { - UndoElem *uel= BLI_findlink(&undobase, nr); + UndoElem *uel = BLI_findlink(&undobase, nr); - if (active) *active= 0; + if (active) *active = 0; if (uel) { - if (active && uel==curundo) - *active= 1; + if (active && uel == curundo) + *active = 1; return uel->name; } return NULL; @@ -685,23 +685,23 @@ const char *BKE_undo_get_name(int nr, int *active) char *BKE_undo_menu_string(void) { UndoElem *uel; - DynStr *ds= BLI_dynstr_new(); + DynStr *ds = BLI_dynstr_new(); char *menu; BLI_dynstr_append(ds, "Global Undo History %t"); - for (uel= undobase.first; uel; uel= uel->next) { + for (uel = undobase.first; uel; uel = uel->next) { BLI_dynstr_append(ds, "|"); BLI_dynstr_append(ds, uel->name); } - menu= BLI_dynstr_get_cstring(ds); + menu = BLI_dynstr_get_cstring(ds); BLI_dynstr_free(ds); return menu; } - /* saves quit.blend */ +/* saves quit.blend */ void BKE_undo_save_quit(void) { UndoElem *uel; @@ -709,16 +709,16 @@ void BKE_undo_save_quit(void) int file; char str[FILE_MAX]; - if ( (U.uiflag & USER_GLOBALUNDO)==0) return; + if ( (U.uiflag & USER_GLOBALUNDO) == 0) return; - uel= curundo; - if (uel==NULL) { + uel = curundo; + if (uel == NULL) { printf("No undo buffer to save recovery file\n"); return; } /* no undo state to save */ - if (undobase.first==undobase.last) return; + if (undobase.first == undobase.last) return; BLI_make_file_string("/", str, BLI_temporary_dir(), "quit.blend"); @@ -728,28 +728,28 @@ void BKE_undo_save_quit(void) return; } - chunk= uel->memfile.chunks.first; + chunk = uel->memfile.chunks.first; while (chunk) { - if ( write(file, chunk->buf, chunk->size) != chunk->size) break; - chunk= chunk->next; + if (write(file, chunk->buf, chunk->size) != chunk->size) break; + chunk = chunk->next; } close(file); - if (chunk) ; //XXX error("Unable to save %s, internal error", str); + if (chunk) ; //XXX error("Unable to save %s, internal error", str); else printf("Saved session recovery to %s\n", str); } /* sets curscene */ Main *BKE_undo_get_main(Scene **scene) { - Main *mainp= NULL; - BlendFileData *bfd= BLO_read_from_memfile(G.main, G.main->name, &curundo->memfile, NULL); + Main *mainp = NULL; + BlendFileData *bfd = BLO_read_from_memfile(G.main, G.main->name, &curundo->memfile, NULL); if (bfd) { - mainp= bfd->main; + mainp = bfd->main; if (scene) - *scene= bfd->curscene; + *scene = bfd->curscene; MEM_freeN(bfd); } diff --git a/source/blender/blenkernel/intern/bvhutils.c b/source/blender/blenkernel/intern/bvhutils.c index f0bc2dddbad..24583c124e6 100644 --- a/source/blender/blenkernel/intern/bvhutils.c +++ b/source/blender/blenkernel/intern/bvhutils.c @@ -101,11 +101,11 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f sub_v3_v3v3(e1, v2, v0); A00 = dot_v3v3(e0, e0); - A01 = dot_v3v3(e0, e1 ); - A11 = dot_v3v3(e1, e1 ); - B0 = dot_v3v3(diff, e0 ); - B1 = dot_v3v3(diff, e1 ); - C = dot_v3v3(diff, diff ); + A01 = dot_v3v3(e0, e1); + A11 = dot_v3v3(e1, e1); + B0 = dot_v3v3(diff, e0); + B1 = dot_v3v3(diff, e1); + C = dot_v3v3(diff, diff); Det = fabs(A00 * A11 - A01 * A01); S = A01 * B1 - A11 * B0; T = A01 * B0 - A00 * B1; @@ -122,7 +122,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f } else { if (fabsf(A00) > FLT_EPSILON) - S = -B0/A00; + S = -B0 / A00; else S = 0.0f; sqrDist = B0 * S + C; @@ -195,7 +195,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f } } else { /* Region 0 */ - // Minimum at interior lv + /* Minimum at interior lv */ float invDet; if (fabsf(Det) > FLT_EPSILON) invDet = 1.0f / Det; @@ -203,8 +203,8 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f invDet = 0.0f; S *= invDet; T *= invDet; - sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0) + - T * ( A01 * S + A11 * T + 2.0f * B1 ) + C; + sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) + + T * (A01 * S + A11 * T + 2.0f * B1) + C; } } else { @@ -213,10 +213,10 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f if (S < 0.0f) { /* Region 2 */ tmp0 = A01 + B0; tmp1 = A11 + B1; - if ( tmp1 > tmp0 ) { + if (tmp1 > tmp0) { numer = tmp1 - tmp0; denom = A00 - 2.0f * A01 + A11; - if ( numer >= denom ) { + if (numer >= denom) { S = 1.0f; T = 0.0f; sqrDist = A00 + 2.0f * B0 + C; @@ -228,14 +228,14 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f else S = 0.0f; T = 1.0f - S; - sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0 ) + - T * ( A01 * S + A11 * T + 2.0f * B1 ) + C; + sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) + + T * (A01 * S + A11 * T + 2.0f * B1) + C; le = 2; } } else { S = 0.0f; - if ( tmp1 <= 0.0f ) { + if (tmp1 <= 0.0f) { T = 1.0f; sqrDist = A11 + 2.0f * B1 + C; lv = 2; @@ -258,10 +258,10 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f else if (T < 0.0f) { /* Region 6 */ tmp0 = A01 + B1; tmp1 = A00 + B0; - if ( tmp1 > tmp0 ) { + if (tmp1 > tmp0) { numer = tmp1 - tmp0; denom = A00 - 2.0f * A01 + A11; - if ( numer >= denom ) { + if (numer >= denom) { T = 1.0f; S = 0.0f; sqrDist = A11 + 2.0f * B1 + C; @@ -273,8 +273,8 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f else T = 0.0f; S = 1.0f - T; - sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0 ) + - T * ( A01 * S + A11 * T + 2.0f * B1 ) + C; + sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) + + T * (A01 * S + A11 * T + 2.0f * B1) + C; le = 2; } } @@ -302,7 +302,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f } else { /* Region 1 */ numer = A11 + B1 - A01 - B0; - if ( numer <= 0.0f ) { + if (numer <= 0.0f) { S = 0.0f; T = 1.0f; sqrDist = A11 + 2.0f * B1 + C; @@ -310,7 +310,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f } else { denom = A00 - 2.0f * A01 + A11; - if ( numer >= denom ) { + if (numer >= denom) { S = 1.0f; T = 0.0f; sqrDist = A00 + 2.0f * B0 + C; @@ -322,8 +322,8 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f else S = 0.0f; T = 1.0f - S; - sqrDist = S * ( A00 * S + A01 * T + 2.0f * B0 ) + - T * ( A01 * S + A11 * T + 2.0f * B1 ) + C; + sqrDist = S * (A00 * S + A01 * T + 2.0f * B0) + + T * (A01 * S + A11 * T + 2.0f * B1) + C; le = 2; } } @@ -331,7 +331,7 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f } // Account for numerical round-off error - if ( sqrDist < FLT_EPSILON ) + if (sqrDist < FLT_EPSILON) sqrDist = 0.0f; { @@ -362,19 +362,18 @@ float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const f // userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree. static void mesh_faces_nearest_point(void *userdata, int index, const float co[3], BVHTreeNearest *nearest) { - const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata; - MVert *vert = data->vert; + const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata; + MVert *vert = data->vert; MFace *face = data->face + index; float *t0, *t1, *t2, *t3; - t0 = vert[ face->v1 ].co; - t1 = vert[ face->v2 ].co; - t2 = vert[ face->v3 ].co; - t3 = face->v4 ? vert[ face->v4].co : NULL; + t0 = vert[face->v1].co; + t1 = vert[face->v2].co; + t2 = vert[face->v3].co; + t3 = face->v4 ? vert[face->v4].co : NULL; - do - { + do { float nearest_tmp[3], dist; int vertex, edge; @@ -397,8 +396,8 @@ static void mesh_faces_nearest_point(void *userdata, int index, const float co[3 // userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree. static void mesh_faces_spherecast(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit) { - const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata; - MVert *vert = data->vert; + const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata; + MVert *vert = data->vert; MFace *face = data->face + index; float *t0, *t1, *t2, *t3; @@ -408,8 +407,7 @@ static void mesh_faces_spherecast(void *userdata, int index, const BVHTreeRay *r t3 = face->v4 ? vert[face->v4].co : NULL; - do - { + do { float dist; if (data->sphere_radius == 0.0f) dist = bvhtree_ray_tri_intersection(ray, hit->dist, t0, t1, t2); @@ -435,14 +433,14 @@ static void mesh_faces_spherecast(void *userdata, int index, const BVHTreeRay *r // userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree. static void mesh_edges_nearest_point(void *userdata, int index, const float co[3], BVHTreeNearest *nearest) { - const BVHTreeFromMesh *data = (BVHTreeFromMesh*) userdata; - MVert *vert = data->vert; + const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata; + MVert *vert = data->vert; MEdge *edge = data->edge + index; float nearest_tmp[3], dist; float *t0, *t1; - t0 = vert[ edge->v1 ].co; - t1 = vert[ edge->v2 ].co; + t0 = vert[edge->v1].co; + t1 = vert[edge->v2].co; closest_to_line_segment_v3(nearest_tmp, co, t0, t1); dist = len_squared_v3v3(nearest_tmp, co); @@ -460,15 +458,15 @@ static void mesh_edges_nearest_point(void *userdata, int index, const float co[3 * BVH builders */ // Builds a bvh tree.. where nodes are the vertexs of the given mesh -BVHTree* bvhtree_from_mesh_verts(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis) +BVHTree *bvhtree_from_mesh_verts(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis) { BVHTree *tree = bvhcache_find(&mesh->bvhCache, BVHTREE_FROM_VERTICES); //Not in cache if (tree == NULL) { int i; - int numVerts= mesh->getNumVerts(mesh); - MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT); + int numVerts = mesh->getNumVerts(mesh); + MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT); if (vert != NULL) { tree = BLI_bvhtree_new(numVerts, epsilon, tree_type, axis); @@ -514,14 +512,14 @@ BVHTree* bvhtree_from_mesh_verts(BVHTreeFromMesh *data, DerivedMesh *mesh, float } // Builds a bvh tree.. where nodes are the faces of the given mesh. -BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis) +BVHTree *bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis) { BVHTree *tree = bvhcache_find(&mesh->bvhCache, BVHTREE_FROM_FACES); //Not in cache if (tree == NULL) { int i; - int numFaces= mesh->getNumTessFaces(mesh); + int numFaces = mesh->getNumTessFaces(mesh); /* BMESH specific check that we have tessfaces, * we _could_ tessellate here but rather not - campbell @@ -534,7 +532,7 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float /* Create a bvh-tree of the given target */ tree = BLI_bvhtree_new(numFaces, epsilon, tree_type, axis); if (tree != NULL) { - BMEditMesh *em= data->em_evil; + BMEditMesh *em = data->em_evil; if (em) { /* data->em_evil is only set for snapping, and only for the mesh of the object * which is currently open in edit mode. When set, the bvhtree should not contain @@ -594,17 +592,17 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float } } else { - MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT); + MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT); MFace *face = mesh->getTessFaceDataArray(mesh, CD_MFACE); if (vert != NULL && face != NULL) { for (i = 0; i < numFaces; i++) { float co[4][3]; - copy_v3_v3(co[0], vert[ face[i].v1 ].co); - copy_v3_v3(co[1], vert[ face[i].v2 ].co); - copy_v3_v3(co[2], vert[ face[i].v3 ].co); + copy_v3_v3(co[0], vert[face[i].v1].co); + copy_v3_v3(co[1], vert[face[i].v2].co); + copy_v3_v3(co[2], vert[face[i].v3].co); if (face[i].v4) - copy_v3_v3(co[3], vert[ face[i].v4 ].co); + copy_v3_v3(co[3], vert[face[i].v4].co); BLI_bvhtree_insert(tree, i, co[0], face[i].v4 ? 4 : 3); } @@ -644,15 +642,15 @@ BVHTree* bvhtree_from_mesh_faces(BVHTreeFromMesh *data, DerivedMesh *mesh, float } // Builds a bvh tree.. where nodes are the faces of the given mesh. -BVHTree* bvhtree_from_mesh_edges(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis) +BVHTree *bvhtree_from_mesh_edges(BVHTreeFromMesh *data, DerivedMesh *mesh, float epsilon, int tree_type, int axis) { BVHTree *tree = bvhcache_find(&mesh->bvhCache, BVHTREE_FROM_EDGES); //Not in cache if (tree == NULL) { int i; - int numEdges= mesh->getNumEdges(mesh); - MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT); + int numEdges = mesh->getNumEdges(mesh); + MVert *vert = mesh->getVertDataArray(mesh, CD_MVERT); MEdge *edge = mesh->getEdgeDataArray(mesh, CD_MEDGE); if (vert != NULL && edge != NULL) { @@ -661,8 +659,8 @@ BVHTree* bvhtree_from_mesh_edges(BVHTreeFromMesh *data, DerivedMesh *mesh, float if (tree != NULL) { for (i = 0; i < numEdges; i++) { float co[4][3]; - copy_v3_v3(co[0], vert[ edge[i].v1 ].co); - copy_v3_v3(co[1], vert[ edge[i].v2 ].co); + copy_v3_v3(co[0], vert[edge[i].v1].co); + copy_v3_v3(co[1], vert[edge[i].v2].co); BLI_bvhtree_insert(tree, i, co[0], 2); } @@ -712,8 +710,7 @@ void free_bvhtree_from_mesh(struct BVHTreeFromMesh *data) /* BVHCache */ -typedef struct BVHCacheItem -{ +typedef struct BVHCacheItem { int type; BVHTree *tree; @@ -721,8 +718,8 @@ typedef struct BVHCacheItem static void bvhcacheitem_set_if_match(void *_cached, void *_search) { - BVHCacheItem * cached = (BVHCacheItem *)_cached; - BVHCacheItem * search = (BVHCacheItem *)_search; + BVHCacheItem *cached = (BVHCacheItem *)_cached; + BVHCacheItem *search = (BVHCacheItem *)_search; if (search->type == cached->type) { search->tree = cached->tree; diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c index 15db0df1bad..db2362b58ce 100644 --- a/source/blender/blenkernel/intern/cdderivedmesh.c +++ b/source/blender/blenkernel/intern/cdderivedmesh.c @@ -1,4 +1,4 @@ - /* +/* * ***** BEGIN GPL LICENSE BLOCK ***** * * This program is free software; you can redistribute it and/or @@ -172,7 +172,7 @@ static void cdDM_copyPolyArray(DerivedMesh *dm, MPoly *poly_r) static void cdDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3]) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; int i; if (dm->numVertData) { @@ -188,7 +188,7 @@ static void cdDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3]) static void cdDM_getVertCo(DerivedMesh *dm, int index, float co_r[3]) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; copy_v3_v3(co_r, cddm->mvert[index].co); } @@ -204,16 +204,16 @@ static void cdDM_getVertCos(DerivedMesh *dm, float (*cos_r)[3]) static void cdDM_getVertNo(DerivedMesh *dm, int index, float no_r[3]) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; normal_short_to_float_v3(no_r, cddm->mvert[index].no); } static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; if (!cddm->pmap && ob->type == OB_MESH) { - Mesh *me= ob->data; + Mesh *me = ob->data; create_vert_poly_map(&cddm->pmap, &cddm->pmap_mem, me->mpoly, me->mloop, @@ -225,7 +225,7 @@ static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm) static int can_pbvh_draw(Object *ob, DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; Mesh *me = ob->data; int deformed = 0; @@ -247,10 +247,10 @@ static int can_pbvh_draw(Object *ob, DerivedMesh *dm) static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; if (!ob) { - cddm->pbvh= NULL; + cddm->pbvh = NULL; return NULL; } @@ -258,7 +258,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm) return NULL; if (ob->sculpt->pbvh) { - cddm->pbvh= ob->sculpt->pbvh; + cddm->pbvh = ob->sculpt->pbvh; cddm->pbvh_draw = can_pbvh_draw(ob, dm); } @@ -286,7 +286,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm) int totvert; totvert = deformdm->getNumVerts(deformdm); - vertCos = MEM_callocN(3*totvert*sizeof(float), "cdDM_getPBVH vertCos"); + vertCos = MEM_callocN(3 * totvert * sizeof(float), "cdDM_getPBVH vertCos"); deformdm->getVertCos(deformdm, vertCos); BLI_pbvh_apply_vertCos(cddm->pbvh, vertCos); MEM_freeN(vertCos); @@ -300,7 +300,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm) * TODO: proper fix is to support the pbvh in all drawing modes */ static void cdDM_update_normals_from_pbvh(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; float (*face_nors)[3]; if (!cddm->pbvh || !cddm->pbvh_draw || !dm->numTessFaceData) @@ -313,7 +313,7 @@ static void cdDM_update_normals_from_pbvh(DerivedMesh *dm) static void cdDM_drawVerts(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mv = cddm->mvert; int i; @@ -323,7 +323,7 @@ static void cdDM_drawVerts(DerivedMesh *dm) glVertex3fv(mv->co); glEnd(); } - else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ + else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ GPU_vertex_setup(dm); if (!GPU_buffer_legacy(dm)) { if (dm->drawObject->tot_triangle_point) @@ -337,7 +337,7 @@ static void cdDM_drawVerts(DerivedMesh *dm) static void cdDM_drawUVEdges(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MFace *mf = cddm->mface; MTFace *tf = DM_get_tessface_data_layer(dm, CD_MTFACE); int i; @@ -346,7 +346,7 @@ static void cdDM_drawUVEdges(DerivedMesh *dm) if (GPU_buffer_legacy(dm)) { glBegin(GL_LINES); for (i = 0; i < dm->numTessFaceData; i++, mf++, tf++) { - if (!(mf->flag&ME_HIDE)) { + if (!(mf->flag & ME_HIDE)) { glVertex2fv(tf->uv[0]); glVertex2fv(tf->uv[1]); @@ -377,19 +377,19 @@ static void cdDM_drawUVEdges(DerivedMesh *dm) GPU_uvedge_setup(dm); if (!GPU_buffer_legacy(dm)) { for (i = 0; i < dm->numTessFaceData; i++, mf++) { - if (!(mf->flag&ME_HIDE)) { + if (!(mf->flag & ME_HIDE)) { draw = 1; } else { draw = 0; } - if ( prevdraw != draw ) { - if ( prevdraw > 0 && (curpos-prevstart) > 0) { - glDrawArrays(GL_LINES, prevstart, curpos-prevstart); + if (prevdraw != draw) { + if (prevdraw > 0 && (curpos - prevstart) > 0) { + glDrawArrays(GL_LINES, prevstart, curpos - prevstart); } prevstart = curpos; } - if ( mf->v4 ) { + if (mf->v4) { curpos += 8; } else { @@ -397,8 +397,8 @@ static void cdDM_drawUVEdges(DerivedMesh *dm) } prevdraw = draw; } - if ( prevdraw > 0 && (curpos-prevstart) > 0 ) { - glDrawArrays(GL_LINES, prevstart, curpos-prevstart); + if (prevdraw > 0 && (curpos - prevstart) > 0) { + glDrawArrays(GL_LINES, prevstart, curpos - prevstart); } } GPU_buffer_unbind(); @@ -408,7 +408,7 @@ static void cdDM_drawUVEdges(DerivedMesh *dm) static void cdDM_drawEdges(DerivedMesh *dm, int drawLooseEdges, int drawAllEdges) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mvert = cddm->mvert; MEdge *medge = cddm->medge; int i; @@ -426,7 +426,7 @@ static void cdDM_drawEdges(DerivedMesh *dm, int drawLooseEdges, int drawAllEdges } glEnd(); } - else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ + else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ int prevstart = 0; int prevdraw = 1; int draw = TRUE; @@ -442,16 +442,16 @@ static void cdDM_drawEdges(DerivedMesh *dm, int drawLooseEdges, int drawAllEdges else { draw = FALSE; } - if ( prevdraw != draw ) { - if ( prevdraw > 0 && (i-prevstart) > 0 ) { + if (prevdraw != draw) { + if (prevdraw > 0 && (i - prevstart) > 0) { GPU_buffer_draw_elements(dm->drawObject->edges, GL_LINES, prevstart * 2, (i - prevstart) * 2); } prevstart = i; } prevdraw = draw; } - if ( prevdraw > 0 && (i-prevstart) > 0 ) { - GPU_buffer_draw_elements(dm->drawObject->edges, GL_LINES, prevstart * 2, (i-prevstart) * 2); + if (prevdraw > 0 && (i - prevstart) > 0) { + GPU_buffer_draw_elements(dm->drawObject->edges, GL_LINES, prevstart * 2, (i - prevstart) * 2); } } GPU_buffer_unbind(); @@ -460,7 +460,7 @@ static void cdDM_drawEdges(DerivedMesh *dm, int drawLooseEdges, int drawAllEdges static void cdDM_drawLooseEdges(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mvert = cddm->mvert; MEdge *medge = cddm->medge; int i; @@ -469,14 +469,14 @@ static void cdDM_drawLooseEdges(DerivedMesh *dm) DEBUG_VBO("Using legacy code. cdDM_drawLooseEdges\n"); glBegin(GL_LINES); for (i = 0; i < dm->numEdgeData; i++, medge++) { - if (medge->flag&ME_LOOSEEDGE) { + if (medge->flag & ME_LOOSEEDGE) { glVertex3fv(mvert[medge->v1].co); glVertex3fv(mvert[medge->v2].co); } } glEnd(); } - else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ + else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ int prevstart = 0; int prevdraw = 1; int draw = 1; @@ -484,21 +484,21 @@ static void cdDM_drawLooseEdges(DerivedMesh *dm) GPU_edge_setup(dm); if (!GPU_buffer_legacy(dm)) { for (i = 0; i < dm->numEdgeData; i++, medge++) { - if (medge->flag&ME_LOOSEEDGE) { + if (medge->flag & ME_LOOSEEDGE) { draw = 1; } else { draw = 0; } - if ( prevdraw != draw ) { - if ( prevdraw > 0 && (i-prevstart) > 0) { + if (prevdraw != draw) { + if (prevdraw > 0 && (i - prevstart) > 0) { GPU_buffer_draw_elements(dm->drawObject->edges, GL_LINES, prevstart * 2, (i - prevstart) * 2); } prevstart = i; } prevdraw = draw; } - if ( prevdraw > 0 && (i-prevstart) > 0 ) { + if (prevdraw > 0 && (i - prevstart) > 0) { GPU_buffer_draw_elements(dm->drawObject->edges, GL_LINES, prevstart * 2, (i - prevstart) * 2); } } @@ -507,13 +507,13 @@ static void cdDM_drawLooseEdges(DerivedMesh *dm) } static void cdDM_drawFacesSolid(DerivedMesh *dm, - float (*partial_redraw_planes)[4], - int UNUSED(fast), DMSetMaterial setMaterial) + float (*partial_redraw_planes)[4], + int UNUSED(fast), DMSetMaterial setMaterial) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mvert = cddm->mvert; MFace *mface = cddm->mface; - float *nors= dm->getTessFaceDataArray(dm, CD_NORMAL); + float *nors = dm->getTessFaceDataArray(dm, CD_NORMAL); int a, glmode = -1, shademodel = -1, matnr = -1, drawCurrentMat = 1; #define PASSVERT(index) { \ @@ -521,7 +521,7 @@ static void cdDM_drawFacesSolid(DerivedMesh *dm, short *no = mvert[index].no; \ glNormal3sv(no); \ } \ - glVertex3fv(mvert[index].co); \ + glVertex3fv(mvert[index].co); \ } if (cddm->pbvh && cddm->pbvh_draw) { @@ -541,9 +541,9 @@ static void cdDM_drawFacesSolid(DerivedMesh *dm, for (a = 0; a < dm->numTessFaceData; a++, mface++) { int new_glmode, new_matnr, new_shademodel; - new_glmode = mface->v4?GL_QUADS:GL_TRIANGLES; + new_glmode = mface->v4 ? GL_QUADS : GL_TRIANGLES; new_matnr = mface->mat_nr + 1; - new_shademodel = (mface->flag & ME_SMOOTH)?GL_SMOOTH:GL_FLAT; + new_shademodel = (mface->flag & ME_SMOOTH) ? GL_SMOOTH : GL_FLAT; if (new_glmode != glmode || new_matnr != matnr || new_shademodel != shademodel) { glEnd(); @@ -584,7 +584,7 @@ static void cdDM_drawFacesSolid(DerivedMesh *dm, } glEnd(); } - else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ + else { /* use OpenGL VBOs or Vertex Arrays instead for better, faster rendering */ GPU_vertex_setup(dm); GPU_normal_setup(dm); if (!GPU_buffer_legacy(dm)) { @@ -604,16 +604,16 @@ static void cdDM_drawFacesSolid(DerivedMesh *dm, } static void cdDM_drawFacesTex_common(DerivedMesh *dm, - DMSetDrawOptionsTex drawParams, - DMSetDrawOptions drawParamsMapped, - DMCompareDrawOptions compareDrawOptions, - void *userData) + DMSetDrawOptionsTex drawParams, + DMSetDrawOptions drawParamsMapped, + DMCompareDrawOptions compareDrawOptions, + void *userData) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mv = cddm->mvert; MFace *mf = DM_get_tessface_data_layer(dm, CD_MFACE); MCol *realcol = dm->getTessFaceDataArray(dm, CD_TEXTURE_MCOL); - float *nors= dm->getTessFaceDataArray(dm, CD_NORMAL); + float *nors = dm->getTessFaceDataArray(dm, CD_NORMAL); MTFace *tf = DM_get_tessface_data_layer(dm, CD_MTFACE); int i, j, orig, *index = DM_get_tessface_data_layer(dm, CD_ORIGINDEX); int startFace = 0 /*, lastFlag = 0xdeadbeef */ /* UNUSED */; @@ -631,25 +631,25 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, unsigned char *cp = NULL; if (drawParams) { - draw_option = drawParams(tf? &tf[i]: NULL, (mcol != NULL), mf->mat_nr); + draw_option = drawParams(tf ? &tf[i] : NULL, (mcol != NULL), mf->mat_nr); } else { if (index) { orig = *index++; - if (orig == ORIGINDEX_NONE) { if (nors) nors += 3; continue; } + if (orig == ORIGINDEX_NONE) { if (nors) nors += 3; continue; } if (drawParamsMapped) draw_option = drawParamsMapped(userData, orig); - else { if (nors) nors += 3; continue; } + else { if (nors) nors += 3; continue; } } else - if (drawParamsMapped) draw_option = drawParamsMapped(userData, i); - else { if (nors) nors += 3; continue; } + if (drawParamsMapped) draw_option = drawParamsMapped(userData, i); + else { if (nors) nors += 3; continue; } } if (draw_option != DM_DRAW_OPTION_SKIP) { if (draw_option != DM_DRAW_OPTION_NO_MCOL && mcol) - cp = (unsigned char*) &mcol[i*4]; + cp = (unsigned char *) &mcol[i * 4]; - if (!(mf->flag&ME_SMOOTH)) { + if (!(mf->flag & ME_SMOOTH)) { if (nors) { glNormal3fv(nors); } @@ -665,30 +665,30 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, } } - glBegin(mf->v4?GL_QUADS:GL_TRIANGLES); + glBegin(mf->v4 ? GL_QUADS : GL_TRIANGLES); if (tf) glTexCoord2fv(tf[i].uv[0]); if (cp) glColor3ub(cp[3], cp[2], cp[1]); mvert = &mv[mf->v1]; - if (mf->flag&ME_SMOOTH) glNormal3sv(mvert->no); + if (mf->flag & ME_SMOOTH) glNormal3sv(mvert->no); glVertex3fv(mvert->co); if (tf) glTexCoord2fv(tf[i].uv[1]); if (cp) glColor3ub(cp[7], cp[6], cp[5]); mvert = &mv[mf->v2]; - if (mf->flag&ME_SMOOTH) glNormal3sv(mvert->no); + if (mf->flag & ME_SMOOTH) glNormal3sv(mvert->no); glVertex3fv(mvert->co); if (tf) glTexCoord2fv(tf[i].uv[2]); if (cp) glColor3ub(cp[11], cp[10], cp[9]); mvert = &mv[mf->v3]; - if (mf->flag&ME_SMOOTH) glNormal3sv(mvert->no); + if (mf->flag & ME_SMOOTH) glNormal3sv(mvert->no); glVertex3fv(mvert->co); if (mf->v4) { if (tf) glTexCoord2fv(tf[i].uv[3]); if (cp) glColor3ub(cp[15], cp[14], cp[13]); mvert = &mv[mf->v4]; - if (mf->flag&ME_SMOOTH) glNormal3sv(mvert->no); + if (mf->flag & ME_SMOOTH) glNormal3sv(mvert->no); glVertex3fv(mvert->co); } glEnd(); @@ -705,7 +705,7 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, GPU_vertex_setup(dm); GPU_normal_setup(dm); GPU_uv_setup(dm); - if ( col != NULL ) { + if (col != NULL) { #if 0 if (realcol && dm->drawObject->colType == CD_TEXTURE_MCOL) { col = 0; @@ -717,13 +717,13 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, if (col != 0) #endif { - unsigned char *colors = MEM_mallocN(dm->getNumTessFaces(dm)*4*3*sizeof(unsigned char), "cdDM_drawFacesTex_common"); + unsigned char *colors = MEM_mallocN(dm->getNumTessFaces(dm) * 4 * 3 * sizeof(unsigned char), "cdDM_drawFacesTex_common"); for (i = 0; i < dm->getNumTessFaces(dm); i++) { for (j = 0; j < 4; j++) { /* bgr -> rgb is intentional (and stupid), but how its stored internally */ - colors[i*12+j*3] = col[i*4+j].b; - colors[i*12+j*3+1] = col[i*4+j].g; - colors[i*12+j*3+2] = col[i*4+j].r; + colors[i * 12 + j * 3] = col[i * 4 + j].b; + colors[i * 12 + j * 3 + 1] = col[i * 4 + j].g; + colors[i * 12 + j * 3 + 2] = col[i * 4 + j].r; } } GPU_color3_upload(dm, colors); @@ -737,7 +737,7 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, } if (!GPU_buffer_legacy(dm)) { - int tottri = dm->drawObject->tot_triangle_point/3; + int tottri = dm->drawObject->tot_triangle_point / 3; int next_actualFace = dm->drawObject->triangle_to_mface[0]; glShadeModel(GL_SMOOTH); @@ -747,11 +747,11 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, DMDrawOption draw_option = DM_DRAW_OPTION_NORMAL; int flush = 0; - if (i != tottri-1) - next_actualFace= dm->drawObject->triangle_to_mface[i+1]; + if (i != tottri - 1) + next_actualFace = dm->drawObject->triangle_to_mface[i + 1]; if (drawParams) { - draw_option = drawParams(tf? &tf[actualFace]: NULL, (mcol != NULL), mf[actualFace].mat_nr); + draw_option = drawParams(tf ? &tf[actualFace] : NULL, (mcol != NULL), mf[actualFace].mat_nr); } else { if (index) { @@ -761,8 +761,8 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, draw_option = drawParamsMapped(userData, orig); } else - if (drawParamsMapped) - draw_option = drawParamsMapped(userData, actualFace); + if (drawParamsMapped) + draw_option = drawParamsMapped(userData, actualFace); } /* flush buffer if current triangle isn't drawable or it's last triangle */ @@ -771,13 +771,13 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, if (!flush && compareDrawOptions) { /* also compare draw options and flush buffer if they're different * need for face selection highlight in edit mode */ - flush|= compareDrawOptions(userData, actualFace, next_actualFace) == 0; + flush |= compareDrawOptions(userData, actualFace, next_actualFace) == 0; } if (flush) { - int first = startFace*3; + int first = startFace * 3; /* Add one to the length if we're drawing at the end of the array */ - int count = (i-startFace+(draw_option != DM_DRAW_OPTION_SKIP ? 1 : 0))*3; + int count = (i - startFace + (draw_option != DM_DRAW_OPTION_SKIP ? 1 : 0)) * 3; if (count) { if (col) @@ -799,24 +799,24 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm, } static void cdDM_drawFacesTex(DerivedMesh *dm, - DMSetDrawOptionsTex setDrawOptions, - DMCompareDrawOptions compareDrawOptions, - void *userData) + DMSetDrawOptionsTex setDrawOptions, + DMCompareDrawOptions compareDrawOptions, + void *userData) { cdDM_drawFacesTex_common(dm, setDrawOptions, NULL, compareDrawOptions, userData); } static void cdDM_drawMappedFaces(DerivedMesh *dm, - DMSetDrawOptions setDrawOptions, - DMSetMaterial setMaterial, - DMCompareDrawOptions compareDrawOptions, - void *userData, DMDrawFlag flag) + DMSetDrawOptions setDrawOptions, + DMSetMaterial setMaterial, + DMCompareDrawOptions compareDrawOptions, + void *userData, DMDrawFlag flag) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mv = cddm->mvert; MFace *mf = cddm->mface; MCol *mc; - float *nors= DM_get_tessface_data_layer(dm, CD_NORMAL); + float *nors = DM_get_tessface_data_layer(dm, CD_NORMAL); int useColors = flag & DM_DRAW_USE_COLORS; int i, orig, *index = DM_get_tessface_data_layer(dm, CD_ORIGINDEX); @@ -836,12 +836,12 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm, int drawSmooth = (flag & DM_DRAW_ALWAYS_SMOOTH) ? 1 : (mf->flag & ME_SMOOTH); DMDrawOption draw_option = DM_DRAW_OPTION_NORMAL; - orig = (index==NULL) ? i : *index++; + orig = (index == NULL) ? i : *index++; if (orig == ORIGINDEX_NONE) - draw_option= setMaterial(mf->mat_nr + 1, NULL); + draw_option = setMaterial(mf->mat_nr + 1, NULL); else if (setDrawOptions != NULL) - draw_option= setDrawOptions(userData, orig); + draw_option = setDrawOptions(userData, orig); if (draw_option != DM_DRAW_OPTION_SKIP) { unsigned char *cp = NULL; @@ -852,7 +852,7 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm, /* no need to set shading mode to flat because * normals are already used to change shading */ glShadeModel(GL_SMOOTH); - glBegin(mf->v4?GL_QUADS:GL_TRIANGLES); + glBegin(mf->v4 ? GL_QUADS : GL_TRIANGLES); if (!drawSmooth) { if (nors) { @@ -907,10 +907,10 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm, int prevstart = 0; GPU_vertex_setup(dm); GPU_normal_setup(dm); - if ( useColors && mc ) + if (useColors && mc) GPU_color_setup(dm); if (!GPU_buffer_legacy(dm)) { - int tottri = dm->drawObject->tot_triangle_point/3; + int tottri = dm->drawObject->tot_triangle_point / 3; glShadeModel(GL_SMOOTH); if (tottri == 0) { @@ -932,15 +932,15 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm, DMDrawOption draw_option = DM_DRAW_OPTION_NORMAL; int flush = 0; - if (i != tottri-1) - next_actualFace= dm->drawObject->triangle_to_mface[i+1]; + if (i != tottri - 1) + next_actualFace = dm->drawObject->triangle_to_mface[i + 1]; - orig = (index==NULL) ? actualFace : index[actualFace]; + orig = (index == NULL) ? actualFace : index[actualFace]; if (orig == ORIGINDEX_NONE) - draw_option= setMaterial(mface->mat_nr + 1, NULL); + draw_option = setMaterial(mface->mat_nr + 1, NULL); else if (setDrawOptions != NULL) - draw_option= setDrawOptions(userData, orig); + draw_option = setDrawOptions(userData, orig); /* Goal is to draw as long of a contiguous triangle * array as possible, so draw when we hit either an @@ -957,9 +957,9 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm, } if (flush) { - int first = prevstart*3; + int first = prevstart * 3; /* Add one to the length if we're drawing at the end of the array */ - int count = (i-prevstart+(draw_option != DM_DRAW_OPTION_SKIP ? 1 : 0))*3; + int count = (i - prevstart + (draw_option != DM_DRAW_OPTION_SKIP ? 1 : 0)) * 3; if (count) glDrawArrays(GL_TRIANGLES, first, count); @@ -976,9 +976,9 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm, } static void cdDM_drawMappedFacesTex(DerivedMesh *dm, - DMSetDrawOptions setDrawOptions, - DMCompareDrawOptions compareDrawOptions, - void *userData) + DMSetDrawOptions setDrawOptions, + DMCompareDrawOptions compareDrawOptions, + void *userData) { cdDM_drawFacesTex_common(dm, NULL, setDrawOptions, compareDrawOptions, userData); } @@ -1007,15 +1007,15 @@ static void cddm_draw_attrib_vertex(DMVertexAttribs *attribs, MVert *mvert, int /* vertex colors */ for (b = 0; b < attribs->totmcol; b++) { - MCol *cp = &attribs->mcol[b].array[a*4 + vert]; + MCol *cp = &attribs->mcol[b].array[a * 4 + vert]; GLubyte col[4]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; glVertexAttrib4ubvARB(attribs->mcol[b].gl_index, col); } /* tangent for normal mapping */ if (attribs->tottang) { - float *tang = attribs->tang.array[a*4 + vert]; + float *tang = attribs->tang.array[a * 4 + vert]; glVertexAttrib4fvARB(attribs->tang.gl_index, tang); } @@ -1028,11 +1028,11 @@ static void cddm_draw_attrib_vertex(DMVertexAttribs *attribs, MVert *mvert, int } static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, - DMSetMaterial setMaterial, - DMSetDrawOptions setDrawOptions, - void *userData) + DMSetMaterial setMaterial, + DMSetDrawOptions setDrawOptions, + void *userData) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; GPUVertexAttribs gattribs; DMVertexAttribs attribs; MVert *mvert = cddm->mvert; @@ -1049,7 +1049,7 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, glShadeModel(GL_SMOOTH); - if ( GPU_buffer_legacy(dm) || setDrawOptions != NULL ) { + if (GPU_buffer_legacy(dm) || setDrawOptions != NULL) { DEBUG_VBO("Using legacy code. cdDM_drawMappedFacesGLSL\n"); memset(&attribs, 0, sizeof(attribs)); @@ -1073,7 +1073,7 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, continue; } else if (setDrawOptions) { - orig = (index)? index[a]: a; + orig = (index) ? index[a] : a; if (orig == ORIGINDEX_NONE) { /* since the material is set by setMaterial(), faces with no @@ -1128,7 +1128,7 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, GPU_normal_setup(dm); if (!GPU_buffer_legacy(dm)) { - for (i = 0; i < dm->drawObject->tot_triangle_point/3; i++) { + for (i = 0; i < dm->drawObject->tot_triangle_point / 3; i++) { a = dm->drawObject->triangle_to_mface[i]; @@ -1148,7 +1148,7 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, GPU_interleaved_attrib_setup(buffer, datatypes, numdata); } - glDrawArrays(GL_TRIANGLES, start*3, numfaces*3); + glDrawArrays(GL_TRIANGLES, start * 3, numfaces * 3); if (numdata != 0) { @@ -1215,84 +1215,84 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, } } - if (dodraw && numdata != 0 ) { + if (dodraw && numdata != 0) { offset = 0; if (attribs.totorco) { - copy_v3_v3((float *)&varray[elementsize*curface*3], (float *)attribs.orco.array[mface->v1]); - copy_v3_v3((float *)&varray[elementsize*curface*3+elementsize], (float *)attribs.orco.array[mface->v2]); - copy_v3_v3((float *)&varray[elementsize*curface*3+elementsize*2], (float *)attribs.orco.array[mface->v3]); - offset += sizeof(float)*3; + copy_v3_v3((float *)&varray[elementsize * curface * 3], (float *)attribs.orco.array[mface->v1]); + copy_v3_v3((float *)&varray[elementsize * curface * 3 + elementsize], (float *)attribs.orco.array[mface->v2]); + copy_v3_v3((float *)&varray[elementsize * curface * 3 + elementsize * 2], (float *)attribs.orco.array[mface->v3]); + offset += sizeof(float) * 3; } for (b = 0; b < attribs.tottface; b++) { MTFace *tf = &attribs.tface[b].array[a]; - copy_v2_v2((float *)&varray[elementsize*curface*3+offset], tf->uv[0]); - copy_v2_v2((float *)&varray[elementsize*curface*3+offset+elementsize], tf->uv[1]); + copy_v2_v2((float *)&varray[elementsize * curface * 3 + offset], tf->uv[0]); + copy_v2_v2((float *)&varray[elementsize * curface * 3 + offset + elementsize], tf->uv[1]); - copy_v2_v2((float *)&varray[elementsize*curface*3+offset+elementsize*2], tf->uv[2]); - offset += sizeof(float)*2; + copy_v2_v2((float *)&varray[elementsize * curface * 3 + offset + elementsize * 2], tf->uv[2]); + offset += sizeof(float) * 2; } for (b = 0; b < attribs.totmcol; b++) { - MCol *cp = &attribs.mcol[b].array[a*4 + 0]; + MCol *cp = &attribs.mcol[b].array[a * 4 + 0]; GLubyte col[4]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; - copy_v4_v4_char((char *)&varray[elementsize*curface*3+offset], (char *)col); - cp = &attribs.mcol[b].array[a*4 + 1]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; - copy_v4_v4_char((char *)&varray[elementsize*curface*3+offset+elementsize], (char *)col); - cp = &attribs.mcol[b].array[a*4 + 2]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; - copy_v4_v4_char((char *)&varray[elementsize*curface*3+offset+elementsize*2], (char *)col); - offset += sizeof(unsigned char)*4; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; + copy_v4_v4_char((char *)&varray[elementsize * curface * 3 + offset], (char *)col); + cp = &attribs.mcol[b].array[a * 4 + 1]; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; + copy_v4_v4_char((char *)&varray[elementsize * curface * 3 + offset + elementsize], (char *)col); + cp = &attribs.mcol[b].array[a * 4 + 2]; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; + copy_v4_v4_char((char *)&varray[elementsize * curface * 3 + offset + elementsize * 2], (char *)col); + offset += sizeof(unsigned char) * 4; } if (attribs.tottang) { - float *tang = attribs.tang.array[a*4 + 0]; - copy_v4_v4((float *)&varray[elementsize*curface*3+offset], tang); - tang = attribs.tang.array[a*4 + 1]; - copy_v4_v4((float *)&varray[elementsize*curface*3+offset+elementsize], tang); - tang = attribs.tang.array[a*4 + 2]; - copy_v4_v4((float *)&varray[elementsize*curface*3+offset+elementsize*2], tang); - offset += sizeof(float)*4; + float *tang = attribs.tang.array[a * 4 + 0]; + copy_v4_v4((float *)&varray[elementsize * curface * 3 + offset], tang); + tang = attribs.tang.array[a * 4 + 1]; + copy_v4_v4((float *)&varray[elementsize * curface * 3 + offset + elementsize], tang); + tang = attribs.tang.array[a * 4 + 2]; + copy_v4_v4((float *)&varray[elementsize * curface * 3 + offset + elementsize * 2], tang); + offset += sizeof(float) * 4; } (void)offset; } curface++; if (mface->v4) { - if (dodraw && numdata != 0 ) { + if (dodraw && numdata != 0) { offset = 0; if (attribs.totorco) { - copy_v3_v3((float *)&varray[elementsize*curface*3], (float *)attribs.orco.array[mface->v3]); - copy_v3_v3((float *)&varray[elementsize*curface*3+elementsize], (float *)attribs.orco.array[mface->v4]); - copy_v3_v3((float *)&varray[elementsize*curface*3+elementsize*2], (float *)attribs.orco.array[mface->v1]); - offset += sizeof(float)*3; + copy_v3_v3((float *)&varray[elementsize * curface * 3], (float *)attribs.orco.array[mface->v3]); + copy_v3_v3((float *)&varray[elementsize * curface * 3 + elementsize], (float *)attribs.orco.array[mface->v4]); + copy_v3_v3((float *)&varray[elementsize * curface * 3 + elementsize * 2], (float *)attribs.orco.array[mface->v1]); + offset += sizeof(float) * 3; } for (b = 0; b < attribs.tottface; b++) { MTFace *tf = &attribs.tface[b].array[a]; - copy_v2_v2((float *)&varray[elementsize*curface*3+offset], tf->uv[2]); - copy_v2_v2((float *)&varray[elementsize*curface*3+offset+elementsize], tf->uv[3]); - copy_v2_v2((float *)&varray[elementsize*curface*3+offset+elementsize*2], tf->uv[0]); - offset += sizeof(float)*2; + copy_v2_v2((float *)&varray[elementsize * curface * 3 + offset], tf->uv[2]); + copy_v2_v2((float *)&varray[elementsize * curface * 3 + offset + elementsize], tf->uv[3]); + copy_v2_v2((float *)&varray[elementsize * curface * 3 + offset + elementsize * 2], tf->uv[0]); + offset += sizeof(float) * 2; } for (b = 0; b < attribs.totmcol; b++) { - MCol *cp = &attribs.mcol[b].array[a*4 + 2]; + MCol *cp = &attribs.mcol[b].array[a * 4 + 2]; GLubyte col[4]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; - copy_v4_v4_char((char *)&varray[elementsize*curface*3+offset], (char *)col); - cp = &attribs.mcol[b].array[a*4 + 3]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; - copy_v4_v4_char((char *)&varray[elementsize*curface*3+offset+elementsize], (char *)col); - cp = &attribs.mcol[b].array[a*4 + 0]; - col[0]= cp->b; col[1]= cp->g; col[2]= cp->r; col[3]= cp->a; - copy_v4_v4_char((char *)&varray[elementsize*curface*3+offset+elementsize*2], (char *)col); - offset += sizeof(unsigned char)*4; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; + copy_v4_v4_char((char *)&varray[elementsize * curface * 3 + offset], (char *)col); + cp = &attribs.mcol[b].array[a * 4 + 3]; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; + copy_v4_v4_char((char *)&varray[elementsize * curface * 3 + offset + elementsize], (char *)col); + cp = &attribs.mcol[b].array[a * 4 + 0]; + col[0] = cp->b; col[1] = cp->g; col[2] = cp->r; col[3] = cp->a; + copy_v4_v4_char((char *)&varray[elementsize * curface * 3 + offset + elementsize * 2], (char *)col); + offset += sizeof(unsigned char) * 4; } if (attribs.tottang) { - float *tang = attribs.tang.array[a*4 + 2]; - copy_v4_v4((float *)&varray[elementsize*curface*3+offset], tang); - tang = attribs.tang.array[a*4 + 3]; - copy_v4_v4((float *)&varray[elementsize*curface*3+offset+elementsize], tang); - tang = attribs.tang.array[a*4 + 0]; - copy_v4_v4((float *)&varray[elementsize*curface*3+offset+elementsize*2], tang); - offset += sizeof(float)*4; + float *tang = attribs.tang.array[a * 4 + 2]; + copy_v4_v4((float *)&varray[elementsize * curface * 3 + offset], tang); + tang = attribs.tang.array[a * 4 + 3]; + copy_v4_v4((float *)&varray[elementsize * curface * 3 + offset + elementsize], tang); + tang = attribs.tang.array[a * 4 + 0]; + copy_v4_v4((float *)&varray[elementsize * curface * 3 + offset + elementsize * 2], tang); + offset += sizeof(float) * 4; } (void)offset; } @@ -1307,7 +1307,7 @@ static void cdDM_drawMappedFacesGLSL(DerivedMesh *dm, GPU_buffer_unlock(buffer); GPU_interleaved_attrib_setup(buffer, datatypes, numdata); } - glDrawArrays(GL_TRIANGLES, start*3, (curface-start)*3); + glDrawArrays(GL_TRIANGLES, start * 3, (curface - start) * 3); } } GPU_buffer_unbind(); @@ -1324,10 +1324,10 @@ static void cdDM_drawFacesGLSL(DerivedMesh *dm, DMSetMaterial setMaterial) } static void cdDM_drawMappedFacesMat(DerivedMesh *dm, - void (*setMaterial)(void *userData, int, void *attribs), - int (*setFace)(void *userData, int index), void *userData) + void (*setMaterial)(void *userData, int, void *attribs), + int (*setFace)(void *userData, int index), void *userData) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; GPUVertexAttribs gattribs; DMVertexAttribs attribs; MVert *mvert = cddm->mvert; @@ -1363,7 +1363,7 @@ static void cdDM_drawMappedFacesMat(DerivedMesh *dm, /* skipping faces */ if (setFace) { - orig = (index)? index[a]: a; + orig = (index) ? index[a] : a; if (orig != ORIGINDEX_NONE && !setFace(userData, orig)) continue; @@ -1404,7 +1404,7 @@ static void cdDM_drawMappedFacesMat(DerivedMesh *dm, static void cdDM_drawMappedEdges(DerivedMesh *dm, DMSetDrawOptions setDrawOptions, void *userData) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *vert = cddm->mvert; MEdge *edge = cddm->medge; int i, orig, *index = DM_get_edge_data_layer(dm, CD_ORIGINDEX); @@ -1450,7 +1450,7 @@ static void cdDM_foreachMappedEdge( void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]), void *userData) { - CDDerivedMesh *cddm = (CDDerivedMesh*) dm; + CDDerivedMesh *cddm = (CDDerivedMesh *) dm; MVert *mv = cddm->mvert; MEdge *med = cddm->medge; int i, orig, *index = DM_get_edge_data_layer(dm, CD_ORIGINDEX); @@ -1471,7 +1471,7 @@ static void cdDM_foreachMappedFaceCenter( void (*func)(void *userData, int index, const float cent[3], const float no[3]), void *userData) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; MVert *mv = cddm->mvert; MPoly *mp = cddm->mpoly; MLoop *ml = cddm->mloop; @@ -1492,7 +1492,7 @@ static void cdDM_foreachMappedFaceCenter( ml = &cddm->mloop[mp->loopstart]; cent[0] = cent[1] = cent[2] = 0.0f; - for (j=0; jtotloop; j++, ml++) { + for (j = 0; j < mp->totloop; j++, ml++) { add_v3_v3v3(cent, cent, mv[ml->v].co); } mul_v3_fl(cent, 1.0f / (float)j); @@ -1519,7 +1519,7 @@ static void cdDM_foreachMappedFaceCenter( void CDDM_recalc_tessellation_ex(DerivedMesh *dm, const int do_face_nor_cpy) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; dm->numTessFaceData = BKE_mesh_recalc_tessellation(&dm->faceData, &dm->loopData, &dm->polyData, cddm->mvert, @@ -1551,7 +1551,7 @@ static void cdDM_free_internal(CDDerivedMesh *cddm) static void cdDM_release(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; if (DM_release(dm)) { cdDM_free_internal(cddm); @@ -1671,18 +1671,18 @@ DerivedMesh *CDDM_from_mesh(Mesh *mesh, Object *UNUSED(ob)) /* this does a referenced copy, with an exception for fluidsim */ DM_init(dm, DM_TYPE_CDDM, mesh->totvert, mesh->totedge, mesh->totface, - mesh->totloop, mesh->totpoly); + mesh->totloop, mesh->totpoly); dm->deformedOnly = 1; - alloctype= CD_REFERENCE; + alloctype = CD_REFERENCE; CustomData_merge(&mesh->vdata, &dm->vertData, mask, alloctype, - mesh->totvert); + mesh->totvert); CustomData_merge(&mesh->edata, &dm->edgeData, mask, alloctype, - mesh->totedge); - CustomData_merge(&mesh->fdata, &dm->faceData, mask|CD_MASK_POLYINDEX, alloctype, - mesh->totface); + mesh->totedge); + CustomData_merge(&mesh->fdata, &dm->faceData, mask | CD_MASK_POLYINDEX, alloctype, + mesh->totface); CustomData_merge(&mesh->ldata, &dm->loopData, mask, alloctype, mesh->totloop); CustomData_merge(&mesh->pdata, &dm->polyData, mask, alloctype, @@ -1733,12 +1733,12 @@ DerivedMesh *CDDM_from_curve_customDB(Object *ob, ListBase *dispbase) dm = CDDM_new(totvert, totedge, 0, totloop, totpoly); dm->deformedOnly = 1; - cddm = (CDDerivedMesh*)dm; + cddm = (CDDerivedMesh *)dm; - memcpy(cddm->mvert, allvert, totvert*sizeof(MVert)); - memcpy(cddm->medge, alledge, totedge*sizeof(MEdge)); - memcpy(cddm->mloop, allloop, totloop*sizeof(MLoop)); - memcpy(cddm->mpoly, allpoly, totpoly*sizeof(MPoly)); + memcpy(cddm->mvert, allvert, totvert * sizeof(MVert)); + memcpy(cddm->medge, alledge, totedge * sizeof(MEdge)); + memcpy(cddm->mloop, allloop, totloop * sizeof(MLoop)); + memcpy(cddm->mpoly, allpoly, totpoly * sizeof(MPoly)); MEM_freeN(allvert); MEM_freeN(alledge); @@ -1751,8 +1751,8 @@ DerivedMesh *CDDM_from_curve_customDB(Object *ob, ListBase *dispbase) } static void loops_to_customdata_corners(BMesh *bm, CustomData *facedata, - int cdindex, BMLoop *l3[3], - int numCol, int numTex) + int cdindex, BMLoop *l3[3], + int numCol, int numTex) { BMLoop *l; BMFace *f = l3[0]->f; @@ -1769,7 +1769,7 @@ static void loops_to_customdata_corners(BMesh *bm, CustomData *facedata, ME_MTEXFACE_CPY(texface, texpoly); - for (j = 0 ; j < 3; j++) { + for (j = 0; j < 3; j++) { l = l3[j]; mloopuv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i); copy_v2_v2(texface->uv[j], mloopuv->uv); @@ -1807,7 +1807,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis bm->totloop, bm->totface); - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; BMIter iter, liter; BMVert *eve; BMEdge *eed; @@ -1833,7 +1833,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis /*don't add origindex layer if one already exists*/ add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX); - mask = use_mdisps ? CD_MASK_DERIVEDMESH|CD_MASK_MDISPS : CD_MASK_DERIVEDMESH; + mask = use_mdisps ? CD_MASK_DERIVEDMESH | CD_MASK_MDISPS : CD_MASK_DERIVEDMESH; /* don't process shapekeys, we only feed them through the modifier stack as needed, * e.g. for applying modifiers or the like*/ @@ -1867,7 +1867,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis mv->flag = BM_vert_flag_to_mflag(eve); if (has_vert_bweight) - mv->bweight = (unsigned char)(BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT)*255.0f); + mv->bweight = (unsigned char)(BM_elem_float_data_get(&bm->vdata, eve, CD_BWEIGHT) * 255.0f); if (add_orig) *index = i; @@ -1886,9 +1886,9 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis med->v2 = BM_elem_index_get(eed->v2); if (has_crease) - med->crease = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_CREASE)*255.0f); + med->crease = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_CREASE) * 255.0f); if (has_edge_bweight) - med->bweight = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_BWEIGHT)*255.0f); + med->bweight = (unsigned char)(BM_elem_float_data_get(&bm->edata, eed, CD_BWEIGHT) * 255.0f); med->flag = BM_edge_flag_to_mflag(eed); @@ -1917,7 +1917,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis mf->mat_nr = efa->mat_nr; mf->flag = BM_face_flag_to_mflag(efa); - *index = add_orig ? BM_elem_index_get(efa) : *(int*)CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_ORIGINDEX); + *index = add_orig ? BM_elem_index_get(efa) : *(int *)CustomData_bmesh_get(&bm->pdata, efa->head.data, CD_ORIGINDEX); *polyindex = BM_elem_index_get(efa); loops_to_customdata_corners(bm, &dm->faceData, i, l, numCol, numTex); @@ -1974,7 +1974,7 @@ static DerivedMesh *cddm_copy_ex(DerivedMesh *source, int faces_from_tessfaces) /* this initializes dm, and copies all non mvert/medge/mface layers */ DM_from_template(dm, source, DM_TYPE_CDDM, numVerts, numEdges, numTessFaces, - numLoops, numPolys); + numLoops, numPolys); dm->deformedOnly = source->deformedOnly; dm->dirty = source->dirty; @@ -2056,7 +2056,7 @@ DerivedMesh *CDDM_from_template(DerivedMesh *source, void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3]) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; MVert *vert; int i; @@ -2070,7 +2070,7 @@ void CDDM_apply_vert_coords(DerivedMesh *dm, float (*vertCoords)[3]) void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3]) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; MVert *vert; int i; @@ -2084,7 +2084,7 @@ void CDDM_apply_vert_normals(DerivedMesh *dm, short (*vertNormals)[3]) void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const short only_face_normals) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; float (*face_nors)[3] = NULL; if (dm->numVertData == 0) return; @@ -2114,7 +2114,7 @@ void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const short only_face_normals } - face_nors = MEM_mallocN(sizeof(float)*3*dm->numTessFaceData, "face_nors"); + face_nors = MEM_mallocN(sizeof(float) * 3 * dm->numTessFaceData, "face_nors"); /* calculate face normals */ BKE_mesh_calc_normals_mapping_ex(cddm->mvert, dm->numVertData, CDDM_get_loops(dm), CDDM_get_polys(dm), @@ -2123,7 +2123,7 @@ void CDDM_calc_normals_mapping_ex(DerivedMesh *dm, const short only_face_normals only_face_normals); CustomData_add_layer(&dm->faceData, CD_NORMAL, CD_ASSIGN, - face_nors, dm->numTessFaceData); + face_nors, dm->numTessFaceData); } @@ -2138,7 +2138,7 @@ void CDDM_calc_normals_mapping(DerivedMesh *dm) /* bmesh note: this matches what we have in trunk */ void CDDM_calc_normals(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; float (*poly_nors)[3]; if (dm->numVertData == 0) return; @@ -2158,7 +2158,7 @@ void CDDM_calc_normals(DerivedMesh *dm) void CDDM_calc_normals_tessface(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; float (*face_nors)[3]; if (dm->numVertData == 0) return; @@ -2190,7 +2190,7 @@ void CDDM_calc_normals_tessface(DerivedMesh *dm) */ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; CDDerivedMesh *cddm2 = NULL; MVert *mv, *mvert = NULL; BLI_array_declare(mvert); @@ -2209,9 +2209,9 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) totloop = dm->numLoopData; totpoly = dm->numPolyData; - newv = MEM_callocN(sizeof(int)*dm->numVertData, "newv vtable CDDM_merge_verts"); - newe = MEM_callocN(sizeof(int)*dm->numEdgeData, "newv etable CDDM_merge_verts"); - newl = MEM_callocN(sizeof(int)*totloop, "newv ltable CDDM_merge_verts"); + newv = MEM_callocN(sizeof(int) * dm->numVertData, "newv vtable CDDM_merge_verts"); + newe = MEM_callocN(sizeof(int) * dm->numEdgeData, "newv etable CDDM_merge_verts"); + newl = MEM_callocN(sizeof(int) * totloop, "newv ltable CDDM_merge_verts"); /*fill newl with destination vertex indices*/ mv = cddm->mvert; @@ -2247,7 +2247,7 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) if (LIKELY(med->v1 != med->v2)) { const unsigned int v1 = (vtargetmap[med->v1] != -1) ? vtargetmap[med->v1] : med->v1; const unsigned int v2 = (vtargetmap[med->v2] != -1) ? vtargetmap[med->v2] : med->v2; - void **eh_p= BLI_edgehash_lookup_p(ehash, v1, v2); + void **eh_p = BLI_edgehash_lookup_p(ehash, v1, v2); if (eh_p) { newe[i] = GET_INT_FROM_POINTER(*eh_p); @@ -2275,8 +2275,8 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) for (j = 0; j < mp->totloop; j++, ml++) { med = cddm->medge + ml->e; if (LIKELY(med->v1 != med->v2)) { - newl[j+mp->loopstart] = BLI_array_count(mloop); - BLI_array_append(oldl, j+mp->loopstart); + newl[j + mp->loopstart] = BLI_array_count(mloop); + BLI_array_append(oldl, j + mp->loopstart); BLI_array_append(mloop, *ml); c++; } @@ -2294,7 +2294,7 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) } /*create new cddm*/ - cddm2 = (CDDerivedMesh*) CDDM_from_template((DerivedMesh*)cddm, BLI_array_count(mvert), BLI_array_count(medge), 0, BLI_array_count(mloop), BLI_array_count(mpoly)); + cddm2 = (CDDerivedMesh *) CDDM_from_template((DerivedMesh *)cddm, BLI_array_count(mvert), BLI_array_count(medge), 0, BLI_array_count(mloop), BLI_array_count(mpoly)); /*update edge indices and copy customdata*/ med = medge; @@ -2331,10 +2331,10 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) } /*copy over data. CustomData_add_layer can do this, need to look it up.*/ - memcpy(cddm2->mvert, mvert, sizeof(MVert)*BLI_array_count(mvert)); - memcpy(cddm2->medge, medge, sizeof(MEdge)*BLI_array_count(medge)); - memcpy(cddm2->mloop, mloop, sizeof(MLoop)*BLI_array_count(mloop)); - memcpy(cddm2->mpoly, mpoly, sizeof(MPoly)*BLI_array_count(mpoly)); + memcpy(cddm2->mvert, mvert, sizeof(MVert) * BLI_array_count(mvert)); + memcpy(cddm2->medge, medge, sizeof(MEdge) * BLI_array_count(medge)); + memcpy(cddm2->mloop, mloop, sizeof(MLoop) * BLI_array_count(mloop)); + memcpy(cddm2->mpoly, mpoly, sizeof(MPoly) * BLI_array_count(mpoly)); BLI_array_free(mvert); BLI_array_free(medge); BLI_array_free(mloop); BLI_array_free(mpoly); if (newv) @@ -2358,13 +2358,13 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap) dm->needsFree = 1; dm->release(dm); - return (DerivedMesh*)cddm2; + return (DerivedMesh *)cddm2; } #endif void CDDM_calc_edges_tessface(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; CustomData edgeData; EdgeHashIterator *ehi; MFace *mf = cddm->mface; @@ -2401,10 +2401,10 @@ void CDDM_calc_edges_tessface(DerivedMesh *dm) med = CustomData_get_layer(&edgeData, CD_MEDGE); index = CustomData_get_layer(&edgeData, CD_ORIGINDEX); for (i = 0; !BLI_edgehashIterator_isDone(ehi); - BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) { + BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) { BLI_edgehashIterator_getKey(ehi, &med->v1, &med->v2); - med->flag = ME_EDGEDRAW|ME_EDGERENDER; + med->flag = ME_EDGEDRAW | ME_EDGERENDER; *index = ORIGINDEX_NONE; } BLI_edgehashIterator_free(ehi); @@ -2422,7 +2422,7 @@ void CDDM_calc_edges_tessface(DerivedMesh *dm) /* warning, this uses existing edges but CDDM_calc_edges_tessface() doesn't */ void CDDM_calc_edges(DerivedMesh *dm) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; CustomData edgeData; EdgeHashIterator *ehi; MPoly *mp = cddm->mpoly; @@ -2438,7 +2438,7 @@ void CDDM_calc_edges(DerivedMesh *dm) med = cddm->medge; if (med) { for (i = 0; i < numEdges; i++, med++) { - BLI_edgehash_insert(eh, med->v1, med->v2, SET_INT_IN_POINTER(i+1)); + BLI_edgehash_insert(eh, med->v1, med->v2, SET_INT_IN_POINTER(i + 1)); } } @@ -2464,12 +2464,12 @@ void CDDM_calc_edges(DerivedMesh *dm) med = CustomData_get_layer(&edgeData, CD_MEDGE); index = CustomData_get_layer(&edgeData, CD_ORIGINDEX); for (i = 0; !BLI_edgehashIterator_isDone(ehi); - BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) { + BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) { BLI_edgehashIterator_getKey(ehi, &med->v1, &med->v2); j = GET_INT_FROM_POINTER(BLI_edgehashIterator_getValue(ehi)); - med->flag = ME_EDGEDRAW|ME_EDGERENDER; - *index = j==0 ? ORIGINDEX_NONE : eindex[j-1]; + med->flag = ME_EDGEDRAW | ME_EDGERENDER; + *index = j == 0 ? ORIGINDEX_NONE : eindex[j - 1]; BLI_edgehashIterator_setValue(ehi, SET_INT_IN_POINTER(i)); } @@ -2498,7 +2498,7 @@ void CDDM_calc_edges(DerivedMesh *dm) void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts) { if (numVerts < dm->numVertData) - CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData-numVerts); + CustomData_free_elem(&dm->vertData, numVerts, dm->numVertData - numVerts); dm->numVertData = numVerts; } @@ -2506,7 +2506,7 @@ void CDDM_lower_num_verts(DerivedMesh *dm, int numVerts) void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges) { if (numEdges < dm->numEdgeData) - CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData-numEdges); + CustomData_free_elem(&dm->edgeData, numEdges, dm->numEdgeData - numEdges); dm->numEdgeData = numEdges; } @@ -2514,7 +2514,7 @@ void CDDM_lower_num_edges(DerivedMesh *dm, int numEdges) void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces) { if (numTessFaces < dm->numTessFaceData) - CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData-numTessFaces); + CustomData_free_elem(&dm->faceData, numTessFaces, dm->numTessFaceData - numTessFaces); dm->numTessFaceData = numTessFaces; } @@ -2522,7 +2522,7 @@ void CDDM_lower_num_tessfaces(DerivedMesh *dm, int numTessFaces) void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys) { if (numPolys < dm->numPolyData) - CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData-numPolys); + CustomData_free_elem(&dm->polyData, numPolys, dm->numPolyData - numPolys); dm->numPolyData = numPolys; } @@ -2531,60 +2531,60 @@ void CDDM_lower_num_polys(DerivedMesh *dm, int numPolys) MVert *CDDM_get_vert(DerivedMesh *dm, int index) { - return &((CDDerivedMesh*)dm)->mvert[index]; + return &((CDDerivedMesh *)dm)->mvert[index]; } MEdge *CDDM_get_edge(DerivedMesh *dm, int index) { - return &((CDDerivedMesh*)dm)->medge[index]; + return &((CDDerivedMesh *)dm)->medge[index]; } MFace *CDDM_get_tessface(DerivedMesh *dm, int index) { - return &((CDDerivedMesh*)dm)->mface[index]; + return &((CDDerivedMesh *)dm)->mface[index]; } MLoop *CDDM_get_loop(DerivedMesh *dm, int index) { - return &((CDDerivedMesh*)dm)->mloop[index]; + return &((CDDerivedMesh *)dm)->mloop[index]; } MPoly *CDDM_get_poly(DerivedMesh *dm, int index) { - return &((CDDerivedMesh*)dm)->mpoly[index]; + return &((CDDerivedMesh *)dm)->mpoly[index]; } /* array access functions */ MVert *CDDM_get_verts(DerivedMesh *dm) { - return ((CDDerivedMesh*)dm)->mvert; + return ((CDDerivedMesh *)dm)->mvert; } MEdge *CDDM_get_edges(DerivedMesh *dm) { - return ((CDDerivedMesh*)dm)->medge; + return ((CDDerivedMesh *)dm)->medge; } MFace *CDDM_get_tessfaces(DerivedMesh *dm) { - return ((CDDerivedMesh*)dm)->mface; + return ((CDDerivedMesh *)dm)->mface; } MLoop *CDDM_get_loops(DerivedMesh *dm) { - return ((CDDerivedMesh*)dm)->mloop; + return ((CDDerivedMesh *)dm)->mloop; } MPoly *CDDM_get_polys(DerivedMesh *dm) { - return ((CDDerivedMesh*)dm)->mpoly; + return ((CDDerivedMesh *)dm)->mpoly; } void CDDM_tessfaces_to_faces(DerivedMesh *dm) { /*converts mfaces to mpolys/mloops*/ - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; MFace *mf; MEdge *me; EdgeHash *eh = BLI_edgehash_new(); @@ -2628,13 +2628,13 @@ void CDDM_tessfaces_to_faces(DerivedMesh *dm) MPoly *mp; int l, *polyindex; - cddm->mloop = MEM_callocN(sizeof(MLoop)*totloop, "cddm->mloop in CDDM_tessfaces_to_faces"); - cddm->mpoly = MEM_callocN(sizeof(MPoly)*cddm->dm.numTessFaceData, "cddm->mpoly in CDDM_tessfaces_to_faces"); + cddm->mloop = MEM_callocN(sizeof(MLoop) * totloop, "cddm->mloop in CDDM_tessfaces_to_faces"); + cddm->mpoly = MEM_callocN(sizeof(MPoly) * cddm->dm.numTessFaceData, "cddm->mpoly in CDDM_tessfaces_to_faces"); CustomData_add_layer(&cddm->dm.loopData, CD_MLOOP, CD_ASSIGN, cddm->mloop, totloop); CustomData_add_layer(&cddm->dm.polyData, CD_MPOLY, CD_ASSIGN, cddm->mpoly, cddm->dm.numPolyData); CustomData_merge(&cddm->dm.faceData, &cddm->dm.polyData, - CD_MASK_ORIGINDEX, CD_DUPLICATE, cddm->dm.numTessFaceData); + CD_MASK_ORIGINDEX, CD_DUPLICATE, cddm->dm.numTessFaceData); polyindex = CustomData_get_layer(&cddm->dm.faceData, CD_POLYINDEX); @@ -2657,12 +2657,12 @@ void CDDM_tessfaces_to_faces(DerivedMesh *dm) ml++, l++; ml->v = mf->v3; - ml->e = GET_INT_FROM_POINTER(BLI_edgehash_lookup(eh, mf->v3, mf->v4?mf->v4:mf->v1)); + ml->e = GET_INT_FROM_POINTER(BLI_edgehash_lookup(eh, mf->v3, mf->v4 ? mf->v4 : mf->v1)); ml++, l++; if (mf->v4) { ml->v = mf->v4; - ml->e = GET_INT_FROM_POINTER(BLI_edgehash_lookup(eh, mf->v4, mf->v1)); + ml->e = GET_INT_FROM_POINTER(BLI_edgehash_lookup(eh, mf->v4, mf->v1)); ml++, l++; } @@ -2675,7 +2675,7 @@ void CDDM_tessfaces_to_faces(DerivedMesh *dm) void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; if (!CustomData_has_layer(&dm->vertData, CD_MVERT)) CustomData_add_layer(&dm->vertData, CD_MVERT, CD_ASSIGN, mvert, dm->numVertData); @@ -2685,7 +2685,7 @@ void CDDM_set_mvert(DerivedMesh *dm, MVert *mvert) void CDDM_set_medge(DerivedMesh *dm, MEdge *medge) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; if (!CustomData_has_layer(&dm->edgeData, CD_MEDGE)) CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_ASSIGN, medge, dm->numEdgeData); @@ -2695,7 +2695,7 @@ void CDDM_set_medge(DerivedMesh *dm, MEdge *medge) void CDDM_set_mface(DerivedMesh *dm, MFace *mface) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; if (!CustomData_has_layer(&dm->faceData, CD_MFACE)) CustomData_add_layer(&dm->faceData, CD_MFACE, CD_ASSIGN, mface, dm->numTessFaceData); @@ -2705,7 +2705,7 @@ void CDDM_set_mface(DerivedMesh *dm, MFace *mface) void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; if (!CustomData_has_layer(&dm->loopData, CD_MLOOP)) CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_ASSIGN, mloop, dm->numLoopData); @@ -2715,7 +2715,7 @@ void CDDM_set_mloop(DerivedMesh *dm, MLoop *mloop) void CDDM_set_mpoly(DerivedMesh *dm, MPoly *mpoly) { - CDDerivedMesh *cddm = (CDDerivedMesh*)dm; + CDDerivedMesh *cddm = (CDDerivedMesh *)dm; if (!CustomData_has_layer(&dm->polyData, CD_MPOLY)) CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_ASSIGN, mpoly, dm->numPolyData); diff --git a/source/blender/blenkernel/intern/colortools.c b/source/blender/blenkernel/intern/colortools.c index 2955e20c9e2..7ba117861bb 100644 --- a/source/blender/blenkernel/intern/colortools.c +++ b/source/blender/blenkernel/intern/colortools.c @@ -62,9 +62,9 @@ CurveMapping *curvemapping_add(int tot, float minx, float miny, float maxx, floa int a; float clipminx, clipminy, clipmaxx, clipmaxy; - cumap= MEM_callocN(sizeof(CurveMapping), "new curvemap"); - cumap->flag= CUMA_DO_CLIP; - if (tot==4) cumap->cur= 3; /* rhms, hack for 'col' curve? */ + cumap = MEM_callocN(sizeof(CurveMapping), "new curvemap"); + cumap->flag = CUMA_DO_CLIP; + if (tot == 4) cumap->cur = 3; /* rhms, hack for 'col' curve? */ clipminx = MIN2(minx, maxx); clipminy = MIN2(miny, maxy); @@ -72,20 +72,20 @@ CurveMapping *curvemapping_add(int tot, float minx, float miny, float maxx, floa clipmaxy = MAX2(miny, maxy); BLI_init_rctf(&cumap->curr, clipminx, clipmaxx, clipminy, clipmaxy); - cumap->clipr= cumap->curr; + cumap->clipr = cumap->curr; - cumap->white[0]= cumap->white[1]= cumap->white[2]= 1.0f; - cumap->bwmul[0]= cumap->bwmul[1]= cumap->bwmul[2]= 1.0f; + cumap->white[0] = cumap->white[1] = cumap->white[2] = 1.0f; + cumap->bwmul[0] = cumap->bwmul[1] = cumap->bwmul[2] = 1.0f; - for (a=0; acm[a].flag= CUMA_EXTEND_EXTRAPOLATE; - cumap->cm[a].totpoint= 2; - cumap->cm[a].curve= MEM_callocN(2*sizeof(CurveMapPoint), "curve points"); - - cumap->cm[a].curve[0].x= minx; - cumap->cm[a].curve[0].y= miny; - cumap->cm[a].curve[1].x= maxx; - cumap->cm[a].curve[1].y= maxy; + for (a = 0; a < tot; a++) { + cumap->cm[a].flag = CUMA_EXTEND_EXTRAPOLATE; + cumap->cm[a].totpoint = 2; + cumap->cm[a].curve = MEM_callocN(2 * sizeof(CurveMapPoint), "curve points"); + + cumap->cm[a].curve[0].x = minx; + cumap->cm[a].curve[0].y = miny; + cumap->cm[a].curve[1].x = maxx; + cumap->cm[a].curve[1].y = maxy; } cumap->changed_timestamp = 0; @@ -98,7 +98,7 @@ void curvemapping_free(CurveMapping *cumap) int a; if (cumap) { - for (a=0; acm[a].curve) MEM_freeN(cumap->cm[a].curve); if (cumap->cm[a].table) MEM_freeN(cumap->cm[a].table); if (cumap->cm[a].premultable) MEM_freeN(cumap->cm[a].premultable); @@ -112,14 +112,14 @@ CurveMapping *curvemapping_copy(CurveMapping *cumap) int a; if (cumap) { - CurveMapping *cumapn= MEM_dupallocN(cumap); - for (a=0; acm[a].curve) - cumapn->cm[a].curve= MEM_dupallocN(cumap->cm[a].curve); + cumapn->cm[a].curve = MEM_dupallocN(cumap->cm[a].curve); if (cumap->cm[a].table) - cumapn->cm[a].table= MEM_dupallocN(cumap->cm[a].table); + cumapn->cm[a].table = MEM_dupallocN(cumap->cm[a].table); if (cumap->cm[a].premultable) - cumapn->cm[a].premultable= MEM_dupallocN(cumap->cm[a].premultable); + cumapn->cm[a].premultable = MEM_dupallocN(cumap->cm[a].premultable); } return cumapn; } @@ -135,11 +135,11 @@ void curvemapping_set_black_white(CurveMapping *cumap, const float black[3], con if (black) copy_v3_v3(cumap->black, black); - for (a=0; a<3; a++) { - if (cumap->white[a]==cumap->black[a]) - cumap->bwmul[a]= 0.0f; + for (a = 0; a < 3; a++) { + if (cumap->white[a] == cumap->black[a]) + cumap->bwmul[a] = 0.0f; else - cumap->bwmul[a]= 1.0f/(cumap->white[a] - cumap->black[a]); + cumap->bwmul[a] = 1.0f / (cumap->white[a] - cumap->black[a]); } } @@ -149,52 +149,52 @@ void curvemapping_set_black_white(CurveMapping *cumap, const float black[3], con /* removes with flag set */ void curvemap_remove(CurveMap *cuma, int flag) { - CurveMapPoint *cmp= MEM_mallocN((cuma->totpoint)*sizeof(CurveMapPoint), "curve points"); - int a, b, removed=0; + CurveMapPoint *cmp = MEM_mallocN((cuma->totpoint) * sizeof(CurveMapPoint), "curve points"); + int a, b, removed = 0; /* well, lets keep the two outer points! */ - cmp[0]= cuma->curve[0]; - for (a=1, b=1; atotpoint-1; a++) { + cmp[0] = cuma->curve[0]; + for (a = 1, b = 1; a < cuma->totpoint - 1; a++) { if (!(cuma->curve[a].flag & flag)) { - cmp[b]= cuma->curve[a]; + cmp[b] = cuma->curve[a]; b++; } else removed++; } - cmp[b]= cuma->curve[a]; + cmp[b] = cuma->curve[a]; MEM_freeN(cuma->curve); - cuma->curve= cmp; + cuma->curve = cmp; cuma->totpoint -= removed; } void curvemap_insert(CurveMap *cuma, float x, float y) { - CurveMapPoint *cmp= MEM_callocN((cuma->totpoint+1)*sizeof(CurveMapPoint), "curve points"); - int a, b, foundloc= 0; + CurveMapPoint *cmp = MEM_callocN((cuma->totpoint + 1) * sizeof(CurveMapPoint), "curve points"); + int a, b, foundloc = 0; /* insert fragments of the old one and the new point to the new curve */ cuma->totpoint++; - for (a=0, b=0; atotpoint; a++) { + for (a = 0, b = 0; a < cuma->totpoint; a++) { if ((x < cuma->curve[a].x) && !foundloc) { - cmp[a].x= x; - cmp[a].y= y; - cmp[a].flag= CUMA_SELECT; - foundloc= 1; + cmp[a].x = x; + cmp[a].y = y; + cmp[a].flag = CUMA_SELECT; + foundloc = 1; } else { - cmp[a].x= cuma->curve[b].x; - cmp[a].y= cuma->curve[b].y; - cmp[a].flag= cuma->curve[b].flag; + cmp[a].x = cuma->curve[b].x; + cmp[a].y = cuma->curve[b].y; + cmp[a].flag = cuma->curve[b].flag; cmp[a].flag &= ~CUMA_SELECT; /* make sure old points don't remain selected */ - cmp[a].shorty= cuma->curve[b].shorty; + cmp[a].shorty = cuma->curve[b].shorty; b++; } } /* free old curve and replace it with new one */ MEM_freeN(cuma->curve); - cuma->curve= cmp; + cuma->curve = cmp; } void curvemap_reset(CurveMap *cuma, rctf *clipr, int preset, int slope) @@ -203,91 +203,91 @@ void curvemap_reset(CurveMap *cuma, rctf *clipr, int preset, int slope) MEM_freeN(cuma->curve); switch (preset) { - case CURVE_PRESET_LINE: cuma->totpoint= 2; break; - case CURVE_PRESET_SHARP: cuma->totpoint= 4; break; - case CURVE_PRESET_SMOOTH: cuma->totpoint= 4; break; - case CURVE_PRESET_MAX: cuma->totpoint= 2; break; - case CURVE_PRESET_MID9: cuma->totpoint= 9; break; - case CURVE_PRESET_ROUND: cuma->totpoint= 4; break; - case CURVE_PRESET_ROOT: cuma->totpoint= 4; break; + case CURVE_PRESET_LINE: cuma->totpoint = 2; break; + case CURVE_PRESET_SHARP: cuma->totpoint = 4; break; + case CURVE_PRESET_SMOOTH: cuma->totpoint = 4; break; + case CURVE_PRESET_MAX: cuma->totpoint = 2; break; + case CURVE_PRESET_MID9: cuma->totpoint = 9; break; + case CURVE_PRESET_ROUND: cuma->totpoint = 4; break; + case CURVE_PRESET_ROOT: cuma->totpoint = 4; break; } - cuma->curve= MEM_callocN(cuma->totpoint*sizeof(CurveMapPoint), "curve points"); + cuma->curve = MEM_callocN(cuma->totpoint * sizeof(CurveMapPoint), "curve points"); switch (preset) { case CURVE_PRESET_LINE: - cuma->curve[0].x= clipr->xmin; - cuma->curve[0].y= clipr->ymax; - cuma->curve[0].flag= 0; - cuma->curve[1].x= clipr->xmax; - cuma->curve[1].y= clipr->ymin; - cuma->curve[1].flag= 0; + cuma->curve[0].x = clipr->xmin; + cuma->curve[0].y = clipr->ymax; + cuma->curve[0].flag = 0; + cuma->curve[1].x = clipr->xmax; + cuma->curve[1].y = clipr->ymin; + cuma->curve[1].flag = 0; break; case CURVE_PRESET_SHARP: - cuma->curve[0].x= 0; - cuma->curve[0].y= 1; - cuma->curve[1].x= 0.25; - cuma->curve[1].y= 0.50; - cuma->curve[2].x= 0.75; - cuma->curve[2].y= 0.04; - cuma->curve[3].x= 1; - cuma->curve[3].y= 0; + cuma->curve[0].x = 0; + cuma->curve[0].y = 1; + cuma->curve[1].x = 0.25; + cuma->curve[1].y = 0.50; + cuma->curve[2].x = 0.75; + cuma->curve[2].y = 0.04; + cuma->curve[3].x = 1; + cuma->curve[3].y = 0; break; case CURVE_PRESET_SMOOTH: - cuma->curve[0].x= 0; - cuma->curve[0].y= 1; - cuma->curve[1].x= 0.25; - cuma->curve[1].y= 0.94; - cuma->curve[2].x= 0.75; - cuma->curve[2].y= 0.06; - cuma->curve[3].x= 1; - cuma->curve[3].y= 0; + cuma->curve[0].x = 0; + cuma->curve[0].y = 1; + cuma->curve[1].x = 0.25; + cuma->curve[1].y = 0.94; + cuma->curve[2].x = 0.75; + cuma->curve[2].y = 0.06; + cuma->curve[3].x = 1; + cuma->curve[3].y = 0; break; case CURVE_PRESET_MAX: - cuma->curve[0].x= 0; - cuma->curve[0].y= 1; - cuma->curve[1].x= 1; - cuma->curve[1].y= 1; + cuma->curve[0].x = 0; + cuma->curve[0].y = 1; + cuma->curve[1].x = 1; + cuma->curve[1].y = 1; break; case CURVE_PRESET_MID9: - { - int i; - for (i = 0; i < cuma->totpoint; i++) { - cuma->curve[i].x = i / ((float)cuma->totpoint - 1); - cuma->curve[i].y = 0.5; - } + { + int i; + for (i = 0; i < cuma->totpoint; i++) { + cuma->curve[i].x = i / ((float)cuma->totpoint - 1); + cuma->curve[i].y = 0.5; } - break; + } + break; case CURVE_PRESET_ROUND: - cuma->curve[0].x= 0; - cuma->curve[0].y= 1; - cuma->curve[1].x= 0.5; - cuma->curve[1].y= 0.90; - cuma->curve[2].x= 0.86; - cuma->curve[2].y= 0.5; - cuma->curve[3].x= 1; - cuma->curve[3].y= 0; + cuma->curve[0].x = 0; + cuma->curve[0].y = 1; + cuma->curve[1].x = 0.5; + cuma->curve[1].y = 0.90; + cuma->curve[2].x = 0.86; + cuma->curve[2].y = 0.5; + cuma->curve[3].x = 1; + cuma->curve[3].y = 0; break; case CURVE_PRESET_ROOT: - cuma->curve[0].x= 0; - cuma->curve[0].y= 1; - cuma->curve[1].x= 0.25; - cuma->curve[1].y= 0.95; - cuma->curve[2].x= 0.75; - cuma->curve[2].y= 0.44; - cuma->curve[3].x= 1; - cuma->curve[3].y= 0; + cuma->curve[0].x = 0; + cuma->curve[0].y = 1; + cuma->curve[1].x = 0.25; + cuma->curve[1].y = 0.95; + cuma->curve[2].x = 0.75; + cuma->curve[2].y = 0.44; + cuma->curve[3].x = 1; + cuma->curve[3].y = 0; break; } /* mirror curve in x direction to have positive slope * rather than default negative slope */ if (slope == CURVEMAP_SLOPE_POSITIVE) { - int i, last=cuma->totpoint-1; - CurveMapPoint *newpoints= MEM_dupallocN(cuma->curve); + int i, last = cuma->totpoint - 1; + CurveMapPoint *newpoints = MEM_dupallocN(cuma->curve); - for (i=0; itotpoint; i++) { - newpoints[i].y = cuma->curve[last-i].y; + for (i = 0; i < cuma->totpoint; i++) { + newpoints[i].y = cuma->curve[last - i].y; } MEM_freeN(cuma->curve); @@ -296,7 +296,7 @@ void curvemap_reset(CurveMap *cuma, rctf *clipr, int preset, int slope) if (cuma->table) { MEM_freeN(cuma->table); - cuma->table= NULL; + cuma->table = NULL; } } @@ -305,7 +305,7 @@ void curvemap_sethandle(CurveMap *cuma, int type) { int a; - for (a=0; atotpoint; a++) { + for (a = 0; a < cuma->totpoint; a++) { if (cuma->curve[a].flag & CUMA_SELECT) { if (type) cuma->curve[a].flag |= CUMA_VECTOR; else cuma->curve[a].flag &= ~CUMA_VECTOR; @@ -322,65 +322,65 @@ static void calchandle_curvemap(BezTriple *bezt, BezTriple *prev, BezTriple *nex float len, len_a, len_b; float dvec_a[2], dvec_b[2]; - if (bezt->h1==0 && bezt->h2==0) { + if (bezt->h1 == 0 && bezt->h2 == 0) { return; } - p2= bezt->vec[1]; + p2 = bezt->vec[1]; - if (prev==NULL) { - p3= next->vec[1]; - pt[0]= 2.0f*p2[0] - p3[0]; - pt[1]= 2.0f*p2[1] - p3[1]; - p1= pt; + if (prev == NULL) { + p3 = next->vec[1]; + pt[0] = 2.0f * p2[0] - p3[0]; + pt[1] = 2.0f * p2[1] - p3[1]; + p1 = pt; } else { - p1= prev->vec[1]; + p1 = prev->vec[1]; } - if (next==NULL) { - p1= prev->vec[1]; - pt[0]= 2.0f*p2[0] - p1[0]; - pt[1]= 2.0f*p2[1] - p1[1]; - p3= pt; + if (next == NULL) { + p1 = prev->vec[1]; + pt[0] = 2.0f * p2[0] - p1[0]; + pt[1] = 2.0f * p2[1] - p1[1]; + p3 = pt; } else { - p3= next->vec[1]; + p3 = next->vec[1]; } sub_v2_v2v2(dvec_a, p2, p1); sub_v2_v2v2(dvec_b, p3, p2); - len_a= len_v2(dvec_a); - len_b= len_v2(dvec_b); + len_a = len_v2(dvec_a); + len_b = len_v2(dvec_b); - if (len_a==0.0f) len_a=1.0f; - if (len_b==0.0f) len_b=1.0f; + if (len_a == 0.0f) len_a = 1.0f; + if (len_b == 0.0f) len_b = 1.0f; - if (bezt->h1==HD_AUTO || bezt->h2==HD_AUTO) { /* auto */ + if (bezt->h1 == HD_AUTO || bezt->h2 == HD_AUTO) { /* auto */ float tvec[2]; - tvec[0]= dvec_b[0]/len_b + dvec_a[0]/len_a; - tvec[1]= dvec_b[1]/len_b + dvec_a[1]/len_a; + tvec[0] = dvec_b[0] / len_b + dvec_a[0] / len_a; + tvec[1] = dvec_b[1] / len_b + dvec_a[1] / len_a; - len= len_v2(tvec) * 2.5614f; - if (len!=0.0f) { + len = len_v2(tvec) * 2.5614f; + if (len != 0.0f) { - if (bezt->h1==HD_AUTO) { - len_a/=len; - madd_v2_v2v2fl(p2-3, p2, tvec, -len_a); + if (bezt->h1 == HD_AUTO) { + len_a /= len; + madd_v2_v2v2fl(p2 - 3, p2, tvec, -len_a); } - if (bezt->h2==HD_AUTO) { - len_b/=len; - madd_v2_v2v2fl(p2+3, p2, tvec, len_b); + if (bezt->h2 == HD_AUTO) { + len_b /= len; + madd_v2_v2v2fl(p2 + 3, p2, tvec, len_b); } } } - if (bezt->h1==HD_VECT) { /* vector */ - madd_v2_v2v2fl(p2-3, p2, dvec_a, -1.0f/3.0f); + if (bezt->h1 == HD_VECT) { /* vector */ + madd_v2_v2v2fl(p2 - 3, p2, dvec_a, -1.0f / 3.0f); } - if (bezt->h2==HD_VECT) { - madd_v2_v2v2fl(p2+3, p2, dvec_b, 1.0f/3.0f); + if (bezt->h2 == HD_VECT) { + madd_v2_v2v2fl(p2 + 3, p2, dvec_b, 1.0f / 3.0f); } } @@ -389,27 +389,27 @@ static void calchandle_curvemap(BezTriple *bezt, BezTriple *prev, BezTriple *nex static float curvemap_calc_extend(CurveMap *cuma, float x, const float first[2], const float last[2]) { if (x <= first[0]) { - if ((cuma->flag & CUMA_EXTEND_EXTRAPOLATE)==0) { + if ((cuma->flag & CUMA_EXTEND_EXTRAPOLATE) == 0) { /* no extrapolate */ return first[1]; } else { - if (cuma->ext_in[0]==0.0f) - return first[1] + cuma->ext_in[1]*10000.0f; + if (cuma->ext_in[0] == 0.0f) + return first[1] + cuma->ext_in[1] * 10000.0f; else - return first[1] + cuma->ext_in[1]*(x - first[0])/cuma->ext_in[0]; + return first[1] + cuma->ext_in[1] * (x - first[0]) / cuma->ext_in[0]; } } else if (x >= last[0]) { - if ((cuma->flag & CUMA_EXTEND_EXTRAPOLATE)==0) { + if ((cuma->flag & CUMA_EXTEND_EXTRAPOLATE) == 0) { /* no extrapolate */ return last[1]; } else { - if (cuma->ext_out[0]==0.0f) - return last[1] - cuma->ext_out[1]*10000.0f; + if (cuma->ext_out[0] == 0.0f) + return last[1] - cuma->ext_out[1] * 10000.0f; else - return last[1] + cuma->ext_out[1]*(x - last[0])/cuma->ext_out[0]; + return last[1] + cuma->ext_out[1] * (x - last[0]) / cuma->ext_out[0]; } } return 0.0f; @@ -418,74 +418,74 @@ static float curvemap_calc_extend(CurveMap *cuma, float x, const float first[2], /* only creates a table for a single channel in CurveMapping */ static void curvemap_make_table(CurveMap *cuma, rctf *clipr) { - CurveMapPoint *cmp= cuma->curve; + CurveMapPoint *cmp = cuma->curve; BezTriple *bezt; float *fp, *allpoints, *lastpoint, curf, range; int a, totpoint; - if (cuma->curve==NULL) return; + if (cuma->curve == NULL) return; /* default rect also is table range */ - cuma->mintable= clipr->xmin; - cuma->maxtable= clipr->xmax; + cuma->mintable = clipr->xmin; + cuma->maxtable = clipr->xmax; /* hrmf... we now rely on blender ipo beziers, these are more advanced */ - bezt= MEM_callocN(cuma->totpoint*sizeof(BezTriple), "beztarr"); + bezt = MEM_callocN(cuma->totpoint * sizeof(BezTriple), "beztarr"); - for (a=0; atotpoint; a++) { - cuma->mintable= MIN2(cuma->mintable, cmp[a].x); - cuma->maxtable= MAX2(cuma->maxtable, cmp[a].x); - bezt[a].vec[1][0]= cmp[a].x; - bezt[a].vec[1][1]= cmp[a].y; + for (a = 0; a < cuma->totpoint; a++) { + cuma->mintable = MIN2(cuma->mintable, cmp[a].x); + cuma->maxtable = MAX2(cuma->maxtable, cmp[a].x); + bezt[a].vec[1][0] = cmp[a].x; + bezt[a].vec[1][1] = cmp[a].y; if (cmp[a].flag & CUMA_VECTOR) - bezt[a].h1= bezt[a].h2= HD_VECT; + bezt[a].h1 = bezt[a].h2 = HD_VECT; else - bezt[a].h1= bezt[a].h2= HD_AUTO; + bezt[a].h1 = bezt[a].h2 = HD_AUTO; } - for (a=0; atotpoint; a++) { - if (a==0) - calchandle_curvemap(bezt, NULL, bezt+1, 0); - else if (a==cuma->totpoint-1) - calchandle_curvemap(bezt+a, bezt+a-1, NULL, 0); + for (a = 0; a < cuma->totpoint; a++) { + if (a == 0) + calchandle_curvemap(bezt, NULL, bezt + 1, 0); + else if (a == cuma->totpoint - 1) + calchandle_curvemap(bezt + a, bezt + a - 1, NULL, 0); else - calchandle_curvemap(bezt+a, bezt+a-1, bezt+a+1, 0); + calchandle_curvemap(bezt + a, bezt + a - 1, bezt + a + 1, 0); } /* first and last handle need correction, instead of pointing to center of next/prev, * we let it point to the closest handle */ - if (cuma->totpoint>2) { + if (cuma->totpoint > 2) { float hlen, nlen, vec[3]; - if (bezt[0].h2==HD_AUTO) { + if (bezt[0].h2 == HD_AUTO) { - hlen= len_v3v3(bezt[0].vec[1], bezt[0].vec[2]); /* original handle length */ + hlen = len_v3v3(bezt[0].vec[1], bezt[0].vec[2]); /* original handle length */ /* clip handle point */ copy_v3_v3(vec, bezt[1].vec[0]); if (vec[0] < bezt[0].vec[1][0]) - vec[0]= bezt[0].vec[1][0]; + vec[0] = bezt[0].vec[1][0]; sub_v3_v3(vec, bezt[0].vec[1]); - nlen= len_v3(vec); - if (nlen>FLT_EPSILON) { - mul_v3_fl(vec, hlen/nlen); + nlen = len_v3(vec); + if (nlen > FLT_EPSILON) { + mul_v3_fl(vec, hlen / nlen); add_v3_v3v3(bezt[0].vec[2], vec, bezt[0].vec[1]); sub_v3_v3v3(bezt[0].vec[0], bezt[0].vec[1], vec); } } - a= cuma->totpoint-1; - if (bezt[a].h2==HD_AUTO) { + a = cuma->totpoint - 1; + if (bezt[a].h2 == HD_AUTO) { - hlen= len_v3v3(bezt[a].vec[1], bezt[a].vec[0]); /* original handle length */ + hlen = len_v3v3(bezt[a].vec[1], bezt[a].vec[0]); /* original handle length */ /* clip handle point */ - copy_v3_v3(vec, bezt[a-1].vec[2]); + copy_v3_v3(vec, bezt[a - 1].vec[2]); if (vec[0] > bezt[a].vec[1][0]) - vec[0]= bezt[a].vec[1][0]; + vec[0] = bezt[a].vec[1][0]; sub_v3_v3(vec, bezt[a].vec[1]); - nlen= len_v3(vec); - if (nlen>FLT_EPSILON) { - mul_v3_fl(vec, hlen/nlen); + nlen = len_v3(vec); + if (nlen > FLT_EPSILON) { + mul_v3_fl(vec, hlen / nlen); add_v3_v3v3(bezt[a].vec[0], vec, bezt[a].vec[1]); sub_v3_v3v3(bezt[a].vec[2], bezt[a].vec[1], vec); } @@ -494,63 +494,63 @@ static void curvemap_make_table(CurveMap *cuma, rctf *clipr) /* make the bezier curve */ if (cuma->table) MEM_freeN(cuma->table); - totpoint= (cuma->totpoint-1)*CM_RESOL; - fp= allpoints= MEM_callocN(totpoint*2*sizeof(float), "table"); + totpoint = (cuma->totpoint - 1) * CM_RESOL; + fp = allpoints = MEM_callocN(totpoint * 2 * sizeof(float), "table"); - for (a=0; atotpoint-1; a++, fp += 2*CM_RESOL) { - correct_bezpart(bezt[a].vec[1], bezt[a].vec[2], bezt[a+1].vec[0], bezt[a+1].vec[1]); - BKE_curve_forward_diff_bezier(bezt[a].vec[1][0], bezt[a].vec[2][0], bezt[a+1].vec[0][0], bezt[a+1].vec[1][0], fp, CM_RESOL-1, 2*sizeof(float)); - BKE_curve_forward_diff_bezier(bezt[a].vec[1][1], bezt[a].vec[2][1], bezt[a+1].vec[0][1], bezt[a+1].vec[1][1], fp+1, CM_RESOL-1, 2*sizeof(float)); + for (a = 0; a < cuma->totpoint - 1; a++, fp += 2 * CM_RESOL) { + correct_bezpart(bezt[a].vec[1], bezt[a].vec[2], bezt[a + 1].vec[0], bezt[a + 1].vec[1]); + BKE_curve_forward_diff_bezier(bezt[a].vec[1][0], bezt[a].vec[2][0], bezt[a + 1].vec[0][0], bezt[a + 1].vec[1][0], fp, CM_RESOL - 1, 2 * sizeof(float)); + BKE_curve_forward_diff_bezier(bezt[a].vec[1][1], bezt[a].vec[2][1], bezt[a + 1].vec[0][1], bezt[a + 1].vec[1][1], fp + 1, CM_RESOL - 1, 2 * sizeof(float)); } /* store first and last handle for extrapolation, unit length */ - cuma->ext_in[0]= bezt[0].vec[0][0] - bezt[0].vec[1][0]; - cuma->ext_in[1]= bezt[0].vec[0][1] - bezt[0].vec[1][1]; - range= sqrt(cuma->ext_in[0]*cuma->ext_in[0] + cuma->ext_in[1]*cuma->ext_in[1]); - cuma->ext_in[0]/= range; - cuma->ext_in[1]/= range; - - a= cuma->totpoint-1; - cuma->ext_out[0]= bezt[a].vec[1][0] - bezt[a].vec[2][0]; - cuma->ext_out[1]= bezt[a].vec[1][1] - bezt[a].vec[2][1]; - range= sqrt(cuma->ext_out[0]*cuma->ext_out[0] + cuma->ext_out[1]*cuma->ext_out[1]); - cuma->ext_out[0]/= range; - cuma->ext_out[1]/= range; + cuma->ext_in[0] = bezt[0].vec[0][0] - bezt[0].vec[1][0]; + cuma->ext_in[1] = bezt[0].vec[0][1] - bezt[0].vec[1][1]; + range = sqrt(cuma->ext_in[0] * cuma->ext_in[0] + cuma->ext_in[1] * cuma->ext_in[1]); + cuma->ext_in[0] /= range; + cuma->ext_in[1] /= range; + + a = cuma->totpoint - 1; + cuma->ext_out[0] = bezt[a].vec[1][0] - bezt[a].vec[2][0]; + cuma->ext_out[1] = bezt[a].vec[1][1] - bezt[a].vec[2][1]; + range = sqrt(cuma->ext_out[0] * cuma->ext_out[0] + cuma->ext_out[1] * cuma->ext_out[1]); + cuma->ext_out[0] /= range; + cuma->ext_out[1] /= range; /* cleanup */ MEM_freeN(bezt); - range= CM_TABLEDIV*(cuma->maxtable - cuma->mintable); - cuma->range= 1.0f/range; + range = CM_TABLEDIV * (cuma->maxtable - cuma->mintable); + cuma->range = 1.0f / range; /* now make a table with CM_TABLE equal x distances */ - fp= allpoints; - lastpoint= allpoints + 2*(totpoint-1); - cmp= MEM_callocN((CM_TABLE+1)*sizeof(CurveMapPoint), "dist table"); - - for (a=0; a<=CM_TABLE; a++) { - curf= cuma->mintable + range*(float)a; - cmp[a].x= curf; + fp = allpoints; + lastpoint = allpoints + 2 * (totpoint - 1); + cmp = MEM_callocN((CM_TABLE + 1) * sizeof(CurveMapPoint), "dist table"); + + for (a = 0; a <= CM_TABLE; a++) { + curf = cuma->mintable + range * (float)a; + cmp[a].x = curf; /* get the first x coordinate larger than curf */ - while (curf >= fp[0] && fp!=lastpoint) { - fp+=2; + while (curf >= fp[0] && fp != lastpoint) { + fp += 2; } - if (fp==allpoints || (curf >= fp[0] && fp==lastpoint)) - cmp[a].y= curvemap_calc_extend(cuma, curf, allpoints, lastpoint); + if (fp == allpoints || (curf >= fp[0] && fp == lastpoint)) + cmp[a].y = curvemap_calc_extend(cuma, curf, allpoints, lastpoint); else { - float fac1= fp[0] - fp[-2]; - float fac2= fp[0] - curf; + float fac1 = fp[0] - fp[-2]; + float fac2 = fp[0] - curf; if (fac1 > FLT_EPSILON) - fac1= fac2/fac1; + fac1 = fac2 / fac1; else - fac1= 0.0f; - cmp[a].y= fac1*fp[-1] + (1.0f-fac1)*fp[1]; + fac1 = 0.0f; + cmp[a].y = fac1 * fp[-1] + (1.0f - fac1) * fp[1]; } } MEM_freeN(allpoints); - cuma->table= cmp; + cuma->table = cmp; } /* call when you do images etc, needs restore too. also verifies tables */ @@ -561,34 +561,34 @@ void curvemapping_premultiply(CurveMapping *cumap, int restore) if (restore) { if (cumap->flag & CUMA_PREMULLED) { - for (a=0; a<3; a++) { + for (a = 0; a < 3; a++) { MEM_freeN(cumap->cm[a].table); - cumap->cm[a].table= cumap->cm[a].premultable; - cumap->cm[a].premultable= NULL; + cumap->cm[a].table = cumap->cm[a].premultable; + cumap->cm[a].premultable = NULL; } cumap->flag &= ~CUMA_PREMULLED; } } else { - if ((cumap->flag & CUMA_PREMULLED)==0) { + if ((cumap->flag & CUMA_PREMULLED) == 0) { /* verify and copy */ - for (a=0; a<3; a++) { - if (cumap->cm[a].table==NULL) - curvemap_make_table(cumap->cm+a, &cumap->clipr); - cumap->cm[a].premultable= cumap->cm[a].table; - cumap->cm[a].table= MEM_mallocN((CM_TABLE+1)*sizeof(CurveMapPoint), "premul table"); - memcpy(cumap->cm[a].table, cumap->cm[a].premultable, (CM_TABLE+1)*sizeof(CurveMapPoint)); + for (a = 0; a < 3; a++) { + if (cumap->cm[a].table == NULL) + curvemap_make_table(cumap->cm + a, &cumap->clipr); + cumap->cm[a].premultable = cumap->cm[a].table; + cumap->cm[a].table = MEM_mallocN((CM_TABLE + 1) * sizeof(CurveMapPoint), "premul table"); + memcpy(cumap->cm[a].table, cumap->cm[a].premultable, (CM_TABLE + 1) * sizeof(CurveMapPoint)); } - if (cumap->cm[3].table==NULL) - curvemap_make_table(cumap->cm+3, &cumap->clipr); + if (cumap->cm[3].table == NULL) + curvemap_make_table(cumap->cm + 3, &cumap->clipr); /* premul */ - for (a=0; a<3; a++) { + for (a = 0; a < 3; a++) { int b; - for (b=0; b<=CM_TABLE; b++) { - cumap->cm[a].table[b].y= curvemap_evaluateF(cumap->cm+3, cumap->cm[a].table[b].y); + for (b = 0; b <= CM_TABLE; b++) { + cumap->cm[a].table[b].y = curvemap_evaluateF(cumap->cm + 3, cumap->cm[a].table[b].y); } } @@ -599,10 +599,10 @@ void curvemapping_premultiply(CurveMapping *cumap, int restore) static int sort_curvepoints(const void *a1, const void *a2) { - const struct CurveMapPoint *x1=a1, *x2=a2; + const struct CurveMapPoint *x1 = a1, *x2 = a2; - if ( x1->x > x2->x ) return 1; - else if ( x1->x < x2->x) return -1; + if (x1->x > x2->x) return 1; + else if (x1->x < x2->x) return -1; return 0; } @@ -611,30 +611,30 @@ static int sort_curvepoints(const void *a1, const void *a2) /* note; only does current curvemap! */ void curvemapping_changed(CurveMapping *cumap, int rem_doubles) { - CurveMap *cuma= cumap->cm+cumap->cur; - CurveMapPoint *cmp= cuma->curve; - rctf *clipr= &cumap->clipr; - float thresh= 0.01f*(clipr->xmax - clipr->xmin); - float dx= 0.0f, dy= 0.0f; + CurveMap *cuma = cumap->cm + cumap->cur; + CurveMapPoint *cmp = cuma->curve; + rctf *clipr = &cumap->clipr; + float thresh = 0.01f * (clipr->xmax - clipr->xmin); + float dx = 0.0f, dy = 0.0f; int a; cumap->changed_timestamp++; /* clamp with clip */ if (cumap->flag & CUMA_DO_CLIP) { - for (a=0; atotpoint; a++) { + for (a = 0; a < cuma->totpoint; a++) { if (cmp[a].flag & CUMA_SELECT) { if (cmp[a].x < clipr->xmin) - dx= MIN2(dx, cmp[a].x - clipr->xmin); + dx = MIN2(dx, cmp[a].x - clipr->xmin); else if (cmp[a].x > clipr->xmax) - dx= MAX2(dx, cmp[a].x - clipr->xmax); + dx = MAX2(dx, cmp[a].x - clipr->xmax); if (cmp[a].y < clipr->ymin) - dy= MIN2(dy, cmp[a].y - clipr->ymin); + dy = MIN2(dy, cmp[a].y - clipr->ymin); else if (cmp[a].y > clipr->ymax) - dy= MAX2(dy, cmp[a].y - clipr->ymax); + dy = MAX2(dy, cmp[a].y - clipr->ymax); } } - for (a=0; atotpoint; a++) { + for (a = 0; a < cuma->totpoint; a++) { if (cmp[a].flag & CUMA_SELECT) { cmp[a].x -= dx; cmp[a].y -= dy; @@ -646,25 +646,25 @@ void curvemapping_changed(CurveMapping *cumap, int rem_doubles) qsort(cmp, cuma->totpoint, sizeof(CurveMapPoint), sort_curvepoints); /* remove doubles, threshold set on 1% of default range */ - if (rem_doubles && cuma->totpoint>2) { - for (a=0; atotpoint-1; a++) { - dx= cmp[a].x - cmp[a+1].x; - dy= cmp[a].y - cmp[a+1].y; - if ( sqrtf(dx*dx + dy*dy) < thresh ) { - if (a==0) { - cmp[a+1].flag|= 2; - if (cmp[a+1].flag & CUMA_SELECT) + if (rem_doubles && cuma->totpoint > 2) { + for (a = 0; a < cuma->totpoint - 1; a++) { + dx = cmp[a].x - cmp[a + 1].x; + dy = cmp[a].y - cmp[a + 1].y; + if (sqrtf(dx * dx + dy * dy) < thresh) { + if (a == 0) { + cmp[a + 1].flag |= 2; + if (cmp[a + 1].flag & CUMA_SELECT) cmp[a].flag |= CUMA_SELECT; } else { - cmp[a].flag|= 2; + cmp[a].flag |= 2; if (cmp[a].flag & CUMA_SELECT) - cmp[a+1].flag |= CUMA_SELECT; + cmp[a + 1].flag |= CUMA_SELECT; } - break; /* we assume 1 deletion per edit is ok */ + break; /* we assume 1 deletion per edit is ok */ } } - if (a != cuma->totpoint-1) + if (a != cuma->totpoint - 1) curvemap_remove(cuma, 2); } curvemap_make_table(cuma, clipr); @@ -677,31 +677,31 @@ float curvemap_evaluateF(CurveMap *cuma, float value) int i; /* index in table */ - fi= (value-cuma->mintable)*cuma->range; - i= (int)fi; + fi = (value - cuma->mintable) * cuma->range; + i = (int)fi; /* fi is table float index and should check against table range i.e. [0.0 CM_TABLE] */ - if (fi<0.0f || fi>CM_TABLE) + if (fi < 0.0f || fi > CM_TABLE) return curvemap_calc_extend(cuma, value, &cuma->table[0].x, &cuma->table[CM_TABLE].x); else { - if (i<0) return cuma->table[0].y; - if (i>=CM_TABLE) return cuma->table[CM_TABLE].y; + if (i < 0) return cuma->table[0].y; + if (i >= CM_TABLE) return cuma->table[CM_TABLE].y; - fi= fi-(float)i; - return (1.0f-fi)*cuma->table[i].y + (fi)*cuma->table[i+1].y; + fi = fi - (float)i; + return (1.0f - fi) * cuma->table[i].y + (fi) * cuma->table[i + 1].y; } } /* works with curve 'cur' */ float curvemapping_evaluateF(CurveMapping *cumap, int cur, float value) { - CurveMap *cuma= cumap->cm+cur; + CurveMap *cuma = cumap->cm + cur; /* allocate or bail out */ - if (cuma->table==NULL) { + if (cuma->table == NULL) { curvemap_make_table(cuma, &cumap->clipr); - if (cuma->table==NULL) - return 1.0f-value; + if (cuma->table == NULL) + return 1.0f - value; } return curvemap_evaluateF(cuma, value); } @@ -709,17 +709,17 @@ float curvemapping_evaluateF(CurveMapping *cumap, int cur, float value) /* vector case */ void curvemapping_evaluate3F(CurveMapping *cumap, float vecout[3], const float vecin[3]) { - vecout[0]= curvemapping_evaluateF(cumap, 0, vecin[0]); - vecout[1]= curvemapping_evaluateF(cumap, 1, vecin[1]); - vecout[2]= curvemapping_evaluateF(cumap, 2, vecin[2]); + vecout[0] = curvemapping_evaluateF(cumap, 0, vecin[0]); + vecout[1] = curvemapping_evaluateF(cumap, 1, vecin[1]); + vecout[2] = curvemapping_evaluateF(cumap, 2, vecin[2]); } /* RGB case, no black/white points, no premult */ void curvemapping_evaluateRGBF(CurveMapping *cumap, float vecout[3], const float vecin[3]) { - vecout[0]= curvemapping_evaluateF(cumap, 0, curvemapping_evaluateF(cumap, 3, vecin[0])); - vecout[1]= curvemapping_evaluateF(cumap, 1, curvemapping_evaluateF(cumap, 3, vecin[1])); - vecout[2]= curvemapping_evaluateF(cumap, 2, curvemapping_evaluateF(cumap, 3, vecin[2])); + vecout[0] = curvemapping_evaluateF(cumap, 0, curvemapping_evaluateF(cumap, 3, vecin[0])); + vecout[1] = curvemapping_evaluateF(cumap, 1, curvemapping_evaluateF(cumap, 3, vecin[1])); + vecout[2] = curvemapping_evaluateF(cumap, 2, curvemapping_evaluateF(cumap, 3, vecin[2])); } @@ -728,14 +728,14 @@ void curvemapping_evaluate_premulRGBF(CurveMapping *cumap, float vecout[3], cons { float fac; - fac= (vecin[0] - cumap->black[0])*cumap->bwmul[0]; - vecout[0]= curvemap_evaluateF(cumap->cm, fac); + fac = (vecin[0] - cumap->black[0]) * cumap->bwmul[0]; + vecout[0] = curvemap_evaluateF(cumap->cm, fac); - fac= (vecin[1] - cumap->black[1])*cumap->bwmul[1]; - vecout[1]= curvemap_evaluateF(cumap->cm+1, fac); + fac = (vecin[1] - cumap->black[1]) * cumap->bwmul[1]; + vecout[1] = curvemap_evaluateF(cumap->cm + 1, fac); - fac= (vecin[2] - cumap->black[2])*cumap->bwmul[2]; - vecout[2]= curvemap_evaluateF(cumap->cm+2, fac); + fac = (vecin[2] - cumap->black[2]) * cumap->bwmul[2]; + vecout[2] = curvemap_evaluateF(cumap->cm + 2, fac); } @@ -746,14 +746,14 @@ void curvemapping_do_ibuf(CurveMapping *cumap, ImBuf *ibuf) int pixel; float *pix_in; float col[3]; - int stride= 4; + int stride = 4; float *pix_out; - if (ibuf==NULL) + if (ibuf == NULL) return; - if (ibuf->rect_float==NULL) + if (ibuf->rect_float == NULL) IMB_float_from_rect(ibuf); - else if (ibuf->rect==NULL) + else if (ibuf->rect == NULL) imb_addrectImBuf(ibuf); if (!ibuf->rect || !ibuf->rect_float) @@ -765,27 +765,27 @@ void curvemapping_do_ibuf(CurveMapping *cumap, ImBuf *ibuf) curvemapping_premultiply(cumap, 0); - pix_in= ibuf->rect_float; - pix_out= tmpbuf->rect_float; + pix_in = ibuf->rect_float; + pix_out = tmpbuf->rect_float; if (ibuf->channels) - stride= ibuf->channels; + stride = ibuf->channels; - for (pixel= ibuf->x*ibuf->y; pixel>0; pixel--, pix_in+=stride, pix_out+=stride) { - if (stride<3) { - col[0]= curvemap_evaluateF(cumap->cm, *pix_in); + for (pixel = ibuf->x * ibuf->y; pixel > 0; pixel--, pix_in += stride, pix_out += stride) { + if (stride < 3) { + col[0] = curvemap_evaluateF(cumap->cm, *pix_in); - pix_out[1]= pix_out[2]= pix_out[3]= pix_out[0]= col[0]; + pix_out[1] = pix_out[2] = pix_out[3] = pix_out[0] = col[0]; } else { curvemapping_evaluate_premulRGBF(cumap, col, pix_in); - pix_out[0]= col[0]; - pix_out[1]= col[1]; - pix_out[2]= col[2]; - if (stride>3) - pix_out[3]= pix_in[3]; + pix_out[0] = col[0]; + pix_out[1] = col[1]; + pix_out[2] = col[2]; + if (stride > 3) + pix_out[3] = pix_in[3]; else - pix_out[3]= 1.f; + pix_out[3] = 1.f; } } @@ -800,16 +800,16 @@ int curvemapping_RGBA_does_something(CurveMapping *cumap) { int a; - if (cumap->black[0]!=0.0f) return 1; - if (cumap->black[1]!=0.0f) return 1; - if (cumap->black[2]!=0.0f) return 1; - if (cumap->white[0]!=1.0f) return 1; - if (cumap->white[1]!=1.0f) return 1; - if (cumap->white[2]!=1.0f) return 1; + if (cumap->black[0] != 0.0f) return 1; + if (cumap->black[1] != 0.0f) return 1; + if (cumap->black[2] != 0.0f) return 1; + if (cumap->white[0] != 1.0f) return 1; + if (cumap->white[1] != 1.0f) return 1; + if (cumap->white[2] != 1.0f) return 1; - for (a=0; acm[a].curve) { - if (cumap->cm[a].totpoint!=2) return 1; + if (cumap->cm[a].totpoint != 2) return 1; if (cumap->cm[a].curve[0].x != 0.0f) return 1; if (cumap->cm[a].curve[0].y != 0.0f) return 1; @@ -824,11 +824,11 @@ void curvemapping_initialize(CurveMapping *cumap) { int a; - if (cumap==NULL) return; + if (cumap == NULL) return; - for (a=0; acm[a].table==NULL) - curvemap_make_table(cumap->cm+a, &cumap->clipr); + for (a = 0; a < CM_TOT; a++) { + if (cumap->cm[a].table == NULL) + curvemap_make_table(cumap->cm + a, &cumap->clipr); } } @@ -836,29 +836,29 @@ void curvemapping_table_RGBA(CurveMapping *cumap, float **array, int *size) { int a; - *size = CM_TABLE+1; - *array = MEM_callocN(sizeof(float)*(*size)*4, "CurveMapping"); + *size = CM_TABLE + 1; + *array = MEM_callocN(sizeof(float) * (*size) * 4, "CurveMapping"); curvemapping_initialize(cumap); - for (a=0; a<*size; a++) { + for (a = 0; a < *size; a++) { if (cumap->cm[0].table) - (*array)[a*4+0]= cumap->cm[0].table[a].y; + (*array)[a * 4 + 0] = cumap->cm[0].table[a].y; if (cumap->cm[1].table) - (*array)[a*4+1]= cumap->cm[1].table[a].y; + (*array)[a * 4 + 1] = cumap->cm[1].table[a].y; if (cumap->cm[2].table) - (*array)[a*4+2]= cumap->cm[2].table[a].y; + (*array)[a * 4 + 2] = cumap->cm[2].table[a].y; if (cumap->cm[3].table) - (*array)[a*4+3]= cumap->cm[3].table[a].y; + (*array)[a * 4 + 3] = cumap->cm[3].table[a].y; } } /* ***************** Histogram **************** */ -#define INV_255 (1.f/255.f) +#define INV_255 (1.f / 255.f) DO_INLINE int get_bin_float(float f) { - int bin= (int)((f*255.0f) + 0.5f); /* 0.5 to prevent quantisation differences */ + int bin = (int)((f * 255.0f) + 0.5f); /* 0.5 to prevent quantisation differences */ /* note: clamp integer instead of float to avoid problems with NaN */ CLAMP(bin, 0, 255); @@ -907,17 +907,17 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) int x, y, c; unsigned int n, nl; double div, divl; - float *rf=NULL; - unsigned char *rc=NULL; + float *rf = NULL; + unsigned char *rc = NULL; unsigned int *bin_r, *bin_g, *bin_b, *bin_lum; int savedlines, saveline; float rgb[3], ycc[3], luma; - int ycc_mode=-1; + int ycc_mode = -1; const short is_float = (ibuf->rect_float != NULL); - if (ibuf->rect==NULL && ibuf->rect_float==NULL) return; + if (ibuf->rect == NULL && ibuf->rect_float == NULL) return; - if (scopes->ok == 1 ) return; + if (scopes->ok == 1) return; if (scopes->hist.ymax == 0.f) scopes->hist.ymax = 1.f; @@ -950,19 +950,19 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) bin_lum = MEM_callocN(256 * sizeof(unsigned int), "temp historgram bins"); /* convert to number of lines with logarithmic scale */ - scopes->sample_lines = (scopes->accuracy*0.01f) * (scopes->accuracy*0.01f) * ibuf->y; + scopes->sample_lines = (scopes->accuracy * 0.01f) * (scopes->accuracy * 0.01f) * ibuf->y; if (scopes->sample_full) scopes->sample_lines = ibuf->y; /* scan the image */ - savedlines=0; - for (c=0; c<3; c++) { - scopes->minmax[c][0]=25500.0f; - scopes->minmax[c][1]=-25500.0f; + savedlines = 0; + for (c = 0; c < 3; c++) { + scopes->minmax[c][0] = 25500.0f; + scopes->minmax[c][1] = -25500.0f; } - scopes->waveform_tot = ibuf->x*scopes->sample_lines; + scopes->waveform_tot = ibuf->x * scopes->sample_lines; if (scopes->waveform_1) MEM_freeN(scopes->waveform_1); @@ -973,10 +973,10 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) if (scopes->vecscope) MEM_freeN(scopes->vecscope); - scopes->waveform_1= MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "waveform point channel 1"); - scopes->waveform_2= MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "waveform point channel 2"); - scopes->waveform_3= MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "waveform point channel 3"); - scopes->vecscope= MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "vectorscope point channel"); + scopes->waveform_1 = MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "waveform point channel 1"); + scopes->waveform_2 = MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "waveform point channel 2"); + scopes->waveform_3 = MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "waveform point channel 3"); + scopes->vecscope = MEM_callocN(scopes->waveform_tot * 2 * sizeof(float), "vectorscope point channel"); if (is_float) rf = ibuf->rect_float; @@ -984,7 +984,7 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) rc = (unsigned char *)ibuf->rect; for (y = 0; y < ibuf->y; y++) { - if (savedlinessample_lines && y>=((savedlines)*ibuf->y)/(scopes->sample_lines+1)) { + if (savedlines < scopes->sample_lines && y >= ((savedlines) * ibuf->y) / (scopes->sample_lines + 1)) { saveline = 1; } else { @@ -999,7 +999,7 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) copy_v3_v3(rgb, rf); } else { - for (c=0; c<3; c++) + for (c = 0; c < 3; c++) rgb[c] = rc[c] * INV_255; } @@ -1007,44 +1007,44 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) luma = rgb_to_luma(rgb); /* check for min max */ - if (ycc_mode == -1 ) { - for (c=0; c<3; c++) { + if (ycc_mode == -1) { + for (c = 0; c < 3; c++) { if (rgb[c] < scopes->minmax[c][0]) scopes->minmax[c][0] = rgb[c]; if (rgb[c] > scopes->minmax[c][1]) scopes->minmax[c][1] = rgb[c]; } } else { rgb_to_ycc(rgb[0], rgb[1], rgb[2], &ycc[0], &ycc[1], &ycc[2], ycc_mode); - for (c=0; c<3; c++) { - ycc[c] *=INV_255; + for (c = 0; c < 3; c++) { + ycc[c] *= INV_255; if (ycc[c] < scopes->minmax[c][0]) scopes->minmax[c][0] = ycc[c]; if (ycc[c] > scopes->minmax[c][1]) scopes->minmax[c][1] = ycc[c]; } } /* increment count for histo*/ - bin_r[ get_bin_float(rgb[0]) ] += 1; - bin_g[ get_bin_float(rgb[1]) ] += 1; - bin_b[ get_bin_float(rgb[2]) ] += 1; - bin_lum[ get_bin_float(luma) ] += 1; + bin_r[get_bin_float(rgb[0])] += 1; + bin_g[get_bin_float(rgb[1])] += 1; + bin_b[get_bin_float(rgb[2])] += 1; + bin_lum[get_bin_float(luma)] += 1; /* save sample if needed */ if (saveline) { const float fx = (float)x / (float)ibuf->x; - const int idx = 2*(ibuf->x*savedlines+x); + const int idx = 2 * (ibuf->x * savedlines + x); save_sample_line(scopes, idx, fx, rgb, ycc); } - rf+= ibuf->channels; - rc+= ibuf->channels; + rf += ibuf->channels; + rc += ibuf->channels; } if (saveline) - savedlines +=1; + savedlines += 1; } /* convert hist data to float (proportional to max count) */ - n=0; - nl=0; - for (x=0; x<256; x++) { + n = 0; + nl = 0; + for (x = 0; x < 256; x++) { if (bin_r[x] > n) n = bin_r[x]; if (bin_g[x] > n) @@ -1054,9 +1054,9 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, int use_color_management) if (bin_lum[x] > nl) nl = bin_lum[x]; } - div = 1.0/(double)n; - divl = 1.0/(double)nl; - for (x=0; x<256; x++) { + div = 1.0 / (double)n; + divl = 1.0 / (double)nl; + for (x = 0; x < 256; x++) { scopes->hist.data_r[x] = bin_r[x] * div; scopes->hist.data_g[x] = bin_g[x] * div; scopes->hist.data_b[x] = bin_b[x] * div; @@ -1092,14 +1092,14 @@ void scopes_free(Scopes *scopes) void scopes_new(Scopes *scopes) { - scopes->accuracy=30.0; - scopes->hist.mode=HISTO_MODE_RGB; - scopes->wavefrm_alpha=0.3; - scopes->vecscope_alpha=0.3; - scopes->wavefrm_height= 100; - scopes->vecscope_height= 100; - scopes->hist.height= 100; - scopes->ok= 0; + scopes->accuracy = 30.0; + scopes->hist.mode = HISTO_MODE_RGB; + scopes->wavefrm_alpha = 0.3; + scopes->vecscope_alpha = 0.3; + scopes->wavefrm_height = 100; + scopes->vecscope_height = 100; + scopes->hist.height = 100; + scopes->ok = 0; scopes->waveform_1 = NULL; scopes->waveform_2 = NULL; scopes->waveform_3 = NULL; diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c index 9e47d136863..eed5ec49012 100644 --- a/source/blender/blenkernel/intern/constraint.c +++ b/source/blender/blenkernel/intern/constraint.c @@ -69,7 +69,7 @@ #include "BKE_constraint.h" #include "BKE_displist.h" #include "BKE_deform.h" -#include "BKE_DerivedMesh.h" /* for geometry targets */ +#include "BKE_DerivedMesh.h" /* for geometry targets */ #include "BKE_cdderivedmesh.h" /* for geometry targets */ #include "BKE_object.h" #include "BKE_ipo.h" @@ -90,7 +90,7 @@ #endif #ifndef M_PI -#define M_PI 3.14159265358979323846 +#define M_PI 3.14159265358979323846 #endif @@ -113,15 +113,15 @@ void unique_constraint_name(bConstraint *con, ListBase *list) /* package an object/bone for use in constraint evaluation */ /* This function MEM_calloc's a bConstraintOb struct, that will need to be freed after evaluation */ -bConstraintOb *constraints_make_evalob (Scene *scene, Object *ob, void *subdata, short datatype) +bConstraintOb *constraints_make_evalob(Scene *scene, Object *ob, void *subdata, short datatype) { bConstraintOb *cob; /* create regardless of whether we have any data! */ - cob= MEM_callocN(sizeof(bConstraintOb), "bConstraintOb"); + cob = MEM_callocN(sizeof(bConstraintOb), "bConstraintOb"); /* for system time, part of deglobalization, code nicer later with local time (ton) */ - cob->scene= scene; + cob->scene = scene; /* based on type of available data */ switch (datatype) { @@ -139,7 +139,7 @@ bConstraintOb *constraints_make_evalob (Scene *scene, Object *ob, void *subdata, copy_m4_m4(cob->startmat, cob->matrix); } - break; + break; case CONSTRAINT_OBTYPE_BONE: { /* only set if we have valid bone, otherwise default */ @@ -150,11 +150,11 @@ bConstraintOb *constraints_make_evalob (Scene *scene, Object *ob, void *subdata, if (cob->pchan->rotmode > 0) { /* should be some type of Euler order */ - cob->rotOrder= cob->pchan->rotmode; + cob->rotOrder = cob->pchan->rotmode; } else { /* Quats, so eulers should just use default order */ - cob->rotOrder= EULER_ORDER_DEFAULT; + cob->rotOrder = EULER_ORDER_DEFAULT; } /* matrix in world-space */ @@ -165,7 +165,7 @@ bConstraintOb *constraints_make_evalob (Scene *scene, Object *ob, void *subdata, copy_m4_m4(cob->startmat, cob->matrix); } - break; + break; default: /* other types not yet handled */ unit_m4(cob->matrix); @@ -202,7 +202,7 @@ void constraints_clear_evalob(bConstraintOb *cob) invert_m4_m4(cob->ob->constinv, delta); } } - break; + break; case CONSTRAINT_OBTYPE_BONE: { /* cob->ob or cob->pchan might not exist */ @@ -214,7 +214,7 @@ void constraints_clear_evalob(bConstraintOb *cob) invert_m4_m4(cob->pchan->constinv, delta); } } - break; + break; } /* free tempolary struct */ @@ -278,7 +278,7 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] float imat[4][4]; /* prevent crashes in these unlikely events */ - if (ob==NULL || mat==NULL) return; + if (ob == NULL || mat == NULL) return; /* optimize trick - check if need to do anything */ if (from == to) return; @@ -298,8 +298,8 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_POSE, to); } } - break; - case CONSTRAINT_SPACE_POSE: /* ---------- FROM POSESPACE ---------- */ + break; + case CONSTRAINT_SPACE_POSE: /* ---------- FROM POSESPACE ---------- */ { /* pose to world */ if (to == CONSTRAINT_SPACE_WORLD) { @@ -331,7 +331,7 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] } } } - break; + break; case CONSTRAINT_SPACE_LOCAL: /* ------------ FROM LOCALSPACE --------- */ { /* local to pose - do inverse procedure that was done for pose to local */ @@ -351,7 +351,7 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_POSE, to); } } - break; + break; case CONSTRAINT_SPACE_PARLOCAL: /* -------------- FROM LOCAL WITH PARENT ---------- */ { /* local + parent to pose */ @@ -366,12 +366,12 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] constraint_mat_convertspace(ob, pchan, mat, CONSTRAINT_SPACE_POSE, to); } } - break; + break; } } else { /* objects */ - if (from==CONSTRAINT_SPACE_WORLD && to==CONSTRAINT_SPACE_LOCAL) { + if (from == CONSTRAINT_SPACE_WORLD && to == CONSTRAINT_SPACE_LOCAL) { /* check if object has a parent */ if (ob->parent) { /* 'subtract' parent's effects from owner */ @@ -391,7 +391,7 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] mult_m4_m4m4(mat, imat, mat); } } - else if (from==CONSTRAINT_SPACE_LOCAL && to==CONSTRAINT_SPACE_WORLD) { + else if (from == CONSTRAINT_SPACE_LOCAL && to == CONSTRAINT_SPACE_WORLD) { /* check that object has a parent - otherwise this won't work */ if (ob->parent) { /* 'add' parent's effect back to owner */ @@ -415,15 +415,15 @@ void constraint_mat_convertspace(Object *ob, bPoseChannel *pchan, float mat[][4] /* ------------ General Target Matrix Tools ---------- */ /* function that sets the given matrix based on given vertex group in mesh */ -static void contarget_get_mesh_mat (Object *ob, const char *substring, float mat[][4]) +static void contarget_get_mesh_mat(Object *ob, const char *substring, float mat[][4]) { DerivedMesh *dm = NULL; - Mesh *me= ob->data; + Mesh *me = ob->data; BMEditMesh *em = me->edit_btmesh; float vec[3] = {0.0f, 0.0f, 0.0f}; float normal[3] = {0.0f, 0.0f, 0.0f}, plane[3]; float imat[3][3], tmat[3][3]; - const int defgroup= defgroup_name_index(ob, substring); + const int defgroup = defgroup_name_index(ob, substring); short freeDM = 0; /* initialize target matrix using target matrix */ @@ -436,7 +436,7 @@ static void contarget_get_mesh_mat (Object *ob, const char *substring, float mat if (em) { /* target is in editmode, so get a special derived mesh */ dm = CDDM_from_BMEditMesh(em, ob->data, FALSE, FALSE); - freeDM= 1; + freeDM = 1; } else { /* when not in EditMode, use the 'final' derived mesh, depsgraph @@ -454,10 +454,10 @@ static void contarget_get_mesh_mat (Object *ob, const char *substring, float mat /* check that dvert is a valid pointers (just in case) */ if (dvert) { - MDeformVert *dv= dvert; + MDeformVert *dv = dvert; /* get the average of all verts with that are in the vertex-group */ for (i = 0; i < numVerts; i++, dv++) { - MDeformWeight *dw= defvert_find_index(dv, defgroup); + MDeformWeight *dw = defvert_find_index(dv, defgroup); if (dw && dw->weight != 0.0f) { dm->getVertCo(dm, i, co); dm->getVertNo(dm, i, nor); @@ -512,20 +512,20 @@ static void contarget_get_mesh_mat (Object *ob, const char *substring, float mat } /* function that sets the given matrix based on given vertex group in lattice */ -static void contarget_get_lattice_mat (Object *ob, const char *substring, float mat[][4]) +static void contarget_get_lattice_mat(Object *ob, const char *substring, float mat[][4]) { - Lattice *lt= (Lattice *)ob->data; + Lattice *lt = (Lattice *)ob->data; DispList *dl = find_displist(&ob->disp, DL_VERTS); - float *co = dl?dl->verts:NULL; + float *co = dl ? dl->verts : NULL; BPoint *bp = lt->def; MDeformVert *dv = lt->dvert; - int tot_verts= lt->pntsu*lt->pntsv*lt->pntsw; - float vec[3]= {0.0f, 0.0f, 0.0f}, tvec[3]; - int grouped=0; + int tot_verts = lt->pntsu * lt->pntsv * lt->pntsw; + float vec[3] = {0.0f, 0.0f, 0.0f}, tvec[3]; + int grouped = 0; int i, n; - const int defgroup= defgroup_name_index(ob, substring); + const int defgroup = defgroup_name_index(ob, substring); /* initialize target matrix using target matrix */ copy_m4_m4(mat, ob->obmat); @@ -537,9 +537,9 @@ static void contarget_get_lattice_mat (Object *ob, const char *substring, float /* 1. Loop through control-points checking if in nominated vertex-group. * 2. If it is, add it to vec to find the average point. */ - for (i=0; i < tot_verts; i++, dv++) { - for (n= 0; n < dv->totweight; n++) { - MDeformWeight *dw= defvert_find_index(dv, defgroup); + for (i = 0; i < tot_verts; i++, dv++) { + for (n = 0; n < dv->totweight; n++) { + MDeformWeight *dw = defvert_find_index(dv, defgroup); if (dw && dw->weight > 0.0f) { /* copy coordinates of point to temporary vector, then add to find average */ memcpy(tvec, co ? co : bp->vec, 3 * sizeof(float)); @@ -551,7 +551,7 @@ static void contarget_get_lattice_mat (Object *ob, const char *substring, float /* advance pointer to coordinate data */ if (co) co += 3; - else bp++; + else bp++; } /* find average location, then multiply by ob->obmat to find world-space location */ @@ -565,14 +565,14 @@ static void contarget_get_lattice_mat (Object *ob, const char *substring, float /* generic function to get the appropriate matrix for most target cases */ /* The cases where the target can be object data have not been implemented */ -static void constraint_target_to_mat4 (Object *ob, const char *substring, float mat[][4], short from, short to, float headtail) +static void constraint_target_to_mat4(Object *ob, const char *substring, float mat[][4], short from, short to, float headtail) { /* Case OBJECT */ if (!strlen(substring)) { copy_m4_m4(mat, ob->obmat); constraint_mat_convertspace(ob, NULL, mat, from, to); } - /* Case VERTEXGROUP */ + /* Case VERTEXGROUP */ /* Current method just takes the average location of all the points in the * VertexGroup, and uses that as the location value of the targets. Where * possible, the orientation will also be calculated, by calculating an @@ -631,14 +631,14 @@ static void constraint_target_to_mat4 (Object *ob, const char *substring, float */ /* Template for type-info data: - * - make a copy of this when creating new constraints, and just change the functions - * pointed to as necessary - * - although the naming of functions doesn't matter, it would help for code - * readability, to follow the same naming convention as is presented here - * - any functions that a constraint doesn't need to define, don't define - * for such cases, just use NULL - * - these should be defined after all the functions have been defined, so that - * forward-definitions/prototypes don't need to be used! + * - make a copy of this when creating new constraints, and just change the functions + * pointed to as necessary + * - although the naming of functions doesn't matter, it would help for code + * readability, to follow the same naming convention as is presented here + * - any functions that a constraint doesn't need to define, don't define + * for such cases, just use NULL + * - these should be defined after all the functions have been defined, so that + * forward-definitions/prototypes don't need to be used! * - keep this copy #if-def'd so that future constraints can get based off this */ #if 0 @@ -661,7 +661,7 @@ static bConstraintTypeInfo CTI_CONSTRNAME = { /* This function should be used for the get_target_matrix member of all * constraints that are not picky about what happens to their target matrix. */ -static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bConstraintTarget *ct, float UNUSED(ctime)) +static void default_get_tarmat(bConstraint *con, bConstraintOb *UNUSED(cob), bConstraintTarget *ct, float UNUSED(ctime)) { if (VALID_CONS_TARGET(ct)) constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space, con->headtail); @@ -677,26 +677,26 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC // TODO: cope with getting rotation order... #define SINGLETARGET_GET_TARS(con, datatar, datasubtarget, ct, list) \ { \ - ct= MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \ + ct = MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \ \ - ct->tar= datatar; \ + ct->tar = datatar; \ BLI_strncpy(ct->subtarget, datasubtarget, sizeof(ct->subtarget)); \ - ct->space= con->tarspace; \ - ct->flag= CONSTRAINT_TAR_TEMP; \ + ct->space = con->tarspace; \ + ct->flag = CONSTRAINT_TAR_TEMP; \ \ if (ct->tar) { \ - if ((ct->tar->type==OB_ARMATURE) && (ct->subtarget[0])) { \ - bPoseChannel *pchan= BKE_pose_channel_find_name(ct->tar->pose, ct->subtarget); \ + if ((ct->tar->type == OB_ARMATURE) && (ct->subtarget[0])) { \ + bPoseChannel *pchan = BKE_pose_channel_find_name(ct->tar->pose, ct->subtarget); \ ct->type = CONSTRAINT_OBTYPE_BONE; \ - ct->rotOrder= (pchan) ? (pchan->rotmode) : EULER_ORDER_DEFAULT; \ - }\ + ct->rotOrder = (pchan) ? (pchan->rotmode) : EULER_ORDER_DEFAULT; \ + } \ else if (OB_TYPE_SUPPORT_VGROUP(ct->tar->type) && (ct->subtarget[0])) { \ ct->type = CONSTRAINT_OBTYPE_VERT; \ ct->rotOrder = EULER_ORDER_DEFAULT; \ } \ - else {\ + else { \ ct->type = CONSTRAINT_OBTYPE_OBJECT; \ - ct->rotOrder= ct->tar->rotmode; \ + ct->rotOrder = ct->tar->rotmode; \ } \ } \ \ @@ -711,11 +711,11 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC // TODO: cope with getting rotation order... #define SINGLETARGETNS_GET_TARS(con, datatar, ct, list) \ { \ - ct= MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \ + ct = MEM_callocN(sizeof(bConstraintTarget), "tempConstraintTarget"); \ \ - ct->tar= datatar; \ - ct->space= con->tarspace; \ - ct->flag= CONSTRAINT_TAR_TEMP; \ + ct->tar = datatar; \ + ct->space = con->tarspace; \ + ct->flag = CONSTRAINT_TAR_TEMP; \ \ if (ct->tar) ct->type = CONSTRAINT_OBTYPE_OBJECT; \ \ @@ -733,13 +733,13 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC if (ct) { \ bConstraintTarget *ctn = ct->next; \ if (nocopy == 0) { \ - datatar= ct->tar; \ + datatar = ct->tar; \ BLI_strncpy(datasubtarget, ct->subtarget, sizeof(datasubtarget)); \ - con->tarspace= (char)ct->space; \ + con->tarspace = (char)ct->space; \ } \ \ BLI_freelinkN(list, ct); \ - ct= ctn; \ + ct = ctn; \ } \ } @@ -754,39 +754,39 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC if (ct) { \ bConstraintTarget *ctn = ct->next; \ if (nocopy == 0) { \ - datatar= ct->tar; \ - con->tarspace= (char)ct->space; \ + datatar = ct->tar; \ + con->tarspace = (char)ct->space; \ } \ \ BLI_freelinkN(list, ct); \ - ct= ctn; \ + ct = ctn; \ } \ } /* --------- ChildOf Constraint ------------ */ -static void childof_new_data (void *cdata) +static void childof_new_data(void *cdata) { - bChildOfConstraint *data= (bChildOfConstraint *)cdata; + bChildOfConstraint *data = (bChildOfConstraint *)cdata; data->flag = (CHILDOF_LOCX | CHILDOF_LOCY | CHILDOF_LOCZ | - CHILDOF_ROTX |CHILDOF_ROTY | CHILDOF_ROTZ | - CHILDOF_SIZEX | CHILDOF_SIZEY | CHILDOF_SIZEZ); + CHILDOF_ROTX | CHILDOF_ROTY | CHILDOF_ROTZ | + CHILDOF_SIZEX | CHILDOF_SIZEY | CHILDOF_SIZEZ); unit_m4(data->invmat); } -static void childof_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void childof_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bChildOfConstraint *data= con->data; + bChildOfConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int childof_get_tars (bConstraint *con, ListBase *list) +static int childof_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bChildOfConstraint *data= con->data; + bChildOfConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -798,21 +798,21 @@ static int childof_get_tars (bConstraint *con, ListBase *list) return 0; } -static void childof_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void childof_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bChildOfConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bChildOfConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void childof_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void childof_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bChildOfConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bChildOfConstraint *data = con->data; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { @@ -849,15 +849,15 @@ static void childof_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta mat4_to_size(sizo, invmat); /* disable channels not enabled */ - if (!(data->flag & CHILDOF_LOCX)) loc[0]= loco[0]= 0.0f; - if (!(data->flag & CHILDOF_LOCY)) loc[1]= loco[1]= 0.0f; - if (!(data->flag & CHILDOF_LOCZ)) loc[2]= loco[2]= 0.0f; - if (!(data->flag & CHILDOF_ROTX)) eul[0]= eulo[0]= 0.0f; - if (!(data->flag & CHILDOF_ROTY)) eul[1]= eulo[1]= 0.0f; - if (!(data->flag & CHILDOF_ROTZ)) eul[2]= eulo[2]= 0.0f; - if (!(data->flag & CHILDOF_SIZEX)) size[0]= sizo[0]= 1.0f; - if (!(data->flag & CHILDOF_SIZEY)) size[1]= sizo[1]= 1.0f; - if (!(data->flag & CHILDOF_SIZEZ)) size[2]= sizo[2]= 1.0f; + if (!(data->flag & CHILDOF_LOCX)) loc[0] = loco[0] = 0.0f; + if (!(data->flag & CHILDOF_LOCY)) loc[1] = loco[1] = 0.0f; + if (!(data->flag & CHILDOF_LOCZ)) loc[2] = loco[2] = 0.0f; + if (!(data->flag & CHILDOF_ROTX)) eul[0] = eulo[0] = 0.0f; + if (!(data->flag & CHILDOF_ROTY)) eul[1] = eulo[1] = 0.0f; + if (!(data->flag & CHILDOF_ROTZ)) eul[2] = eulo[2] = 0.0f; + if (!(data->flag & CHILDOF_SIZEX)) size[0] = sizo[0] = 1.0f; + if (!(data->flag & CHILDOF_SIZEY)) size[1] = sizo[1] = 1.0f; + if (!(data->flag & CHILDOF_SIZEZ)) size[2] = sizo[2] = 1.0f; /* make new target mat and offset mat */ loc_eulO_size_to_mat4(ct->matrix, loc, eul, size, ct->rotOrder); @@ -877,9 +877,9 @@ static void childof_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta /* without this, changes to scale and rotation can change location * of a parentless bone or a disconnected bone. Even though its set * to zero above. */ - if (!(data->flag & CHILDOF_LOCX)) cob->matrix[3][0]= tempmat[3][0]; - if (!(data->flag & CHILDOF_LOCY)) cob->matrix[3][1]= tempmat[3][1]; - if (!(data->flag & CHILDOF_LOCZ)) cob->matrix[3][2]= tempmat[3][2]; + if (!(data->flag & CHILDOF_LOCX)) cob->matrix[3][0] = tempmat[3][0]; + if (!(data->flag & CHILDOF_LOCY)) cob->matrix[3][1] = tempmat[3][1]; + if (!(data->flag & CHILDOF_LOCZ)) cob->matrix[3][2] = tempmat[3][2]; } } } @@ -902,26 +902,26 @@ static bConstraintTypeInfo CTI_CHILDOF = { /* -------- TrackTo Constraint ------- */ -static void trackto_new_data (void *cdata) +static void trackto_new_data(void *cdata) { - bTrackToConstraint *data= (bTrackToConstraint *)cdata; + bTrackToConstraint *data = (bTrackToConstraint *)cdata; data->reserved1 = TRACK_Y; data->reserved2 = UP_Z; } -static void trackto_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void trackto_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bTrackToConstraint *data= con->data; + bTrackToConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int trackto_get_tars (bConstraint *con, ListBase *list) +static int trackto_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bTrackToConstraint *data= con->data; + bTrackToConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -933,11 +933,11 @@ static int trackto_get_tars (bConstraint *con, ListBase *list) return 0; } -static void trackto_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void trackto_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bTrackToConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bTrackToConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) @@ -945,9 +945,9 @@ static void trackto_flush_tars (bConstraint *con, ListBase *list, short nocopy) } -static int basis_cross (int n, int m) +static int basis_cross(int n, int m) { - switch (n-m) { + switch (n - m) { case 1: case -2: return 1; @@ -961,7 +961,7 @@ static int basis_cross (int n, int m) } } -static void vectomat (float *vec, float *target_up, short axis, short upflag, short flags, float m[][3]) +static void vectomat(float *vec, float *target_up, short axis, short upflag, short flags, float m[][3]) { float n[3]; float u[3]; /* vector specifying the up axis */ @@ -1025,10 +1025,10 @@ static void vectomat (float *vec, float *target_up, short axis, short upflag, sh } -static void trackto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void trackto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bTrackToConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bTrackToConstraint *data = con->data; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { float size[3], vec[3]; @@ -1039,23 +1039,23 @@ static void trackto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta mat4_to_size(size, cob->matrix); /* Clear the object's rotation */ - cob->matrix[0][0]=size[0]; - cob->matrix[0][1]=0; - cob->matrix[0][2]=0; - cob->matrix[1][0]=0; - cob->matrix[1][1]=size[1]; - cob->matrix[1][2]=0; - cob->matrix[2][0]=0; - cob->matrix[2][1]=0; - cob->matrix[2][2]=size[2]; + cob->matrix[0][0] = size[0]; + cob->matrix[0][1] = 0; + cob->matrix[0][2] = 0; + cob->matrix[1][0] = 0; + cob->matrix[1][1] = size[1]; + cob->matrix[1][2] = 0; + cob->matrix[2][0] = 0; + cob->matrix[2][1] = 0; + cob->matrix[2][2] = size[2]; /* targetmat[2] instead of ownermat[2] is passed to vectomat * for backwards compatibility it seems... (Aligorith) */ sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]); vectomat(vec, ct->matrix[2], - (short)data->reserved1, (short)data->reserved2, - data->flags, totmat); + (short)data->reserved1, (short)data->reserved2, + data->flags, totmat); copy_m4_m4(tmat, cob->matrix); mul_m4_m3m4(cob->matrix, totmat, tmat); @@ -1079,32 +1079,32 @@ static bConstraintTypeInfo CTI_TRACKTO = { /* --------- Inverse-Kinemetics --------- */ -static void kinematic_new_data (void *cdata) +static void kinematic_new_data(void *cdata) { - bKinematicConstraint *data= (bKinematicConstraint *)cdata; + bKinematicConstraint *data = (bKinematicConstraint *)cdata; - data->weight= 1.0f; - data->orientweight= 1.0f; + data->weight = 1.0f; + data->orientweight = 1.0f; data->iterations = 500; - data->dist= 1.0f; - data->flag= CONSTRAINT_IK_TIP|CONSTRAINT_IK_STRETCH|CONSTRAINT_IK_POS; + data->dist = 1.0f; + data->flag = CONSTRAINT_IK_TIP | CONSTRAINT_IK_STRETCH | CONSTRAINT_IK_POS; } -static void kinematic_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void kinematic_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bKinematicConstraint *data= con->data; + bKinematicConstraint *data = con->data; /* chain target */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); /* poletarget */ - func(con, (ID**)&data->poletar, FALSE, userdata); + func(con, (ID **)&data->poletar, FALSE, userdata); } -static int kinematic_get_tars (bConstraint *con, ListBase *list) +static int kinematic_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bKinematicConstraint *data= con->data; + bKinematicConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints is used twice here */ @@ -1117,11 +1117,11 @@ static int kinematic_get_tars (bConstraint *con, ListBase *list) return 0; } -static void kinematic_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void kinematic_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bKinematicConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bKinematicConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) @@ -1129,15 +1129,15 @@ static void kinematic_flush_tars (bConstraint *con, ListBase *list, short nocopy } } -static void kinematic_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void kinematic_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { - bKinematicConstraint *data= con->data; + bKinematicConstraint *data = con->data; if (VALID_CONS_TARGET(ct)) constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space, con->headtail); else if (ct) { if (data->flag & CONSTRAINT_IK_AUTO) { - Object *ob= cob->ob; + Object *ob = cob->ob; if (ob == NULL) { unit_m4(ct->matrix); @@ -1172,9 +1172,9 @@ static bConstraintTypeInfo CTI_KINEMATIC = { /* -------- Follow-Path Constraint ---------- */ -static void followpath_new_data (void *cdata) +static void followpath_new_data(void *cdata) { - bFollowPathConstraint *data= (bFollowPathConstraint *)cdata; + bFollowPathConstraint *data = (bFollowPathConstraint *)cdata; data->trackflag = TRACK_Y; data->upflag = UP_Z; @@ -1182,18 +1182,18 @@ static void followpath_new_data (void *cdata) data->followflag = 0; } -static void followpath_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void followpath_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bFollowPathConstraint *data= con->data; + bFollowPathConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int followpath_get_tars (bConstraint *con, ListBase *list) +static int followpath_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bFollowPathConstraint *data= con->data; + bFollowPathConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints without subtargets */ @@ -1205,25 +1205,25 @@ static int followpath_get_tars (bConstraint *con, ListBase *list) return 0; } -static void followpath_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void followpath_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bFollowPathConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bFollowPathConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGETNS_FLUSH_TARS(con, data->tar, ct, list, nocopy) } } -static void followpath_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void followpath_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { - bFollowPathConstraint *data= con->data; + bFollowPathConstraint *data = con->data; if (VALID_CONS_TARGET(ct)) { - Curve *cu= ct->tar->data; + Curve *cu = ct->tar->data; float vec[4], dir[3], radius; - float totmat[4][4]= MAT4_UNITY; + float totmat[4][4] = MAT4_UNITY; float curvetime; unit_m4(ct->matrix); @@ -1233,7 +1233,7 @@ static void followpath_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr */ /* only happens on reload file, but violates depsgraph still... fix! */ - if (cu->path==NULL || cu->path->data==NULL) + if (cu->path == NULL || cu->path->data == NULL) makeDispListCurveTypes(cob->scene, ct->tar, 0); if (cu->path && cu->path->data) { @@ -1241,7 +1241,7 @@ static void followpath_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr if ((data->followflag & FOLLOWPATH_STATIC) == 0) { /* animated position along curve depending on time */ Nurb *nu = cu->nurb.first; - curvetime= cu->ctime - data->offset; + curvetime = cu->ctime - data->offset; /* ctime is now a proper var setting of Curve which gets set by Animato like any other var that's animated, * but this will only work if it actually is animated... @@ -1265,21 +1265,21 @@ static void followpath_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr } else { /* fixed position along curve */ - curvetime= data->offset_fac; + curvetime = data->offset_fac; } - if ( where_on_path(ct->tar, curvetime, vec, dir, (data->followflag & FOLLOWPATH_FOLLOW) ? quat : NULL, &radius, NULL) ) { /* quat_pt is quat or NULL*/ + if (where_on_path(ct->tar, curvetime, vec, dir, (data->followflag & FOLLOWPATH_FOLLOW) ? quat : NULL, &radius, NULL) ) { /* quat_pt is quat or NULL*/ if (data->followflag & FOLLOWPATH_FOLLOW) { #if 0 float x1, q[4]; vec_to_quat(quat, dir, (short)data->trackflag, (short)data->upflag); normalize_v3(dir); - q[0]= (float)cos(0.5*vec[3]); - x1= (float)sin(0.5*vec[3]); - q[1]= -x1*dir[0]; - q[2]= -x1*dir[1]; - q[3]= -x1*dir[2]; + q[0] = (float)cos(0.5 * vec[3]); + x1 = (float)sin(0.5 * vec[3]); + q[1] = -x1 * dir[0]; + q[2] = -x1 * dir[1]; + q[3] = -x1 * dir[2]; mul_qt_qtqt(quat, q, quat); #else quat_apply_track(quat, data->trackflag, data->upflag); @@ -1305,15 +1305,15 @@ static void followpath_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr unit_m4(ct->matrix); } -static void followpath_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void followpath_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bConstraintTarget *ct= targets->first; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { float obmat[4][4]; float size[3]; - bFollowPathConstraint *data= con->data; + bFollowPathConstraint *data = con->data; /* get Object transform (loc/rot/size) to determine transformation from path */ // TODO: this used to be local at one point, but is probably more useful as-is @@ -1326,7 +1326,7 @@ static void followpath_evaluate (bConstraint *con, bConstraintOb *cob, ListBase mul_serie_m4(cob->matrix, ct->matrix, obmat, NULL, NULL, NULL, NULL, NULL, NULL); /* un-apply scaling caused by path */ - if ((data->followflag & FOLLOWPATH_RADIUS)==0) { /* XXX - assume that scale correction means that radius will have some scale error in it - Campbell */ + if ((data->followflag & FOLLOWPATH_RADIUS) == 0) { /* XXX - assume that scale correction means that radius will have some scale error in it - Campbell */ float obsize[3]; mat4_to_size(obsize, cob->matrix); @@ -1358,7 +1358,7 @@ static bConstraintTypeInfo CTI_FOLLOWPATH = { /* --------- Limit Location --------- */ -static void loclimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) +static void loclimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) { bLocLimitConstraint *data = con->data; @@ -1405,7 +1405,7 @@ static bConstraintTypeInfo CTI_LOCLIMIT = { /* -------- Limit Rotation --------- */ -static void rotlimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) +static void rotlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) { bRotLimitConstraint *data = con->data; float loc[3]; @@ -1463,7 +1463,7 @@ static bConstraintTypeInfo CTI_ROTLIMIT = { /* --------- Limit Scaling --------- */ -static void sizelimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) +static void sizelimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) { bSizeLimitConstraint *data = con->data; float obsize[3], size[3]; @@ -1497,11 +1497,11 @@ static void sizelimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * } if (obsize[0]) - mul_v3_fl(cob->matrix[0], size[0]/obsize[0]); + mul_v3_fl(cob->matrix[0], size[0] / obsize[0]); if (obsize[1]) - mul_v3_fl(cob->matrix[1], size[1]/obsize[1]); + mul_v3_fl(cob->matrix[1], size[1] / obsize[1]); if (obsize[2]) - mul_v3_fl(cob->matrix[2], size[2]/obsize[2]); + mul_v3_fl(cob->matrix[2], size[2] / obsize[2]); } static bConstraintTypeInfo CTI_SIZELIMIT = { @@ -1521,25 +1521,25 @@ static bConstraintTypeInfo CTI_SIZELIMIT = { /* ----------- Copy Location ------------- */ -static void loclike_new_data (void *cdata) +static void loclike_new_data(void *cdata) { - bLocateLikeConstraint *data= (bLocateLikeConstraint *)cdata; + bLocateLikeConstraint *data = (bLocateLikeConstraint *)cdata; - data->flag = LOCLIKE_X|LOCLIKE_Y|LOCLIKE_Z; + data->flag = LOCLIKE_X | LOCLIKE_Y | LOCLIKE_Z; } -static void loclike_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void loclike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bLocateLikeConstraint *data= con->data; + bLocateLikeConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int loclike_get_tars (bConstraint *con, ListBase *list) +static int loclike_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bLocateLikeConstraint *data= con->data; + bLocateLikeConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -1551,21 +1551,21 @@ static int loclike_get_tars (bConstraint *con, ListBase *list) return 0; } -static void loclike_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void loclike_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bLocateLikeConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bLocateLikeConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void loclike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void loclike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bLocateLikeConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bLocateLikeConstraint *data = con->data; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { float offset[3] = {0.0f, 0.0f, 0.0f}; @@ -1611,25 +1611,25 @@ static bConstraintTypeInfo CTI_LOCLIKE = { /* ----------- Copy Rotation ------------- */ -static void rotlike_new_data (void *cdata) +static void rotlike_new_data(void *cdata) { - bRotateLikeConstraint *data= (bRotateLikeConstraint *)cdata; + bRotateLikeConstraint *data = (bRotateLikeConstraint *)cdata; - data->flag = ROTLIKE_X|ROTLIKE_Y|ROTLIKE_Z; + data->flag = ROTLIKE_X | ROTLIKE_Y | ROTLIKE_Z; } -static void rotlike_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void rotlike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bChildOfConstraint *data= con->data; + bChildOfConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int rotlike_get_tars (bConstraint *con, ListBase *list) +static int rotlike_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bRotateLikeConstraint *data= con->data; + bRotateLikeConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -1641,26 +1641,26 @@ static int rotlike_get_tars (bConstraint *con, ListBase *list) return 0; } -static void rotlike_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void rotlike_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bRotateLikeConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bRotateLikeConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void rotlike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void rotlike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bRotateLikeConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bRotateLikeConstraint *data = con->data; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { - float loc[3]; - float eul[3], obeul[3]; - float size[3]; + float loc[3]; + float eul[3], obeul[3]; + float size[3]; copy_v3_v3(loc, cob->matrix[3]); mat4_to_size(size, cob->matrix); @@ -1670,7 +1670,7 @@ static void rotlike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta /* we must get compatible eulers from the beginning because some of them can be modified below (see bug #21875) */ mat4_to_compatible_eulO(eul, obeul, cob->rotOrder, ct->matrix); - if ((data->flag & ROTLIKE_X)==0) + if ((data->flag & ROTLIKE_X) == 0) eul[0] = obeul[0]; else { if (data->flag & ROTLIKE_OFFSET) @@ -1680,7 +1680,7 @@ static void rotlike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta eul[0] *= -1; } - if ((data->flag & ROTLIKE_Y)==0) + if ((data->flag & ROTLIKE_Y) == 0) eul[1] = obeul[1]; else { if (data->flag & ROTLIKE_OFFSET) @@ -1690,7 +1690,7 @@ static void rotlike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta eul[1] *= -1; } - if ((data->flag & ROTLIKE_Z)==0) + if ((data->flag & ROTLIKE_Z) == 0) eul[2] = obeul[2]; else { if (data->flag & ROTLIKE_OFFSET) @@ -1723,25 +1723,25 @@ static bConstraintTypeInfo CTI_ROTLIKE = { /* ---------- Copy Scaling ---------- */ -static void sizelike_new_data (void *cdata) +static void sizelike_new_data(void *cdata) { - bSizeLikeConstraint *data= (bSizeLikeConstraint *)cdata; + bSizeLikeConstraint *data = (bSizeLikeConstraint *)cdata; - data->flag = SIZELIKE_X|SIZELIKE_Y|SIZELIKE_Z; + data->flag = SIZELIKE_X | SIZELIKE_Y | SIZELIKE_Z; } -static void sizelike_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void sizelike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bSizeLikeConstraint *data= con->data; + bSizeLikeConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int sizelike_get_tars (bConstraint *con, ListBase *list) +static int sizelike_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bSizeLikeConstraint *data= con->data; + bSizeLikeConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -1753,21 +1753,21 @@ static int sizelike_get_tars (bConstraint *con, ListBase *list) return 0; } -static void sizelike_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void sizelike_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bSizeLikeConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bSizeLikeConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void sizelike_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void sizelike_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bSizeLikeConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bSizeLikeConstraint *data = con->data; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { float obsize[3], size[3]; @@ -1819,18 +1819,18 @@ static bConstraintTypeInfo CTI_SIZELIKE = { /* ----------- Copy Transforms ------------- */ -static void translike_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void translike_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bTransLikeConstraint *data= con->data; + bTransLikeConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int translike_get_tars (bConstraint *con, ListBase *list) +static int translike_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bTransLikeConstraint *data= con->data; + bTransLikeConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -1842,20 +1842,20 @@ static int translike_get_tars (bConstraint *con, ListBase *list) return 0; } -static void translike_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void translike_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bTransLikeConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bTransLikeConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void translike_evaluate (bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets) +static void translike_evaluate(bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets) { - bConstraintTarget *ct= targets->first; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { /* just copy the entire transform matrix of the target */ @@ -1880,17 +1880,17 @@ static bConstraintTypeInfo CTI_TRANSLIKE = { /* ---------- Maintain Volume ---------- */ -static void samevolume_new_data (void *cdata) +static void samevolume_new_data(void *cdata) { - bSameVolumeConstraint *data= (bSameVolumeConstraint *)cdata; + bSameVolumeConstraint *data = (bSameVolumeConstraint *)cdata; data->flag = SAMEVOL_Y; data->volume = 1.0f; } -static void samevolume_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) +static void samevolume_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) { - bSameVolumeConstraint *data= con->data; + bSameVolumeConstraint *data = con->data; float volume = data->volume; float fac = 1.0f; @@ -1936,9 +1936,9 @@ static bConstraintTypeInfo CTI_SAMEVOL = { /* ----------- Python Constraint -------------- */ -static void pycon_free (bConstraint *con) +static void pycon_free(bConstraint *con) { - bPythonConstraint *data= con->data; + bPythonConstraint *data = con->data; /* id-properties */ IDP_FreeProperty(data->prop); @@ -1948,7 +1948,7 @@ static void pycon_free (bConstraint *con) BLI_freelistN(&data->targets); } -static void pycon_copy (bConstraint *con, bConstraint *srccon) +static void pycon_copy(bConstraint *con, bConstraint *srccon) { bPythonConstraint *pycon = (bPythonConstraint *)con->data; bPythonConstraint *opycon = (bPythonConstraint *)srccon->data; @@ -1957,19 +1957,19 @@ static void pycon_copy (bConstraint *con, bConstraint *srccon) BLI_duplicatelist(&pycon->targets, &opycon->targets); } -static void pycon_new_data (void *cdata) +static void pycon_new_data(void *cdata) { - bPythonConstraint *data= (bPythonConstraint *)cdata; + bPythonConstraint *data = (bPythonConstraint *)cdata; /* everything should be set correctly by calloc, except for the prop->type constant.*/ data->prop = MEM_callocN(sizeof(IDProperty), "PyConstraintProps"); data->prop->type = IDP_GROUP; } -static int pycon_get_tars (bConstraint *con, ListBase *list) +static int pycon_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bPythonConstraint *data= con->data; + bPythonConstraint *data = con->data; list->first = data->targets.first; list->last = data->targets.last; @@ -1980,33 +1980,33 @@ static int pycon_get_tars (bConstraint *con, ListBase *list) return 0; } -static void pycon_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void pycon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bPythonConstraint *data= con->data; + bPythonConstraint *data = con->data; bConstraintTarget *ct; /* targets */ - for (ct= data->targets.first; ct; ct= ct->next) - func(con, (ID**)&ct->tar, FALSE, userdata); + for (ct = data->targets.first; ct; ct = ct->next) + func(con, (ID **)&ct->tar, FALSE, userdata); /* script */ - func(con, (ID**)&data->text, TRUE, userdata); + func(con, (ID **)&data->text, TRUE, userdata); } /* Whether this approach is maintained remains to be seen (aligorith) */ -static void pycon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void pycon_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { #ifdef WITH_PYTHON - bPythonConstraint *data= con->data; + bPythonConstraint *data = con->data; #endif if (VALID_CONS_TARGET(ct)) { /* special exception for curves - depsgraph issues */ if (ct->tar->type == OB_CURVE) { - Curve *cu= ct->tar->data; + Curve *cu = ct->tar->data; /* this check is to make sure curve objects get updated on file load correctly.*/ - if (cu->path==NULL || cu->path->data==NULL) /* only happens on reload file, but violates depsgraph still... fix! */ + if (cu->path == NULL || cu->path->data == NULL) /* only happens on reload file, but violates depsgraph still... fix! */ makeDispListCurveTypes(cob->scene, ct->tar, 0); } @@ -2025,16 +2025,16 @@ static void pycon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintT unit_m4(ct->matrix); } -static void pycon_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void pycon_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { #ifndef WITH_PYTHON (void)con; (void)cob; (void)targets; /* unused */ return; #else - bPythonConstraint *data= con->data; + bPythonConstraint *data = con->data; /* only evaluate in python if we're allowed to do so */ - if ((G.f & G_SCRIPT_AUTOEXEC)==0) return; + if ((G.f & G_SCRIPT_AUTOEXEC) == 0) return; /* currently removed, until I this can be re-implemented for multiple targets */ #if 0 @@ -2067,29 +2067,29 @@ static bConstraintTypeInfo CTI_PYTHON = { /* -------- Action Constraint ----------- */ -static void actcon_new_data (void *cdata) +static void actcon_new_data(void *cdata) { - bActionConstraint *data= (bActionConstraint *)cdata; + bActionConstraint *data = (bActionConstraint *)cdata; /* set type to 20 (Loc X), as 0 is Rot X for backwards compatibility */ data->type = 20; } -static void actcon_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void actcon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bActionConstraint *data= con->data; + bActionConstraint *data = con->data; /* target */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); /* action */ - func(con, (ID**)&data->act, TRUE, userdata); + func(con, (ID **)&data->act, TRUE, userdata); } -static int actcon_get_tars (bConstraint *con, ListBase *list) +static int actcon_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bActionConstraint *data= con->data; + bActionConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -2101,18 +2101,18 @@ static int actcon_get_tars (bConstraint *con, ListBase *list) return 0; } -static void actcon_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void actcon_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bActionConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bActionConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void actcon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void actcon_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { bActionConstraint *data = con->data; @@ -2130,33 +2130,33 @@ static void actcon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraint /* determine where in transform range target is */ /* data->type is mapped as follows for backwards compatibility: * 00,01,02 - rotation (it used to be like this) - * 10,11,12 - scaling + * 10,11,12 - scaling * 20,21,22 - location */ if (data->type < 10) { /* extract rotation (is in whatever space target should be in) */ mat4_to_eul(vec, tempmat); mul_v3_fl(vec, RAD2DEGF(1.0f)); /* rad -> deg */ - axis= data->type; + axis = data->type; } else if (data->type < 20) { /* extract scaling (is in whatever space target should be in) */ mat4_to_size(vec, tempmat); - axis= data->type - 10; + axis = data->type - 10; } else { /* extract location */ copy_v3_v3(vec, tempmat[3]); - axis= data->type - 20; + axis = data->type - 20; } /* Target defines the animation */ - s = (vec[axis]-data->min) / (data->max-data->min); + s = (vec[axis] - data->min) / (data->max - data->min); CLAMP(s, 0, 1); - t = (s * (data->end-data->start)) + data->start; + t = (s * (data->end - data->start)) + data->start; if (G.debug & G_DEBUG) - printf("do Action Constraint %s - Ob %s Pchan %s\n", con->name, cob->ob->id.name+2, (cob->pchan)?cob->pchan->name:NULL); + printf("do Action Constraint %s - Ob %s Pchan %s\n", con->name, cob->ob->id.name + 2, (cob->pchan) ? cob->pchan->name : NULL); /* Get the appropriate information from the action */ if (cob->type == CONSTRAINT_OBTYPE_BONE) { @@ -2172,8 +2172,8 @@ static void actcon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraint */ pchan = cob->pchan; - tchan= BKE_pose_channel_verify(pose, pchan->name); - tchan->rotmode= pchan->rotmode; + tchan = BKE_pose_channel_verify(pose, pchan->name); + tchan->rotmode = pchan->rotmode; /* evaluate action using workob (it will only set the PoseChannel in question) */ what_does_obaction(cob->ob, &workob, pose, data->act, pchan->name, t); @@ -2200,9 +2200,9 @@ static void actcon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraint } } -static void actcon_evaluate (bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets) +static void actcon_evaluate(bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets) { - bConstraintTarget *ct= targets->first; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { float temp[4][4]; @@ -2232,26 +2232,26 @@ static bConstraintTypeInfo CTI_ACTION = { /* --------- Locked Track ---------- */ -static void locktrack_new_data (void *cdata) +static void locktrack_new_data(void *cdata) { - bLockTrackConstraint *data= (bLockTrackConstraint *)cdata; + bLockTrackConstraint *data = (bLockTrackConstraint *)cdata; data->trackflag = TRACK_Y; data->lockflag = LOCK_Z; } -static void locktrack_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void locktrack_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bLockTrackConstraint *data= con->data; + bLockTrackConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int locktrack_get_tars (bConstraint *con, ListBase *list) +static int locktrack_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bLockTrackConstraint *data= con->data; + bLockTrackConstraint *data = con->data; bConstraintTarget *ct; /* the following macro is used for all standard single-target constraints */ @@ -2263,21 +2263,21 @@ static int locktrack_get_tars (bConstraint *con, ListBase *list) return 0; } -static void locktrack_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void locktrack_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bLockTrackConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bLockTrackConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void locktrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void locktrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bLockTrackConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bLockTrackConstraint *data = con->data; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { float vec[3], vec2[3]; @@ -2290,217 +2290,217 @@ static void locktrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * /* Vector object -> target */ sub_v3_v3v3(vec, ct->matrix[3], cob->matrix[3]); switch (data->lockflag) { - case LOCK_X: /* LOCK X */ - { - switch (data->trackflag) { - case TRACK_Y: /* LOCK X TRACK Y */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[0]); - sub_v3_v3v3(totmat[1], vec, vec2); - normalize_v3(totmat[1]); + case LOCK_X: /* LOCK X */ + { + switch (data->trackflag) { + case TRACK_Y: /* LOCK X TRACK Y */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[0]); + sub_v3_v3v3(totmat[1], vec, vec2); + normalize_v3(totmat[1]); - /* the x axis is fixed */ - normalize_v3_v3(totmat[0], cob->matrix[0]); + /* the x axis is fixed */ + normalize_v3_v3(totmat[0], cob->matrix[0]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); + } break; - case TRACK_Z: /* LOCK X TRACK Z */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[0]); - sub_v3_v3v3(totmat[2], vec, vec2); - normalize_v3(totmat[2]); + case TRACK_Z: /* LOCK X TRACK Z */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[0]); + sub_v3_v3v3(totmat[2], vec, vec2); + normalize_v3(totmat[2]); - /* the x axis is fixed */ - normalize_v3_v3(totmat[0], cob->matrix[0]); + /* the x axis is fixed */ + normalize_v3_v3(totmat[0], cob->matrix[0]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); + } break; - case TRACK_nY: /* LOCK X TRACK -Y */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[0]); - sub_v3_v3v3(totmat[1], vec, vec2); - normalize_v3(totmat[1]); - negate_v3(totmat[1]); + case TRACK_nY: /* LOCK X TRACK -Y */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[0]); + sub_v3_v3v3(totmat[1], vec, vec2); + normalize_v3(totmat[1]); + negate_v3(totmat[1]); - /* the x axis is fixed */ - normalize_v3_v3(totmat[0], cob->matrix[0]); + /* the x axis is fixed */ + normalize_v3_v3(totmat[0], cob->matrix[0]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); + } break; - case TRACK_nZ: /* LOCK X TRACK -Z */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[0]); - sub_v3_v3v3(totmat[2], vec, vec2); - normalize_v3(totmat[2]); - negate_v3(totmat[2]); + case TRACK_nZ: /* LOCK X TRACK -Z */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[0]); + sub_v3_v3v3(totmat[2], vec, vec2); + normalize_v3(totmat[2]); + negate_v3(totmat[2]); - /* the x axis is fixed */ - normalize_v3_v3(totmat[0], cob->matrix[0]); + /* the x axis is fixed */ + normalize_v3_v3(totmat[0], cob->matrix[0]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); + } break; - default: - { - unit_m3(totmat); - } + default: + { + unit_m3(totmat); + } break; + } } - } break; - case LOCK_Y: /* LOCK Y */ - { - switch (data->trackflag) { - case TRACK_X: /* LOCK Y TRACK X */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[1]); - sub_v3_v3v3(totmat[0], vec, vec2); - normalize_v3(totmat[0]); + case LOCK_Y: /* LOCK Y */ + { + switch (data->trackflag) { + case TRACK_X: /* LOCK Y TRACK X */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[1]); + sub_v3_v3v3(totmat[0], vec, vec2); + normalize_v3(totmat[0]); - /* the y axis is fixed */ - normalize_v3_v3(totmat[1], cob->matrix[1]); + /* the y axis is fixed */ + normalize_v3_v3(totmat[1], cob->matrix[1]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); + } break; - case TRACK_Z: /* LOCK Y TRACK Z */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[1]); - sub_v3_v3v3(totmat[2], vec, vec2); - normalize_v3(totmat[2]); + case TRACK_Z: /* LOCK Y TRACK Z */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[1]); + sub_v3_v3v3(totmat[2], vec, vec2); + normalize_v3(totmat[2]); - /* the y axis is fixed */ - normalize_v3_v3(totmat[1], cob->matrix[1]); + /* the y axis is fixed */ + normalize_v3_v3(totmat[1], cob->matrix[1]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); + } break; - case TRACK_nX: /* LOCK Y TRACK -X */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[1]); - sub_v3_v3v3(totmat[0], vec, vec2); - normalize_v3(totmat[0]); - negate_v3(totmat[0]); + case TRACK_nX: /* LOCK Y TRACK -X */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[1]); + sub_v3_v3v3(totmat[0], vec, vec2); + normalize_v3(totmat[0]); + negate_v3(totmat[0]); - /* the y axis is fixed */ - normalize_v3_v3(totmat[1], cob->matrix[1]); + /* the y axis is fixed */ + normalize_v3_v3(totmat[1], cob->matrix[1]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[2], totmat[0], totmat[1]); + } break; - case TRACK_nZ: /* LOCK Y TRACK -Z */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[1]); - sub_v3_v3v3(totmat[2], vec, vec2); - normalize_v3(totmat[2]); - negate_v3(totmat[2]); + case TRACK_nZ: /* LOCK Y TRACK -Z */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[1]); + sub_v3_v3v3(totmat[2], vec, vec2); + normalize_v3(totmat[2]); + negate_v3(totmat[2]); - /* the y axis is fixed */ - normalize_v3_v3(totmat[1], cob->matrix[1]); + /* the y axis is fixed */ + normalize_v3_v3(totmat[1], cob->matrix[1]); - /* the z axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); - } + /* the z axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); + } break; - default: - { - unit_m3(totmat); - } + default: + { + unit_m3(totmat); + } break; + } } - } break; - case LOCK_Z: /* LOCK Z */ - { - switch (data->trackflag) { - case TRACK_X: /* LOCK Z TRACK X */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[2]); - sub_v3_v3v3(totmat[0], vec, vec2); - normalize_v3(totmat[0]); + case LOCK_Z: /* LOCK Z */ + { + switch (data->trackflag) { + case TRACK_X: /* LOCK Z TRACK X */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[2]); + sub_v3_v3v3(totmat[0], vec, vec2); + normalize_v3(totmat[0]); - /* the z axis is fixed */ - normalize_v3_v3(totmat[2], cob->matrix[2]); + /* the z axis is fixed */ + normalize_v3_v3(totmat[2], cob->matrix[2]); - /* the x axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); - } + /* the x axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); + } break; - case TRACK_Y: /* LOCK Z TRACK Y */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[2]); - sub_v3_v3v3(totmat[1], vec, vec2); - normalize_v3(totmat[1]); + case TRACK_Y: /* LOCK Z TRACK Y */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[2]); + sub_v3_v3v3(totmat[1], vec, vec2); + normalize_v3(totmat[1]); - /* the z axis is fixed */ - normalize_v3_v3(totmat[2], cob->matrix[2]); + /* the z axis is fixed */ + normalize_v3_v3(totmat[2], cob->matrix[2]); - /* the x axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); - } + /* the x axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); + } break; - case TRACK_nX: /* LOCK Z TRACK -X */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[2]); - sub_v3_v3v3(totmat[0], vec, vec2); - normalize_v3(totmat[0]); - negate_v3(totmat[0]); + case TRACK_nX: /* LOCK Z TRACK -X */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[2]); + sub_v3_v3v3(totmat[0], vec, vec2); + normalize_v3(totmat[0]); + negate_v3(totmat[0]); - /* the z axis is fixed */ - normalize_v3_v3(totmat[2], cob->matrix[2]); + /* the z axis is fixed */ + normalize_v3_v3(totmat[2], cob->matrix[2]); - /* the x axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); - } + /* the x axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[1], totmat[2], totmat[0]); + } break; - case TRACK_nY: /* LOCK Z TRACK -Y */ - { - /* Projection of Vector on the plane */ - project_v3_v3v3(vec2, vec, cob->matrix[2]); - sub_v3_v3v3(totmat[1], vec, vec2); - normalize_v3(totmat[1]); - negate_v3(totmat[1]); + case TRACK_nY: /* LOCK Z TRACK -Y */ + { + /* Projection of Vector on the plane */ + project_v3_v3v3(vec2, vec, cob->matrix[2]); + sub_v3_v3v3(totmat[1], vec, vec2); + normalize_v3(totmat[1]); + negate_v3(totmat[1]); - /* the z axis is fixed */ - normalize_v3_v3(totmat[2], cob->matrix[2]); + /* the z axis is fixed */ + normalize_v3_v3(totmat[2], cob->matrix[2]); - /* the x axis gets mapped onto a third orthogonal vector */ - cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); - } + /* the x axis gets mapped onto a third orthogonal vector */ + cross_v3_v3v3(totmat[0], totmat[1], totmat[2]); + } break; - default: - { - unit_m3(totmat); - } + default: + { + unit_m3(totmat); + } break; + } } - } break; - default: - { - unit_m3(totmat); - } + default: + { + unit_m3(totmat); + } break; } /* Block to keep matrix heading */ @@ -2508,16 +2508,16 @@ static void locktrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * normalize_m3(tmpmat); invert_m3_m3(invmat, tmpmat); mul_m3_m3m3(tmpmat, totmat, invmat); - totmat[0][0] = tmpmat[0][0];totmat[0][1] = tmpmat[0][1];totmat[0][2] = tmpmat[0][2]; - totmat[1][0] = tmpmat[1][0];totmat[1][1] = tmpmat[1][1];totmat[1][2] = tmpmat[1][2]; - totmat[2][0] = tmpmat[2][0];totmat[2][1] = tmpmat[2][1];totmat[2][2] = tmpmat[2][2]; + totmat[0][0] = tmpmat[0][0]; totmat[0][1] = tmpmat[0][1]; totmat[0][2] = tmpmat[0][2]; + totmat[1][0] = tmpmat[1][0]; totmat[1][1] = tmpmat[1][1]; totmat[1][2] = tmpmat[1][2]; + totmat[2][0] = tmpmat[2][0]; totmat[2][1] = tmpmat[2][1]; totmat[2][2] = tmpmat[2][2]; copy_m4_m4(tmat, cob->matrix); mdet = determinant_m3(totmat[0][0], totmat[0][1], totmat[0][2], totmat[1][0], totmat[1][1], totmat[1][2], totmat[2][0], totmat[2][1], totmat[2][2]); - if (mdet==0) { + if (mdet == 0) { unit_m3(totmat); } @@ -2543,25 +2543,25 @@ static bConstraintTypeInfo CTI_LOCKTRACK = { /* ---------- Limit Distance Constraint ----------- */ -static void distlimit_new_data (void *cdata) +static void distlimit_new_data(void *cdata) { - bDistLimitConstraint *data= (bDistLimitConstraint *)cdata; + bDistLimitConstraint *data = (bDistLimitConstraint *)cdata; - data->dist= 0.0f; + data->dist = 0.0f; } -static void distlimit_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void distlimit_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bDistLimitConstraint *data= con->data; + bDistLimitConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int distlimit_get_tars (bConstraint *con, ListBase *list) +static int distlimit_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bDistLimitConstraint *data= con->data; + bDistLimitConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -2573,40 +2573,40 @@ static int distlimit_get_tars (bConstraint *con, ListBase *list) return 0; } -static void distlimit_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void distlimit_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bDistLimitConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bDistLimitConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void distlimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void distlimit_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bDistLimitConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bDistLimitConstraint *data = con->data; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { - float dvec[3], dist=0.0f, sfac=1.0f; - short clamp_surf= 0; + float dvec[3], dist = 0.0f, sfac = 1.0f; + short clamp_surf = 0; /* calculate our current distance from the target */ - dist= len_v3v3(cob->matrix[3], ct->matrix[3]); + dist = len_v3v3(cob->matrix[3], ct->matrix[3]); /* set distance (flag is only set when user demands it) */ if (data->dist == 0) - data->dist= dist; + data->dist = dist; /* check if we're which way to clamp from, and calculate interpolation factor (if needed) */ if (data->mode == LIMITDIST_OUTSIDE) { /* if inside, then move to surface */ if (dist <= data->dist) { - clamp_surf= 1; - if (dist != 0.0f) sfac= data->dist / dist; + clamp_surf = 1; + if (dist != 0.0f) sfac = data->dist / dist; } /* if soft-distance is enabled, start fading once owner is dist+softdist from the target */ else if (data->flag & LIMITDIST_USESOFT) { @@ -2618,24 +2618,24 @@ static void distlimit_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * else if (data->mode == LIMITDIST_INSIDE) { /* if outside, then move to surface */ if (dist >= data->dist) { - clamp_surf= 1; - if (dist != 0.0f) sfac= data->dist / dist; + clamp_surf = 1; + if (dist != 0.0f) sfac = data->dist / dist; } /* if soft-distance is enabled, start fading once owner is dist-soft from the target */ else if (data->flag & LIMITDIST_USESOFT) { // FIXME: there's a problem with "jumping" when this kicks in if (dist >= (data->dist - data->soft)) { - sfac = (float)( data->soft*(1.0f - expf(-(dist - data->dist)/data->soft)) + data->dist ); + sfac = (float)(data->soft * (1.0f - expf(-(dist - data->dist) / data->soft)) + data->dist); if (dist != 0.0f) sfac /= dist; - clamp_surf= 1; + clamp_surf = 1; } } } else { - if (IS_EQF(dist, data->dist)==0) { - clamp_surf= 1; - if (dist != 0.0f) sfac= data->dist / dist; + if (IS_EQF(dist, data->dist) == 0) { + clamp_surf = 1; + if (dist != 0.0f) sfac = data->dist / dist; } } @@ -2667,9 +2667,9 @@ static bConstraintTypeInfo CTI_DISTLIMIT = { /* ---------- Stretch To ------------ */ -static void stretchto_new_data (void *cdata) +static void stretchto_new_data(void *cdata) { - bStretchToConstraint *data= (bStretchToConstraint *)cdata; + bStretchToConstraint *data = (bStretchToConstraint *)cdata; data->volmode = 0; data->plane = 0; @@ -2677,18 +2677,18 @@ static void stretchto_new_data (void *cdata) data->bulge = 1.0; } -static void stretchto_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void stretchto_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bStretchToConstraint *data= con->data; + bStretchToConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int stretchto_get_tars (bConstraint *con, ListBase *list) +static int stretchto_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bStretchToConstraint *data= con->data; + bStretchToConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -2700,21 +2700,21 @@ static int stretchto_get_tars (bConstraint *con, ListBase *list) return 0; } -static void stretchto_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void stretchto_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bStretchToConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bStretchToConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void stretchto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void stretchto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bStretchToConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bStretchToConstraint *data = con->data; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { @@ -2750,40 +2750,40 @@ static void stretchto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * if (data->bulge == 0) data->bulge = 1.0; - scale[1] = dist/data->orglength; + scale[1] = dist / data->orglength; switch (data->volmode) { - /* volume preserving scaling */ - case VOLUME_XZ : - scale[0] = 1.0f - (float)sqrt(data->bulge) + (float)sqrt(data->bulge*(data->orglength/dist)); - scale[2] = scale[0]; - break; - case VOLUME_X: - scale[0] = 1.0f + data->bulge * (data->orglength /dist - 1); - scale[2] = 1.0; - break; - case VOLUME_Z: - scale[0] = 1.0; - scale[2] = 1.0f + data->bulge * (data->orglength /dist - 1); - break; + /* volume preserving scaling */ + case VOLUME_XZ: + scale[0] = 1.0f - (float)sqrt(data->bulge) + (float)sqrt(data->bulge * (data->orglength / dist)); + scale[2] = scale[0]; + break; + case VOLUME_X: + scale[0] = 1.0f + data->bulge * (data->orglength / dist - 1); + scale[2] = 1.0; + break; + case VOLUME_Z: + scale[0] = 1.0; + scale[2] = 1.0f + data->bulge * (data->orglength / dist - 1); + break; /* don't care for volume */ - case NO_VOLUME: - scale[0] = 1.0; - scale[2] = 1.0; - break; - default: /* should not happen, but in case*/ - return; + case NO_VOLUME: + scale[0] = 1.0; + scale[2] = 1.0; + break; + default: /* should not happen, but in case*/ + return; } /* switch (data->volmode) */ /* Clear the object's rotation and scale */ - cob->matrix[0][0]=size[0]*scale[0]; - cob->matrix[0][1]=0; - cob->matrix[0][2]=0; - cob->matrix[1][0]=0; - cob->matrix[1][1]=size[1]*scale[1]; - cob->matrix[1][2]=0; - cob->matrix[2][0]=0; - cob->matrix[2][1]=0; - cob->matrix[2][2]=size[2]*scale[2]; + cob->matrix[0][0] = size[0] * scale[0]; + cob->matrix[0][1] = 0; + cob->matrix[0][2] = 0; + cob->matrix[1][0] = 0; + cob->matrix[1][1] = size[1] * scale[1]; + cob->matrix[1][2] = 0; + cob->matrix[2][0] = 0; + cob->matrix[2][1] = 0; + cob->matrix[2][2] = size[2] * scale[2]; sub_v3_v3v3(vec, cob->matrix[3], ct->matrix[3]); normalize_v3(vec); @@ -2791,32 +2791,32 @@ static void stretchto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * /* new Y aligns object target connection*/ negate_v3_v3(totmat[1], vec); switch (data->plane) { - case PLANE_X: - /* build new Z vector */ - /* othogonal to "new Y" "old X! plane */ - cross_v3_v3v3(orth, vec, xx); - normalize_v3(orth); - - /* new Z*/ - copy_v3_v3(totmat[2], orth); - - /* we decided to keep X plane*/ - cross_v3_v3v3(xx, orth, vec); - normalize_v3_v3(totmat[0], xx); - break; - case PLANE_Z: - /* build new X vector */ - /* othogonal to "new Y" "old Z! plane */ - cross_v3_v3v3(orth, vec, zz); - normalize_v3(orth); - - /* new X */ - negate_v3_v3(totmat[0], orth); - - /* we decided to keep Z */ - cross_v3_v3v3(zz, orth, vec); - normalize_v3_v3(totmat[2], zz); - break; + case PLANE_X: + /* build new Z vector */ + /* othogonal to "new Y" "old X! plane */ + cross_v3_v3v3(orth, vec, xx); + normalize_v3(orth); + + /* new Z*/ + copy_v3_v3(totmat[2], orth); + + /* we decided to keep X plane*/ + cross_v3_v3v3(xx, orth, vec); + normalize_v3_v3(totmat[0], xx); + break; + case PLANE_Z: + /* build new X vector */ + /* othogonal to "new Y" "old Z! plane */ + cross_v3_v3v3(orth, vec, zz); + normalize_v3(orth); + + /* new X */ + negate_v3_v3(totmat[0], orth); + + /* we decided to keep Z */ + cross_v3_v3v3(zz, orth, vec); + normalize_v3_v3(totmat[2], zz); + break; } /* switch (data->plane) */ copy_m4_m4(tmat, cob->matrix); @@ -2841,9 +2841,9 @@ static bConstraintTypeInfo CTI_STRETCHTO = { /* ---------- Floor ------------ */ -static void minmax_new_data (void *cdata) +static void minmax_new_data(void *cdata) { - bMinMaxConstraint *data= (bMinMaxConstraint *)cdata; + bMinMaxConstraint *data = (bMinMaxConstraint *)cdata; data->minmaxflag = TRACK_Z; data->offset = 0.0f; @@ -2851,18 +2851,18 @@ static void minmax_new_data (void *cdata) data->flag = 0; } -static void minmax_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void minmax_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bMinMaxConstraint *data= con->data; + bMinMaxConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int minmax_get_tars (bConstraint *con, ListBase *list) +static int minmax_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bMinMaxConstraint *data= con->data; + bMinMaxConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -2874,21 +2874,21 @@ static int minmax_get_tars (bConstraint *con, ListBase *list) return 0; } -static void minmax_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void minmax_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bMinMaxConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bMinMaxConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void minmax_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void minmax_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bMinMaxConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bMinMaxConstraint *data = con->data; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { @@ -2908,38 +2908,38 @@ static void minmax_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *tar } switch (data->minmaxflag) { - case TRACK_Z: - val1 = tarmat[3][2]; - val2 = obmat[3][2]-data->offset; - index = 2; - break; - case TRACK_Y: - val1 = tarmat[3][1]; - val2 = obmat[3][1]-data->offset; - index = 1; - break; - case TRACK_X: - val1 = tarmat[3][0]; - val2 = obmat[3][0]-data->offset; - index = 0; - break; - case TRACK_nZ: - val2 = tarmat[3][2]; - val1 = obmat[3][2]-data->offset; - index = 2; - break; - case TRACK_nY: - val2 = tarmat[3][1]; - val1 = obmat[3][1]-data->offset; - index = 1; - break; - case TRACK_nX: - val2 = tarmat[3][0]; - val1 = obmat[3][0]-data->offset; - index = 0; - break; - default: - return; + case TRACK_Z: + val1 = tarmat[3][2]; + val2 = obmat[3][2] - data->offset; + index = 2; + break; + case TRACK_Y: + val1 = tarmat[3][1]; + val2 = obmat[3][1] - data->offset; + index = 1; + break; + case TRACK_X: + val1 = tarmat[3][0]; + val2 = obmat[3][0] - data->offset; + index = 0; + break; + case TRACK_nZ: + val2 = tarmat[3][2]; + val1 = obmat[3][2] - data->offset; + index = 2; + break; + case TRACK_nY: + val2 = tarmat[3][1]; + val1 = obmat[3][1] - data->offset; + index = 1; + break; + case TRACK_nX: + val2 = tarmat[3][0]; + val1 = obmat[3][0] - data->offset; + index = 0; + break; + default: + return; } if (val1 > val2) { @@ -2985,27 +2985,27 @@ static bConstraintTypeInfo CTI_MINMAX = { /* ------- RigidBody Joint ---------- */ -static void rbj_new_data (void *cdata) +static void rbj_new_data(void *cdata) { - bRigidBodyJointConstraint *data= (bRigidBodyJointConstraint *)cdata; + bRigidBodyJointConstraint *data = (bRigidBodyJointConstraint *)cdata; // removed code which set target of this constraint - data->type=1; + data->type = 1; } -static void rbj_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void rbj_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bRigidBodyJointConstraint *data= con->data; + bRigidBodyJointConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); - func(con, (ID**)&data->child, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); + func(con, (ID **)&data->child, FALSE, userdata); } -static int rbj_get_tars (bConstraint *con, ListBase *list) +static int rbj_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bRigidBodyJointConstraint *data= con->data; + bRigidBodyJointConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints without subtargets */ @@ -3017,11 +3017,11 @@ static int rbj_get_tars (bConstraint *con, ListBase *list) return 0; } -static void rbj_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void rbj_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bRigidBodyJointConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bRigidBodyJointConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGETNS_FLUSH_TARS(con, data->tar, ct, list, nocopy) @@ -3045,18 +3045,18 @@ static bConstraintTypeInfo CTI_RIGIDBODYJOINT = { /* -------- Clamp To ---------- */ -static void clampto_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void clampto_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bClampToConstraint *data= con->data; + bClampToConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int clampto_get_tars (bConstraint *con, ListBase *list) +static int clampto_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bClampToConstraint *data= con->data; + bClampToConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints without subtargets */ @@ -3068,28 +3068,28 @@ static int clampto_get_tars (bConstraint *con, ListBase *list) return 0; } -static void clampto_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void clampto_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bClampToConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bClampToConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGETNS_FLUSH_TARS(con, data->tar, ct, list, nocopy) } } -static void clampto_get_tarmat (bConstraint *UNUSED(con), bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void clampto_get_tarmat(bConstraint *UNUSED(con), bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { if (VALID_CONS_TARGET(ct)) { - Curve *cu= ct->tar->data; + Curve *cu = ct->tar->data; /* note: when creating constraints that follow path, the curve gets the CU_PATH set now, * currently for paths to work it needs to go through the bevlist/displist system (ton) */ /* only happens on reload file, but violates depsgraph still... fix! */ - if (cu->path==NULL || cu->path->data==NULL) + if (cu->path == NULL || cu->path->data == NULL) makeDispListCurveTypes(cob->scene, ct->tar, 0); } @@ -3100,17 +3100,17 @@ static void clampto_get_tarmat (bConstraint *UNUSED(con), bConstraintOb *cob, bC unit_m4(ct->matrix); } -static void clampto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bClampToConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bClampToConstraint *data = con->data; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target and it is a curve */ if (VALID_CONS_TARGET(ct) && (ct->tar->type == OB_CURVE)) { - Curve *cu= data->tar->data; + Curve *cu = data->tar->data; float obmat[4][4], ownLoc[3]; float curveMin[3], curveMax[3]; - float targetMatrix[4][4]= MAT4_UNITY; + float targetMatrix[4][4] = MAT4_UNITY; copy_m4_m4(obmat, cob->matrix); copy_v3_v3(ownLoc, obmat[3]); @@ -3134,20 +3134,20 @@ static void clampto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta * extent. Otherwise, default to the x-axis, as that is quite * frequently used. */ - if ((size[2]>size[0]) && (size[2]>size[1])) - clamp_axis= CLAMPTO_Z - 1; - else if ((size[1]>size[0]) && (size[1]>size[2])) - clamp_axis= CLAMPTO_Y - 1; + if ((size[2] > size[0]) && (size[2] > size[1])) + clamp_axis = CLAMPTO_Z - 1; + else if ((size[1] > size[0]) && (size[1] > size[2])) + clamp_axis = CLAMPTO_Y - 1; else clamp_axis = CLAMPTO_X - 1; } else - clamp_axis= data->flag - 1; + clamp_axis = data->flag - 1; /* 2. determine position relative to curve on a 0-1 scale based on bounding box */ if (data->flag2 & CLAMPTO_CYCLIC) { /* cyclic, so offset within relative bounding box is used */ - float len= (curveMax[clamp_axis] - curveMin[clamp_axis]); + float len = (curveMax[clamp_axis] - curveMin[clamp_axis]); float offset; /* check to make sure len is not so close to zero that it'll cause errors */ @@ -3162,7 +3162,7 @@ static void clampto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta } else if (ownLoc[clamp_axis] > curveMax[clamp_axis]) { /* bounding-box range is after */ - offset= curveMax[clamp_axis] + (int)((ownLoc[clamp_axis] - curveMax[clamp_axis]) / len) * len; + offset = curveMax[clamp_axis] + (int)((ownLoc[clamp_axis] - curveMax[clamp_axis]) / len) * len; /* now, we calculate as per normal, except using offset instead of curveMax[clamp_axis] */ curvetime = (ownLoc[clamp_axis] - offset) / (len); @@ -3174,7 +3174,7 @@ static void clampto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta } else { /* as length is close to zero, curvetime by default should be 0 (i.e. the start) */ - curvetime= 0.0f; + curvetime = 0.0f; } } else { @@ -3183,7 +3183,7 @@ static void clampto_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *ta curvetime = 0.0f; else if (ownLoc[clamp_axis] >= curveMax[clamp_axis]) curvetime = 1.0f; - else if ( IS_EQ((curveMax[clamp_axis] - curveMin[clamp_axis]), 0) == 0 ) + else if (IS_EQ((curveMax[clamp_axis] - curveMin[clamp_axis]), 0) == 0) curvetime = (ownLoc[clamp_axis] - curveMin[clamp_axis]) / (curveMax[clamp_axis] - curveMin[clamp_axis]); else curvetime = 0.0f; @@ -3220,27 +3220,27 @@ static bConstraintTypeInfo CTI_CLAMPTO = { /* ---------- Transform Constraint ----------- */ -static void transform_new_data (void *cdata) +static void transform_new_data(void *cdata) { - bTransformConstraint *data= (bTransformConstraint *)cdata; + bTransformConstraint *data = (bTransformConstraint *)cdata; - data->map[0]= 0; - data->map[1]= 1; - data->map[2]= 2; + data->map[0] = 0; + data->map[1] = 1; + data->map[2] = 2; } -static void transform_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void transform_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bTransformConstraint *data= con->data; + bTransformConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int transform_get_tars (bConstraint *con, ListBase *list) +static int transform_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bTransformConstraint *data= con->data; + bTransformConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -3252,21 +3252,21 @@ static int transform_get_tars (bConstraint *con, ListBase *list) return 0; } -static void transform_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void transform_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bTransformConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bTransformConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void transform_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void transform_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bTransformConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bTransformConstraint *data = con->data; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { @@ -3295,21 +3295,21 @@ static void transform_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * /* determine where in range current transforms lie */ if (data->expo) { - for (i=0; i<3; i++) { + for (i = 0; i < 3; i++) { if (data->from_max[i] - data->from_min[i]) - sval[i]= (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]); + sval[i] = (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]); else - sval[i]= 0.0f; + sval[i] = 0.0f; } } else { /* clamp transforms out of range */ - for (i=0; i<3; i++) { + for (i = 0; i < 3; i++) { CLAMP(dvec[i], data->from_min[i], data->from_max[i]); if (data->from_max[i] - data->from_min[i]) - sval[i]= (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]); + sval[i] = (dvec[i] - data->from_min[i]) / (data->from_max[i] - data->from_min[i]); else - sval[i]= 0.0f; + sval[i] = 0.0f; } } @@ -3317,18 +3317,18 @@ static void transform_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * /* apply transforms */ switch (data->to) { case 2: /* scaling */ - for (i=0; i<3; i++) - size[i]= data->to_min[i] + (sval[(int)data->map[i]] * (data->to_max[i] - data->to_min[i])); + for (i = 0; i < 3; i++) + size[i] = data->to_min[i] + (sval[(int)data->map[i]] * (data->to_max[i] - data->to_min[i])); break; case 1: /* rotation */ - for (i=0; i<3; i++) { + for (i = 0; i < 3; i++) { float tmin, tmax; - tmin= data->to_min[i]; - tmax= data->to_max[i]; + tmin = data->to_min[i]; + tmax = data->to_max[i]; /* all values here should be in degrees */ - eul[i]= tmin + (sval[(int)data->map[i]] * (tmax - tmin)); + eul[i] = tmin + (sval[(int)data->map[i]] * (tmax - tmin)); /* now convert final value back to radians */ eul[i] = DEG2RADF(eul[i]); @@ -3336,8 +3336,8 @@ static void transform_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * break; default: /* location */ /* get new location */ - for (i=0; i<3; i++) - loc[i]= (data->to_min[i] + (sval[(int)data->map[i]] * (data->to_max[i] - data->to_min[i]))); + for (i = 0; i < 3; i++) + loc[i] = (data->to_min[i] + (sval[(int)data->map[i]] * (data->to_max[i] - data->to_min[i]))); /* add original location back on (so that it can still be moved) */ add_v3_v3v3(loc, cob->matrix[3], loc); @@ -3366,15 +3366,15 @@ static bConstraintTypeInfo CTI_TRANSFORM = { /* ---------- Shrinkwrap Constraint ----------- */ -static void shrinkwrap_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void shrinkwrap_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { bShrinkwrapConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->target, FALSE, userdata); + func(con, (ID **)&data->target, FALSE, userdata); } -static int shrinkwrap_get_tars (bConstraint *con, ListBase *list) +static int shrinkwrap_get_tars(bConstraint *con, ListBase *list) { if (con && list) { bShrinkwrapConstraint *data = con->data; @@ -3389,22 +3389,22 @@ static int shrinkwrap_get_tars (bConstraint *con, ListBase *list) } -static void shrinkwrap_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void shrinkwrap_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { bShrinkwrapConstraint *data = con->data; - bConstraintTarget *ct= list->first; + bConstraintTarget *ct = list->first; SINGLETARGETNS_FLUSH_TARS(con, data->target, ct, list, nocopy) } } -static void shrinkwrap_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void shrinkwrap_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { bShrinkwrapConstraint *scon = (bShrinkwrapConstraint *) con->data; - if ( VALID_CONS_TARGET(ct) && (ct->tar->type == OB_MESH) ) { + if (VALID_CONS_TARGET(ct) && (ct->tar->type == OB_MESH) ) { int fail = FALSE; float co[3] = {0.0f, 0.0f, 0.0f}; float no[3] = {0.0f, 0.0f, 0.0f}; @@ -3415,7 +3415,7 @@ static void shrinkwrap_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr BVHTreeRayHit hit; BVHTreeNearest nearest; - BVHTreeFromMesh treeData= {NULL}; + BVHTreeFromMesh treeData = {NULL}; nearest.index = -1; nearest.dist = FLT_MAX; @@ -3448,10 +3448,10 @@ static void shrinkwrap_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr dist = len_v3v3(co, nearest.co); if (dist != 0.0f) { - interp_v3_v3v3(co, co, nearest.co, (dist - scon->dist)/dist); /* linear interpolation */ + interp_v3_v3v3(co, co, nearest.co, (dist - scon->dist) / dist); /* linear interpolation */ } space_transform_invert(&transform, co); - break; + break; case MOD_SHRINKWRAP_PROJECT: if (scon->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS) no[0] = 1.0f; @@ -3477,7 +3477,7 @@ static void shrinkwrap_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr break; } copy_v3_v3(co, hit.co); - break; + break; } free_bvhtree_from_mesh(&treeData); @@ -3496,9 +3496,9 @@ static void shrinkwrap_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstr } } -static void shrinkwrap_evaluate (bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets) +static void shrinkwrap_evaluate(bConstraint *UNUSED(con), bConstraintOb *cob, ListBase *targets) { - bConstraintTarget *ct= targets->first; + bConstraintTarget *ct = targets->first; /* only evaluate if there is a target */ if (VALID_CONS_TARGET(ct)) { @@ -3523,25 +3523,25 @@ static bConstraintTypeInfo CTI_SHRINKWRAP = { /* --------- Damped Track ---------- */ -static void damptrack_new_data (void *cdata) +static void damptrack_new_data(void *cdata) { - bDampTrackConstraint *data= (bDampTrackConstraint *)cdata; + bDampTrackConstraint *data = (bDampTrackConstraint *)cdata; data->trackflag = TRACK_Y; } -static void damptrack_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void damptrack_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bDampTrackConstraint *data= con->data; + bDampTrackConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int damptrack_get_tars (bConstraint *con, ListBase *list) +static int damptrack_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bDampTrackConstraint *data= con->data; + bDampTrackConstraint *data = con->data; bConstraintTarget *ct; /* the following macro is used for all standard single-target constraints */ @@ -3553,11 +3553,11 @@ static int damptrack_get_tars (bConstraint *con, ListBase *list) return 0; } -static void damptrack_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void damptrack_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bDampTrackConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bDampTrackConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) @@ -3566,14 +3566,14 @@ static void damptrack_flush_tars (bConstraint *con, ListBase *list, short nocopy /* array of direction vectors for the tracking flags */ static const float track_dir_vecs[6][3] = { - {+1, 0, 0}, {0, +1, 0}, {0, 0, +1}, /* TRACK_X, TRACK_Y, TRACK_Z */ - {-1, 0, 0}, {0, -1, 0}, {0, 0, -1} /* TRACK_NX, TRACK_NY, TRACK_NZ */ + {+1, 0, 0}, {0, +1, 0}, {0, 0, +1}, /* TRACK_X, TRACK_Y, TRACK_Z */ + {-1, 0, 0}, {0, -1, 0}, {0, 0, -1} /* TRACK_NX, TRACK_NY, TRACK_NZ */ }; -static void damptrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void damptrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bDampTrackConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bDampTrackConstraint *data = con->data; + bConstraintTarget *ct = targets->first; if (VALID_CONS_TARGET(ct)) { float obvec[3], tarvec[3], obloc[3]; @@ -3614,8 +3614,8 @@ static void damptrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase * */ cross_v3_v3v3(raxis, obvec, tarvec); - rangle= dot_v3v3(obvec, tarvec); - rangle= acos( MAX2(-1.0f, MIN2(1.0f, rangle)) ); + rangle = dot_v3v3(obvec, tarvec); + rangle = acos(MAX2(-1.0f, MIN2(1.0f, rangle)) ); /* construct rotation matrix from the axis-angle rotation found above * - this call takes care to make sure that the axis provided is a unit vector first @@ -3650,43 +3650,43 @@ static bConstraintTypeInfo CTI_DAMPTRACK = { /* ----------- Spline IK ------------ */ -static void splineik_free (bConstraint *con) +static void splineik_free(bConstraint *con) { - bSplineIKConstraint *data= con->data; + bSplineIKConstraint *data = con->data; /* binding array */ if (data->points) MEM_freeN(data->points); } -static void splineik_copy (bConstraint *con, bConstraint *srccon) +static void splineik_copy(bConstraint *con, bConstraint *srccon) { - bSplineIKConstraint *src= srccon->data; - bSplineIKConstraint *dst= con->data; + bSplineIKConstraint *src = srccon->data; + bSplineIKConstraint *dst = con->data; /* copy the binding array */ - dst->points= MEM_dupallocN(src->points); + dst->points = MEM_dupallocN(src->points); } -static void splineik_new_data (void *cdata) +static void splineik_new_data(void *cdata) { - bSplineIKConstraint *data= (bSplineIKConstraint *)cdata; + bSplineIKConstraint *data = (bSplineIKConstraint *)cdata; - data->chainlen= 1; + data->chainlen = 1; } -static void splineik_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void splineik_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bSplineIKConstraint *data= con->data; + bSplineIKConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int splineik_get_tars (bConstraint *con, ListBase *list) +static int splineik_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bSplineIKConstraint *data= con->data; + bSplineIKConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints without subtargets */ @@ -3698,28 +3698,28 @@ static int splineik_get_tars (bConstraint *con, ListBase *list) return 0; } -static void splineik_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void splineik_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bSplineIKConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bSplineIKConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGETNS_FLUSH_TARS(con, data->tar, ct, list, nocopy) } } -static void splineik_get_tarmat (bConstraint *UNUSED(con), bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) +static void splineik_get_tarmat(bConstraint *UNUSED(con), bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime)) { if (VALID_CONS_TARGET(ct)) { - Curve *cu= ct->tar->data; + Curve *cu = ct->tar->data; /* note: when creating constraints that follow path, the curve gets the CU_PATH set now, * currently for paths to work it needs to go through the bevlist/displist system (ton) */ /* only happens on reload file, but violates depsgraph still... fix! */ - if (cu->path==NULL || cu->path->data==NULL) + if (cu->path == NULL || cu->path->data == NULL) makeDispListCurveTypes(cob->scene, ct->tar, 0); } @@ -3747,18 +3747,18 @@ static bConstraintTypeInfo CTI_SPLINEIK = { /* ----------- Pivot ------------- */ -static void pivotcon_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata) +static void pivotcon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bPivotConstraint *data= con->data; + bPivotConstraint *data = con->data; /* target only */ - func(con, (ID**)&data->tar, FALSE, userdata); + func(con, (ID **)&data->tar, FALSE, userdata); } -static int pivotcon_get_tars (bConstraint *con, ListBase *list) +static int pivotcon_get_tars(bConstraint *con, ListBase *list) { if (con && list) { - bPivotConstraint *data= con->data; + bPivotConstraint *data = con->data; bConstraintTarget *ct; /* standard target-getting macro for single-target constraints */ @@ -3770,21 +3770,21 @@ static int pivotcon_get_tars (bConstraint *con, ListBase *list) return 0; } -static void pivotcon_flush_tars (bConstraint *con, ListBase *list, short nocopy) +static void pivotcon_flush_tars(bConstraint *con, ListBase *list, short nocopy) { if (con && list) { - bPivotConstraint *data= con->data; - bConstraintTarget *ct= list->first; + bPivotConstraint *data = con->data; + bConstraintTarget *ct = list->first; /* the following macro is used for all standard single-target constraints */ SINGLETARGET_FLUSH_TARS(con, data->tar, data->subtarget, ct, list, nocopy) } } -static void pivotcon_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *targets) +static void pivotcon_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *targets) { - bPivotConstraint *data= con->data; - bConstraintTarget *ct= targets->first; + bPivotConstraint *data = con->data; + bConstraintTarget *ct = targets->first; float pivot[3], vec[3]; float rotMat[3][3]; @@ -3845,11 +3845,11 @@ static void pivotcon_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *t } /* perform the pivoting... */ - /* 1. take the vector from owner to the pivot */ + /* 1. take the vector from owner to the pivot */ sub_v3_v3v3(vec, cob->matrix[3], pivot); - /* 2. rotate this vector by the rotation of the object... */ + /* 2. rotate this vector by the rotation of the object... */ mul_m3_v3(rotMat, vec); - /* 3. make the rotation in terms of the pivot now */ + /* 3. make the rotation in terms of the pivot now */ add_v3_v3v3(cob->matrix[3], pivot, vec); } @@ -3883,9 +3883,9 @@ static void followtrack_id_looper(bConstraint *con, ConstraintIDFunc func, void { bFollowTrackConstraint *data = con->data; - func(con, (ID**)&data->clip, TRUE, userdata); - func(con, (ID**)&data->camera, FALSE, userdata); - func(con, (ID**)&data->depth_ob, FALSE, userdata); + func(con, (ID **)&data->clip, TRUE, userdata); + func(con, (ID **)&data->camera, FALSE, userdata); + func(con, (ID **)&data->depth_ob, FALSE, userdata); } static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) @@ -3896,10 +3896,10 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase MovieTracking *tracking; MovieTrackingTrack *track; MovieTrackingObject *tracking_object; - Object *camob= data->camera ? data->camera : scene->camera; + Object *camob = data->camera ? data->camera : scene->camera; if (data->flag & FOLLOWTRACK_ACTIVECLIP) - clip= scene->clip; + clip = scene->clip; if (!clip || !data->track[0] || !camob) return; @@ -3925,7 +3925,7 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase copy_m4_m4(obmat, cob->matrix); - if ((tracking_object->flag & TRACKING_OBJECT_CAMERA)==0) { + if ((tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0) { float imat[4][4]; copy_m4_m4(mat, camob->obmat); @@ -3947,7 +3947,7 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase else { MovieTrackingMarker *marker; float vec[3], disp[3], axis[3], mat[4][4]; - float aspect= (scene->r.xsch * scene->r.xasp) / (scene->r.ysch * scene->r.yasp); + float aspect = (scene->r.xsch * scene->r.xasp) / (scene->r.ysch * scene->r.yasp); float len, d; BKE_object_where_is_calc_mat4(scene, camob, mat); @@ -3995,7 +3995,7 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase copy_v3_v3(cob->matrix[3], disp); } else { - d= (len * params.sensor_x) / (2.0f * params.lens); + d = (len * params.sensor_x) / (2.0f * params.lens); vec[0] = d * (2.0f * (pos[0] + params.shiftx) - 1.0f); vec[1] = d * (2.0f * (pos[1] + params.shifty) - 1.0f); @@ -4076,7 +4076,7 @@ static void camerasolver_id_looper(bConstraint *con, ConstraintIDFunc func, void { bCameraSolverConstraint *data = con->data; - func(con, (ID**)&data->clip, TRUE, userdata); + func(con, (ID **)&data->clip, TRUE, userdata); } static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) @@ -4129,10 +4129,10 @@ static void objectsolver_new_data(void *cdata) static void objectsolver_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata) { - bObjectSolverConstraint *data= con->data; + bObjectSolverConstraint *data = con->data; - func(con, (ID**)&data->clip, FALSE, userdata); - func(con, (ID**)&data->camera, FALSE, userdata); + func(con, (ID **)&data->clip, FALSE, userdata); + func(con, (ID **)&data->camera, FALSE, userdata); } static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets)) @@ -4143,7 +4143,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase Object *camob = data->camera ? data->camera : scene->camera; if (data->flag & OBJECTSOLVER_ACTIVECLIP) - clip= scene->clip; + clip = scene->clip; if (!camob || !clip) return; @@ -4196,46 +4196,46 @@ static bConstraintTypeInfo CTI_OBJECTSOLVER = { /* These globals only ever get directly accessed in this file */ static bConstraintTypeInfo *constraintsTypeInfo[NUM_CONSTRAINT_TYPES]; -static short CTI_INIT= 1; /* when non-zero, the list needs to be updated */ +static short CTI_INIT = 1; /* when non-zero, the list needs to be updated */ /* This function only gets called when CTI_INIT is non-zero */ -static void constraints_init_typeinfo (void) -{ - constraintsTypeInfo[0]= NULL; /* 'Null' Constraint */ - constraintsTypeInfo[1]= &CTI_CHILDOF; /* ChildOf Constraint */ - constraintsTypeInfo[2]= &CTI_TRACKTO; /* TrackTo Constraint */ - constraintsTypeInfo[3]= &CTI_KINEMATIC; /* IK Constraint */ - constraintsTypeInfo[4]= &CTI_FOLLOWPATH; /* Follow-Path Constraint */ - constraintsTypeInfo[5]= &CTI_ROTLIMIT; /* Limit Rotation Constraint */ - constraintsTypeInfo[6]= &CTI_LOCLIMIT; /* Limit Location Constraint */ - constraintsTypeInfo[7]= &CTI_SIZELIMIT; /* Limit Scaling Constraint */ - constraintsTypeInfo[8]= &CTI_ROTLIKE; /* Copy Rotation Constraint */ - constraintsTypeInfo[9]= &CTI_LOCLIKE; /* Copy Location Constraint */ - constraintsTypeInfo[10]= &CTI_SIZELIKE; /* Copy Scaling Constraint */ - constraintsTypeInfo[11]= &CTI_PYTHON; /* Python/Script Constraint */ - constraintsTypeInfo[12]= &CTI_ACTION; /* Action Constraint */ - constraintsTypeInfo[13]= &CTI_LOCKTRACK; /* Locked-Track Constraint */ - constraintsTypeInfo[14]= &CTI_DISTLIMIT; /* Limit Distance Constraint */ - constraintsTypeInfo[15]= &CTI_STRETCHTO; /* StretchTo Constaint */ - constraintsTypeInfo[16]= &CTI_MINMAX; /* Floor Constraint */ - constraintsTypeInfo[17]= &CTI_RIGIDBODYJOINT; /* RigidBody Constraint */ - constraintsTypeInfo[18]= &CTI_CLAMPTO; /* ClampTo Constraint */ - constraintsTypeInfo[19]= &CTI_TRANSFORM; /* Transformation Constraint */ - constraintsTypeInfo[20]= &CTI_SHRINKWRAP; /* Shrinkwrap Constraint */ - constraintsTypeInfo[21]= &CTI_DAMPTRACK; /* Damped TrackTo Constraint */ - constraintsTypeInfo[22]= &CTI_SPLINEIK; /* Spline IK Constraint */ - constraintsTypeInfo[23]= &CTI_TRANSLIKE; /* Copy Transforms Constraint */ - constraintsTypeInfo[24]= &CTI_SAMEVOL; /* Maintain Volume Constraint */ - constraintsTypeInfo[25]= &CTI_PIVOT; /* Pivot Constraint */ - constraintsTypeInfo[26]= &CTI_FOLLOWTRACK; /* Follow Track Constraint */ - constraintsTypeInfo[27]= &CTI_CAMERASOLVER; /* Camera Solver Constraint */ - constraintsTypeInfo[28]= &CTI_OBJECTSOLVER; /* Object Solver Constraint */ +static void constraints_init_typeinfo(void) +{ + constraintsTypeInfo[0] = NULL; /* 'Null' Constraint */ + constraintsTypeInfo[1] = &CTI_CHILDOF; /* ChildOf Constraint */ + constraintsTypeInfo[2] = &CTI_TRACKTO; /* TrackTo Constraint */ + constraintsTypeInfo[3] = &CTI_KINEMATIC; /* IK Constraint */ + constraintsTypeInfo[4] = &CTI_FOLLOWPATH; /* Follow-Path Constraint */ + constraintsTypeInfo[5] = &CTI_ROTLIMIT; /* Limit Rotation Constraint */ + constraintsTypeInfo[6] = &CTI_LOCLIMIT; /* Limit Location Constraint */ + constraintsTypeInfo[7] = &CTI_SIZELIMIT; /* Limit Scaling Constraint */ + constraintsTypeInfo[8] = &CTI_ROTLIKE; /* Copy Rotation Constraint */ + constraintsTypeInfo[9] = &CTI_LOCLIKE; /* Copy Location Constraint */ + constraintsTypeInfo[10] = &CTI_SIZELIKE; /* Copy Scaling Constraint */ + constraintsTypeInfo[11] = &CTI_PYTHON; /* Python/Script Constraint */ + constraintsTypeInfo[12] = &CTI_ACTION; /* Action Constraint */ + constraintsTypeInfo[13] = &CTI_LOCKTRACK; /* Locked-Track Constraint */ + constraintsTypeInfo[14] = &CTI_DISTLIMIT; /* Limit Distance Constraint */ + constraintsTypeInfo[15] = &CTI_STRETCHTO; /* StretchTo Constaint */ + constraintsTypeInfo[16] = &CTI_MINMAX; /* Floor Constraint */ + constraintsTypeInfo[17] = &CTI_RIGIDBODYJOINT; /* RigidBody Constraint */ + constraintsTypeInfo[18] = &CTI_CLAMPTO; /* ClampTo Constraint */ + constraintsTypeInfo[19] = &CTI_TRANSFORM; /* Transformation Constraint */ + constraintsTypeInfo[20] = &CTI_SHRINKWRAP; /* Shrinkwrap Constraint */ + constraintsTypeInfo[21] = &CTI_DAMPTRACK; /* Damped TrackTo Constraint */ + constraintsTypeInfo[22] = &CTI_SPLINEIK; /* Spline IK Constraint */ + constraintsTypeInfo[23] = &CTI_TRANSLIKE; /* Copy Transforms Constraint */ + constraintsTypeInfo[24] = &CTI_SAMEVOL; /* Maintain Volume Constraint */ + constraintsTypeInfo[25] = &CTI_PIVOT; /* Pivot Constraint */ + constraintsTypeInfo[26] = &CTI_FOLLOWTRACK; /* Follow Track Constraint */ + constraintsTypeInfo[27] = &CTI_CAMERASOLVER; /* Camera Solver Constraint */ + constraintsTypeInfo[28] = &CTI_OBJECTSOLVER; /* Object Solver Constraint */ } /* This function should be used for getting the appropriate type-info when only * a constraint type is known */ -bConstraintTypeInfo *get_constraint_typeinfo (int type) +bConstraintTypeInfo *get_constraint_typeinfo(int type) { /* initialize the type-info list? */ if (CTI_INIT) { @@ -4245,7 +4245,7 @@ bConstraintTypeInfo *get_constraint_typeinfo (int type) /* only return for valid types */ if ( (type >= CONSTRAINT_TYPE_NULL) && - (type < NUM_CONSTRAINT_TYPES ) ) + (type < NUM_CONSTRAINT_TYPES) ) { /* there shouldn't be any segfaults here... */ return constraintsTypeInfo[type]; @@ -4260,7 +4260,7 @@ bConstraintTypeInfo *get_constraint_typeinfo (int type) /* This function should always be used to get the appropriate type-info, as it * has checks which prevent segfaults in some weird cases. */ -bConstraintTypeInfo *constraint_get_typeinfo (bConstraint *con) +bConstraintTypeInfo *constraint_get_typeinfo(bConstraint *con) { /* only return typeinfo for valid constraints */ if (con) @@ -4290,7 +4290,7 @@ static void con_unlink_refs_cb(bConstraint *UNUSED(con), ID **idpoin, short isRe void free_constraint_data(bConstraint *con) { if (con->data) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); if (cti) { /* perform any special freeing constraint may have */ @@ -4313,7 +4313,7 @@ void free_constraints(ListBase *list) bConstraint *con; /* Free constraint data and also any extra data */ - for (con= list->first; con; con= con->next) + for (con = list->first; con; con = con->next) free_constraint_data(con); /* Free the whole list */ @@ -4342,8 +4342,8 @@ void remove_constraints_type(ListBase *list, short type, short last_only) return; /* remove from the end of the list to make it faster to find the last instance */ - for (con= list->last; con; con= conp) { - conp= con->prev; + for (con = list->last; con; con = conp) { + conp = con->prev; if (con->type == type) { remove_constraint(list, con); @@ -4356,10 +4356,10 @@ void remove_constraints_type(ListBase *list, short type, short last_only) /* ......... */ /* Creates a new constraint, initializes its data, and returns it */ -static bConstraint *add_new_constraint_internal (const char *name, short type) +static bConstraint *add_new_constraint_internal(const char *name, short type) { - bConstraint *con= MEM_callocN(sizeof(bConstraint), "Constraint"); - bConstraintTypeInfo *cti= get_constraint_typeinfo(type); + bConstraint *con = MEM_callocN(sizeof(bConstraint), "Constraint"); + bConstraintTypeInfo *cti = get_constraint_typeinfo(type); const char *newName; /* Set up a generic constraint datablock */ @@ -4377,12 +4377,12 @@ static bConstraint *add_new_constraint_internal (const char *name, short type) cti->new_data(con->data); /* if no name is provided, use the type of the constraint as the name */ - newName= (name && name[0]) ? name : cti->name; + newName = (name && name[0]) ? name : cti->name; } else { /* if no name is provided, use the generic "Const" name */ // NOTE: any constraint type that gets here really shouldn't get added... - newName= (name && name[0]) ? name : "Const"; + newName = (name && name[0]) ? name : "Const"; } /* copy the name */ @@ -4393,13 +4393,13 @@ static bConstraint *add_new_constraint_internal (const char *name, short type) } /* if pchan is not NULL then assume we're adding a pose constraint */ -static bConstraint *add_new_constraint (Object *ob, bPoseChannel *pchan, const char *name, short type) +static bConstraint *add_new_constraint(Object *ob, bPoseChannel *pchan, const char *name, short type) { bConstraint *con; ListBase *list; /* add the constraint */ - con= add_new_constraint_internal(name, type); + con = add_new_constraint_internal(name, type); /* find the constraint stack - bone or object? */ list = (pchan) ? (&pchan->constraints) : (&ob->constraints); @@ -4434,7 +4434,7 @@ static bConstraint *add_new_constraint (Object *ob, bPoseChannel *pchan, const c con->flag |= CONSTRAINT_SPACEONCE; } } - break; + break; } return con; @@ -4443,7 +4443,7 @@ static bConstraint *add_new_constraint (Object *ob, bPoseChannel *pchan, const c /* ......... */ /* Add new constraint for the given bone */ -bConstraint *add_pose_constraint (Object *ob, bPoseChannel *pchan, const char *name, short type) +bConstraint *add_pose_constraint(Object *ob, bPoseChannel *pchan, const char *name, short type) { if (pchan == NULL) return NULL; @@ -4485,8 +4485,8 @@ void id_loop_constraints(ListBase *conlist, ConstraintIDFunc func, void *userdat { bConstraint *con; - for (con= conlist->first; con; con= con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = conlist->first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); if (cti) { if (cti->id_looper) @@ -4517,11 +4517,11 @@ void copy_constraints(ListBase *dst, const ListBase *src, int do_extern) { bConstraint *con, *srccon; - dst->first= dst->last= NULL; + dst->first = dst->last = NULL; BLI_duplicatelist(dst, src); - for (con=dst->first, srccon=src->first; con && srccon; srccon=srccon->next, con=con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = dst->first, srccon = src->first; con && srccon; srccon = srccon->next, con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); /* make a new copy of the constraint's data */ con->data = MEM_dupallocN(con->data); @@ -4554,13 +4554,13 @@ bConstraint *constraints_findByName(ListBase *list, const char *name) } /* finds the 'active' constraint in a constraint stack */ -bConstraint *constraints_get_active (ListBase *list) +bConstraint *constraints_get_active(ListBase *list) { bConstraint *con; /* search for the first constraint with the 'active' flag set */ if (list) { - for (con= list->first; con; con= con->next) { + for (con = list->first; con; con = con->next) { if (con->flag & CONSTRAINT_ACTIVE) return con; } @@ -4576,7 +4576,7 @@ void constraints_set_active(ListBase *list, bConstraint *con) bConstraint *c; if (list) { - for (c= list->first; c; c= c->next) { + for (c = list->first; c; c = c->next) { if (c == con) c->flag |= CONSTRAINT_ACTIVE; else @@ -4593,8 +4593,8 @@ void extract_proxylocal_constraints(ListBase *dst, ListBase *src) bConstraint *con, *next; /* for each tagged constraint, remove from src and move to dst */ - for (con= src->first; con; con= next) { - next= con->next; + for (con = src->first; con; con = next) { + next = con->next; /* check if tagged */ if (con->flag & CONSTRAINT_PROXY_LOCAL) { @@ -4610,7 +4610,7 @@ short proxylocked_constraints_owner(Object *ob, bPoseChannel *pchan) /* Currently, constraints can only be on object or bone level */ if (ob && ob->proxy) { if (ob->pose && pchan) { - bArmature *arm= ob->data; + bArmature *arm = ob->data; /* On bone-level, check if bone is on proxy-protected layer */ if ((pchan->bone) && (pchan->bone->layer & arm->layer_protected)) @@ -4636,21 +4636,21 @@ short proxylocked_constraints_owner(Object *ob, bPoseChannel *pchan) */ void get_constraint_target_matrix(struct Scene *scene, bConstraint *con, int n, short ownertype, void *ownerdata, float mat[][4], float ctime) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); ListBase targets = {NULL, NULL}; bConstraintOb *cob; bConstraintTarget *ct; if (cti && cti->get_constraint_targets) { /* make 'constraint-ob' */ - cob= MEM_callocN(sizeof(bConstraintOb), "tempConstraintOb"); - cob->type= ownertype; + cob = MEM_callocN(sizeof(bConstraintOb), "tempConstraintOb"); + cob->type = ownertype; cob->scene = scene; switch (ownertype) { case CONSTRAINT_OBTYPE_OBJECT: /* it is usually this case */ { - cob->ob= (Object *)ownerdata; - cob->pchan= NULL; + cob->ob = (Object *)ownerdata; + cob->pchan = NULL; if (cob->ob) { copy_m4_m4(cob->matrix, cob->ob->obmat); copy_m4_m4(cob->startmat, cob->matrix); @@ -4660,11 +4660,11 @@ void get_constraint_target_matrix(struct Scene *scene, bConstraint *con, int n, unit_m4(cob->startmat); } } - break; + break; case CONSTRAINT_OBTYPE_BONE: /* this may occur in some cases */ { - cob->ob= NULL; /* this might not work at all :/ */ - cob->pchan= (bPoseChannel *)ownerdata; + cob->ob = NULL; /* this might not work at all :/ */ + cob->pchan = (bPoseChannel *)ownerdata; if (cob->pchan) { copy_m4_m4(cob->matrix, cob->pchan->pose_mat); copy_m4_m4(cob->startmat, cob->matrix); @@ -4674,16 +4674,16 @@ void get_constraint_target_matrix(struct Scene *scene, bConstraint *con, int n, unit_m4(cob->startmat); } } - break; + break; } /* get targets - we only need the first one though (and there should only be one) */ cti->get_constraint_targets(con, &targets); /* only calculate the target matrix on the first target */ - ct= (bConstraintTarget *)targets.first; + ct = (bConstraintTarget *)targets.first; while (ct && n-- > 0) - ct= ct->next; + ct = ct->next; if (ct) { if (cti->get_target_matrix) @@ -4705,26 +4705,26 @@ void get_constraint_target_matrix(struct Scene *scene, bConstraint *con, int n, /* Get the list of targets required for solving a constraint */ void get_constraint_targets_for_solving(bConstraint *con, bConstraintOb *cob, ListBase *targets, float ctime) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); if (cti && cti->get_constraint_targets) { bConstraintTarget *ct; /* get targets - * - constraints should use ct->matrix, not directly accessing values + * - constraints should use ct->matrix, not directly accessing values * - ct->matrix members have not yet been calculated here! */ cti->get_constraint_targets(con, targets); /* set matrices - * - calculate if possible, otherwise just initialize as identity matrix + * - calculate if possible, otherwise just initialize as identity matrix */ if (cti->get_target_matrix) { - for (ct= targets->first; ct; ct= ct->next) + for (ct = targets->first; ct; ct = ct->next) cti->get_target_matrix(con, cob, ct, ctime); } else { - for (ct= targets->first; ct; ct= ct->next) + for (ct = targets->first; ct; ct = ct->next) unit_m4(ct->matrix); } } @@ -4749,20 +4749,20 @@ void solve_constraints(ListBase *conlist, bConstraintOb *cob, float ctime) return; /* loop over available constraints, solving and blending them */ - for (con= conlist->first; con; con= con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = conlist->first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); ListBase targets = {NULL, NULL}; /* these we can skip completely (invalid constraints...) */ if (cti == NULL) continue; - if (con->flag & (CONSTRAINT_DISABLE|CONSTRAINT_OFF)) continue; + if (con->flag & (CONSTRAINT_DISABLE | CONSTRAINT_OFF)) continue; /* these constraints can't be evaluated anyway */ if (cti->evaluate_constraint == NULL) continue; /* influence == 0 should be ignored */ if (con->enforce == 0.0f) continue; /* influence of constraint - * - value should have been set from animation data already + * - value should have been set from animation data already */ enf = con->enforce; @@ -4791,9 +4791,9 @@ void solve_constraints(ListBase *conlist, bConstraintOb *cob, float ctime) constraint_mat_convertspace(cob->ob, cob->pchan, cob->matrix, con->ownspace, CONSTRAINT_SPACE_WORLD); /* Interpolate the enforcement, to blend result of constraint into final owner transform - * - all this happens in worldspace to prevent any weirdness creeping in ([#26014] and [#25725]), - * since some constraints may not convert the solution back to the input space before blending - * but all are guaranteed to end up in good "worldspace" result + * - all this happens in worldspace to prevent any weirdness creeping in ([#26014] and [#25725]), + * since some constraints may not convert the solution back to the input space before blending + * but all are guaranteed to end up in good "worldspace" result */ /* Note: all kind of stuff here before (caused trouble), much easier to just interpolate, or did I miss something? -jahka */ if (enf < 1.0f) { diff --git a/source/blender/blenkernel/intern/context.c b/source/blender/blenkernel/intern/context.c index bd47e7cbd37..d736309f605 100644 --- a/source/blender/blenkernel/intern/context.c +++ b/source/blender/blenkernel/intern/context.c @@ -92,14 +92,14 @@ bContext *CTX_create(void) { bContext *C; - C= MEM_callocN(sizeof(bContext), "bContext"); + C = MEM_callocN(sizeof(bContext), "bContext"); return C; } bContext *CTX_copy(const bContext *C) { - bContext *newC= MEM_dupallocN((void*)C); + bContext *newC = MEM_dupallocN((void *)C); return newC; } @@ -118,23 +118,23 @@ bContextStore *CTX_store_add(ListBase *contexts, const char *name, PointerRNA *p /* ensure we have a context to put the entry in, if it was already used * we have to copy the context to ensure */ - ctx= contexts->last; + ctx = contexts->last; if (!ctx || ctx->used) { if (ctx) { - lastctx= ctx; - ctx= MEM_dupallocN(lastctx); + lastctx = ctx; + ctx = MEM_dupallocN(lastctx); BLI_duplicatelist(&ctx->entries, &lastctx->entries); } else - ctx= MEM_callocN(sizeof(bContextStore), "bContextStore"); + ctx = MEM_callocN(sizeof(bContextStore), "bContextStore"); BLI_addtail(contexts, ctx); } - entry= MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry"); + entry = MEM_callocN(sizeof(bContextStoreEntry), "bContextStoreEntry"); BLI_strncpy(entry->name, name, sizeof(entry->name)); - entry->ptr= *ptr; + entry->ptr = *ptr; BLI_addtail(&ctx->entries, entry); @@ -148,22 +148,22 @@ bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context) /* ensure we have a context to put the entries in, if it was already used * we have to copy the context to ensure */ - ctx= contexts->last; + ctx = contexts->last; if (!ctx || ctx->used) { if (ctx) { - lastctx= ctx; - ctx= MEM_dupallocN(lastctx); + lastctx = ctx; + ctx = MEM_dupallocN(lastctx); BLI_duplicatelist(&ctx->entries, &lastctx->entries); } else - ctx= MEM_callocN(sizeof(bContextStore), "bContextStore"); + ctx = MEM_callocN(sizeof(bContextStore), "bContextStore"); BLI_addtail(contexts, ctx); } - for (tentry= context->entries.first; tentry; tentry= tentry->next) { - entry= MEM_dupallocN(tentry); + for (tentry = context->entries.first; tentry; tentry = tentry->next) { + entry = MEM_dupallocN(tentry); BLI_addtail(&ctx->entries, entry); } @@ -172,14 +172,14 @@ bContextStore *CTX_store_add_all(ListBase *contexts, bContextStore *context) void CTX_store_set(bContext *C, bContextStore *store) { - C->wm.store= store; + C->wm.store = store; } bContextStore *CTX_store_copy(bContextStore *store) { bContextStore *ctx; - ctx= MEM_dupallocN(store); + ctx = MEM_dupallocN(store); BLI_duplicatelist(&ctx->entries, &store->entries); return ctx; @@ -195,7 +195,7 @@ void CTX_store_free_list(ListBase *contexts) { bContextStore *ctx; - while ((ctx= contexts->first)) { + while ((ctx = contexts->first)) { BLI_remlink(contexts, ctx); CTX_store_free(ctx); } @@ -209,7 +209,7 @@ int CTX_py_init_get(bContext *C) } void CTX_py_init_set(bContext *C, int value) { - C->data.py_init= value; + C->data.py_init = value; } void *CTX_py_dict_get(const bContext *C) @@ -218,7 +218,7 @@ void *CTX_py_dict_get(const bContext *C) } void CTX_py_dict_set(bContext *C, void *value) { - C->data.py_context= value; + C->data.py_context = value; } /* data context utility functions */ @@ -237,8 +237,8 @@ static void *ctx_wm_python_context_get(const bContext *C, const char *member, vo if (C && CTX_py_dict_get(C)) { memset(&result, 0, sizeof(bContextDataResult)); - BPY_context_member_get((bContext*)C, member, &result); - if(result.ptr.data) + BPY_context_member_get((bContext *)C, member, &result); + if (result.ptr.data) return result.ptr.data; } #endif @@ -251,8 +251,8 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res bScreen *sc; ScrArea *sa; ARegion *ar; - int done= 0, recursion= C->data.recursion; - int ret= 0; + int done = 0, recursion = C->data.recursion; + int ret = 0; memset(result, 0, sizeof(bContextDataResult)); #ifdef WITH_PYTHON @@ -271,42 +271,42 @@ static int ctx_data_get(bContext *C, const char *member, bContextDataResult *res * Values in order of importance * (0, -1, 1) - Where 1 is highest priority * */ - if (done!=1 && recursion < 1 && C->wm.store) { + if (done != 1 && recursion < 1 && C->wm.store) { bContextStoreEntry *entry; - C->data.recursion= 1; + C->data.recursion = 1; - entry= BLI_rfindstring(&C->wm.store->entries, member, offsetof(bContextStoreEntry, name)); + entry = BLI_rfindstring(&C->wm.store->entries, member, offsetof(bContextStoreEntry, name)); if (entry) { - result->ptr= entry->ptr; - done= 1; + result->ptr = entry->ptr; + done = 1; } } - if (done!=1 && recursion < 2 && (ar=CTX_wm_region(C))) { - C->data.recursion= 2; + if (done != 1 && recursion < 2 && (ar = CTX_wm_region(C))) { + C->data.recursion = 2; if (ar->type && ar->type->context) { ret = ar->type->context(C, member, result); - if (ret) done= -(-ret | -done); + if (ret) done = -(-ret | -done); } } - if (done!=1 && recursion < 3 && (sa=CTX_wm_area(C))) { - C->data.recursion= 3; + if (done != 1 && recursion < 3 && (sa = CTX_wm_area(C))) { + C->data.recursion = 3; if (sa->type && sa->type->context) { ret = sa->type->context(C, member, result); - if (ret) done= -(-ret | -done); + if (ret) done = -(-ret | -done); } } - if (done!=1 && recursion < 4 && (sc=CTX_wm_screen(C))) { - bContextDataCallback cb= sc->context; - C->data.recursion= 4; + if (done != 1 && recursion < 4 && (sc = CTX_wm_screen(C))) { + bContextDataCallback cb = sc->context; + C->data.recursion = 4; if (cb) { ret = cb(C, member, result); - if (ret) done= -(-ret | -done); + if (ret) done = -(-ret | -done); } } - C->data.recursion= recursion; + C->data.recursion = recursion; return done; } @@ -315,7 +315,7 @@ static void *ctx_data_pointer_get(const bContext *C, const char *member) { bContextDataResult result; - if (C && ctx_data_get((bContext*)C, member, &result)==1) + if (C && ctx_data_get((bContext *)C, member, &result) == 1) return result.ptr.data; return NULL; @@ -327,15 +327,15 @@ static int ctx_data_pointer_verify(const bContext *C, const char *member, void * /* if context is NULL, pointer must be NULL too and that is a valid return */ if (C == NULL) { - *pointer= NULL; + *pointer = NULL; return 1; } - else if (ctx_data_get((bContext*)C, member, &result)==1) { - *pointer= result.ptr.data; + else if (ctx_data_get((bContext *)C, member, &result) == 1) { + *pointer = result.ptr.data; return 1; } else { - *pointer= NULL; + *pointer = NULL; return 0; } } @@ -344,13 +344,13 @@ static int ctx_data_collection_get(const bContext *C, const char *member, ListBa { bContextDataResult result; - if (ctx_data_get((bContext*)C, member, &result)==1) { - *list= result.list; + if (ctx_data_get((bContext *)C, member, &result) == 1) { + *list = result.list; return 1; } - list->first= NULL; - list->last= NULL; + list->first = NULL; + list->last = NULL; return 0; } @@ -359,7 +359,7 @@ PointerRNA CTX_data_pointer_get(const bContext *C, const char *member) { bContextDataResult result; - if (ctx_data_get((bContext*)C, member, &result)==1) + if (ctx_data_get((bContext *)C, member, &result) == 1) return result.ptr; else return PointerRNA_NULL; @@ -379,11 +379,11 @@ ListBase CTX_data_collection_get(const bContext *C, const char *member) { bContextDataResult result; - if (ctx_data_get((bContext*)C, member, &result)==1) { + if (ctx_data_get((bContext *)C, member, &result) == 1) { return result.list; } else { - ListBase list= {NULL, NULL}; + ListBase list = {NULL, NULL}; return list; } } @@ -392,17 +392,17 @@ ListBase CTX_data_collection_get(const bContext *C, const char *member) int CTX_data_get(const bContext *C, const char *member, PointerRNA *r_ptr, ListBase *r_lb, short *r_type) { bContextDataResult result; - int ret= ctx_data_get((bContext*)C, member, &result); + int ret = ctx_data_get((bContext *)C, member, &result); - if (ret==1) { - *r_ptr= result.ptr; - *r_lb= result.list; - *r_type= result.type; + if (ret == 1) { + *r_ptr = result.ptr; + *r_lb = result.list; + *r_type = result.type; } else { memset(r_ptr, 0, sizeof(*r_ptr)); memset(r_lb, 0, sizeof(*r_lb)); - *r_type= 0; + *r_type = 0; } return ret; @@ -418,8 +418,8 @@ static void data_dir_add(ListBase *lb, const char *member) if (BLI_findstring(lb, member, offsetof(LinkData, data))) return; - link= MEM_callocN(sizeof(LinkData), "LinkData"); - link->data= (void*)member; + link = MEM_callocN(sizeof(LinkData), "LinkData"); + link->data = (void *)member; BLI_addtail(lb, link); } @@ -437,32 +437,32 @@ ListBase CTX_data_dir_get(const bContext *C) if (C->wm.store) { bContextStoreEntry *entry; - for (entry=C->wm.store->entries.first; entry; entry=entry->next) + for (entry = C->wm.store->entries.first; entry; entry = entry->next) data_dir_add(&lb, entry->name); } - if ((ar=CTX_wm_region(C)) && ar->type && ar->type->context) { + if ((ar = CTX_wm_region(C)) && ar->type && ar->type->context) { memset(&result, 0, sizeof(result)); ar->type->context(C, "", &result); if (result.dir) - for (a=0; result.dir[a]; a++) + for (a = 0; result.dir[a]; a++) data_dir_add(&lb, result.dir[a]); } - if ((sa=CTX_wm_area(C)) && sa->type && sa->type->context) { + if ((sa = CTX_wm_area(C)) && sa->type && sa->type->context) { memset(&result, 0, sizeof(result)); sa->type->context(C, "", &result); if (result.dir) - for (a=0; result.dir[a]; a++) + for (a = 0; result.dir[a]; a++) data_dir_add(&lb, result.dir[a]); } - if ((sc=CTX_wm_screen(C)) && sc->context) { - bContextDataCallback cb= sc->context; + if ((sc = CTX_wm_screen(C)) && sc->context) { + bContextDataCallback cb = sc->context; memset(&result, 0, sizeof(result)); cb(C, "", &result); if (result.dir) - for (a=0; result.dir[a]; a++) + for (a = 0; result.dir[a]; a++) data_dir_add(&lb, result.dir[a]); } @@ -493,7 +493,7 @@ void CTX_data_id_list_add(bContextDataResult *result, ID *id) { CollectionPointerLink *link; - link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add"); + link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_id_list_add"); RNA_id_pointer_create(id, &link->ptr); BLI_addtail(&result->list, link); @@ -503,18 +503,18 @@ void CTX_data_list_add(bContextDataResult *result, ID *id, StructRNA *type, void { CollectionPointerLink *link; - link= MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add"); + link = MEM_callocN(sizeof(CollectionPointerLink), "CTX_data_list_add"); RNA_pointer_create(id, type, data, &link->ptr); BLI_addtail(&result->list, link); } -int ctx_data_list_count(const bContext *C, int (*func)(const bContext*, ListBase*)) +int ctx_data_list_count(const bContext *C, int (*func)(const bContext *, ListBase *)) { ListBase list; if (func(C, &list)) { - int tot= BLI_countlist(&list); + int tot = BLI_countlist(&list); BLI_freelistN(&list); return tot; } @@ -524,12 +524,12 @@ int ctx_data_list_count(const bContext *C, int (*func)(const bContext*, ListBase void CTX_data_dir_set(bContextDataResult *result, const char **dir) { - result->dir= dir; + result->dir = dir; } void CTX_data_type_set(bContextDataResult *result, short type) { - result->type= type; + result->type = type; } short CTX_data_type_get(bContextDataResult *result) @@ -564,7 +564,7 @@ ScrArea *CTX_wm_area(const bContext *C) SpaceLink *CTX_wm_space_data(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - return (sa)? sa->spacedata.first: NULL; + return (sa) ? sa->spacedata.first : NULL; } ARegion *CTX_wm_region(const bContext *C) @@ -575,7 +575,7 @@ ARegion *CTX_wm_region(const bContext *C) void *CTX_wm_region_data(const bContext *C) { ARegion *ar = CTX_wm_region(C); - return (ar)? ar->regiondata: NULL; + return (ar) ? ar->regiondata : NULL; } struct ARegion *CTX_wm_menu(const bContext *C) @@ -594,7 +594,7 @@ struct ReportList *CTX_wm_reports(const bContext *C) View3D *CTX_wm_view3d(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_VIEW3D) + if (sa && sa->spacetype == SPACE_VIEW3D) return sa->spacedata.first; return NULL; } @@ -604,7 +604,7 @@ RegionView3D *CTX_wm_region_view3d(const bContext *C) ScrArea *sa = CTX_wm_area(C); ARegion *ar = CTX_wm_region(C); - if (sa && sa->spacetype==SPACE_VIEW3D) + if (sa && sa->spacetype == SPACE_VIEW3D) if (ar) return ar->regiondata; return NULL; @@ -613,7 +613,7 @@ RegionView3D *CTX_wm_region_view3d(const bContext *C) struct SpaceText *CTX_wm_space_text(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_TEXT) + if (sa && sa->spacetype == SPACE_TEXT) return sa->spacedata.first; return NULL; } @@ -621,7 +621,7 @@ struct SpaceText *CTX_wm_space_text(const bContext *C) struct SpaceConsole *CTX_wm_space_console(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_CONSOLE) + if (sa && sa->spacetype == SPACE_CONSOLE) return sa->spacedata.first; return NULL; } @@ -629,7 +629,7 @@ struct SpaceConsole *CTX_wm_space_console(const bContext *C) struct SpaceImage *CTX_wm_space_image(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_IMAGE) + if (sa && sa->spacetype == SPACE_IMAGE) return sa->spacedata.first; return NULL; } @@ -637,7 +637,7 @@ struct SpaceImage *CTX_wm_space_image(const bContext *C) struct SpaceButs *CTX_wm_space_buts(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_BUTS) + if (sa && sa->spacetype == SPACE_BUTS) return sa->spacedata.first; return NULL; } @@ -645,7 +645,7 @@ struct SpaceButs *CTX_wm_space_buts(const bContext *C) struct SpaceFile *CTX_wm_space_file(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_FILE) + if (sa && sa->spacetype == SPACE_FILE) return sa->spacedata.first; return NULL; } @@ -653,7 +653,7 @@ struct SpaceFile *CTX_wm_space_file(const bContext *C) struct SpaceSeq *CTX_wm_space_seq(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_SEQ) + if (sa && sa->spacetype == SPACE_SEQ) return sa->spacedata.first; return NULL; } @@ -661,7 +661,7 @@ struct SpaceSeq *CTX_wm_space_seq(const bContext *C) struct SpaceOops *CTX_wm_space_outliner(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_OUTLINER) + if (sa && sa->spacetype == SPACE_OUTLINER) return sa->spacedata.first; return NULL; } @@ -669,7 +669,7 @@ struct SpaceOops *CTX_wm_space_outliner(const bContext *C) struct SpaceNla *CTX_wm_space_nla(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_NLA) + if (sa && sa->spacetype == SPACE_NLA) return sa->spacedata.first; return NULL; } @@ -677,7 +677,7 @@ struct SpaceNla *CTX_wm_space_nla(const bContext *C) struct SpaceTime *CTX_wm_space_time(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_TIME) + if (sa && sa->spacetype == SPACE_TIME) return sa->spacedata.first; return NULL; } @@ -685,7 +685,7 @@ struct SpaceTime *CTX_wm_space_time(const bContext *C) struct SpaceNode *CTX_wm_space_node(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_NODE) + if (sa && sa->spacetype == SPACE_NODE) return sa->spacedata.first; return NULL; } @@ -693,7 +693,7 @@ struct SpaceNode *CTX_wm_space_node(const bContext *C) struct SpaceLogic *CTX_wm_space_logic(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_LOGIC) + if (sa && sa->spacetype == SPACE_LOGIC) return sa->spacedata.first; return NULL; } @@ -701,7 +701,7 @@ struct SpaceLogic *CTX_wm_space_logic(const bContext *C) struct SpaceIpo *CTX_wm_space_graph(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_IPO) + if (sa && sa->spacetype == SPACE_IPO) return sa->spacedata.first; return NULL; } @@ -709,7 +709,7 @@ struct SpaceIpo *CTX_wm_space_graph(const bContext *C) struct SpaceAction *CTX_wm_space_action(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_ACTION) + if (sa && sa->spacetype == SPACE_ACTION) return sa->spacedata.first; return NULL; } @@ -717,7 +717,7 @@ struct SpaceAction *CTX_wm_space_action(const bContext *C) struct SpaceInfo *CTX_wm_space_info(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_INFO) + if (sa && sa->spacetype == SPACE_INFO) return sa->spacedata.first; return NULL; } @@ -725,7 +725,7 @@ struct SpaceInfo *CTX_wm_space_info(const bContext *C) struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_USERPREF) + if (sa && sa->spacetype == SPACE_USERPREF) return sa->spacedata.first; return NULL; } @@ -733,58 +733,58 @@ struct SpaceUserPref *CTX_wm_space_userpref(const bContext *C) struct SpaceClip *CTX_wm_space_clip(const bContext *C) { ScrArea *sa = CTX_wm_area(C); - if (sa && sa->spacetype==SPACE_CLIP) + if (sa && sa->spacetype == SPACE_CLIP) return sa->spacedata.first; return NULL; } void CTX_wm_manager_set(bContext *C, wmWindowManager *wm) { - C->wm.manager= wm; - C->wm.window= NULL; - C->wm.screen= NULL; - C->wm.area= NULL; - C->wm.region= NULL; + C->wm.manager = wm; + C->wm.window = NULL; + C->wm.screen = NULL; + C->wm.area = NULL; + C->wm.region = NULL; } void CTX_wm_window_set(bContext *C, wmWindow *win) { - C->wm.window= win; - C->wm.screen= (win)? win->screen: NULL; + C->wm.window = win; + C->wm.screen = (win) ? win->screen : NULL; if (C->wm.screen) - C->data.scene= C->wm.screen->scene; - C->wm.area= NULL; - C->wm.region= NULL; + C->data.scene = C->wm.screen->scene; + C->wm.area = NULL; + C->wm.region = NULL; } void CTX_wm_screen_set(bContext *C, bScreen *screen) { - C->wm.screen= screen; + C->wm.screen = screen; if (C->wm.screen) - C->data.scene= C->wm.screen->scene; - C->wm.area= NULL; - C->wm.region= NULL; + C->data.scene = C->wm.screen->scene; + C->wm.area = NULL; + C->wm.region = NULL; } void CTX_wm_area_set(bContext *C, ScrArea *area) { - C->wm.area= area; - C->wm.region= NULL; + C->wm.area = area; + C->wm.region = NULL; } void CTX_wm_region_set(bContext *C, ARegion *region) { - C->wm.region= region; + C->wm.region = region; } void CTX_wm_menu_set(bContext *C, ARegion *menu) { - C->wm.menu= menu; + C->wm.menu = menu; } void CTX_wm_operator_poll_msg_set(bContext *C, const char *msg) { - C->wm.operator_poll_msg= msg; + C->wm.operator_poll_msg = msg; } const char *CTX_wm_operator_poll_msg_get(bContext *C) @@ -798,7 +798,7 @@ Main *CTX_data_main(const bContext *C) { Main *bmain; - if (ctx_data_pointer_verify(C, "blend_data", (void*)&bmain)) + if (ctx_data_pointer_verify(C, "blend_data", (void *)&bmain)) return bmain; else return C->data.main; @@ -806,14 +806,14 @@ Main *CTX_data_main(const bContext *C) void CTX_data_main_set(bContext *C, Main *bmain) { - C->data.main= bmain; + C->data.main = bmain; } Scene *CTX_data_scene(const bContext *C) { Scene *scene; - if (ctx_data_pointer_verify(C, "scene", (void*)&scene)) + if (ctx_data_pointer_verify(C, "scene", (void *)&scene)) return scene; else return C->data.scene; @@ -821,7 +821,7 @@ Scene *CTX_data_scene(const bContext *C) int CTX_data_mode_enum(const bContext *C) { - Object *obedit= CTX_data_edit_object(C); + Object *obedit = CTX_data_edit_object(C); if (obedit) { switch (obedit->type) { @@ -846,7 +846,7 @@ int CTX_data_mode_enum(const bContext *C) if (ob) { if (ob->mode & OB_MODE_POSE) return CTX_MODE_POSE; - else if (ob->mode & OB_MODE_SCULPT) return CTX_MODE_SCULPT; + else if (ob->mode & OB_MODE_SCULPT) return CTX_MODE_SCULPT; else if (ob->mode & OB_MODE_WEIGHT_PAINT) return CTX_MODE_PAINT_WEIGHT; else if (ob->mode & OB_MODE_VERTEX_PAINT) return CTX_MODE_PAINT_VERTEX; else if (ob->mode & OB_MODE_TEXTURE_PAINT) return CTX_MODE_PAINT_TEXTURE; @@ -884,7 +884,7 @@ const char *CTX_data_mode_string(const bContext *C) void CTX_data_scene_set(bContext *C, Scene *scene) { - C->data.scene= scene; + C->data.scene = scene; } ToolSettings *CTX_data_tool_settings(const bContext *C) diff --git a/source/blender/blenkernel/intern/depsgraph.c b/source/blender/blenkernel/intern/depsgraph.c index 54655cf8582..51f8815fbd1 100644 --- a/source/blender/blenkernel/intern/depsgraph.c +++ b/source/blender/blenkernel/intern/depsgraph.c @@ -82,10 +82,10 @@ * the queue store a list of freenodes to avoid successive alloc/dealloc */ -DagNodeQueue * queue_create (int slots) +DagNodeQueue *queue_create(int slots) { - DagNodeQueue * queue; - DagNodeQueueElem * elem; + DagNodeQueue *queue; + DagNodeQueueElem *elem; int i; queue = MEM_mallocN(sizeof(DagNodeQueue), "DAG queue"); @@ -98,7 +98,7 @@ DagNodeQueue * queue_create (int slots) elem->next = NULL; queue->freenodes->first = queue->freenodes->last = elem; - for (i = 1; i node = NULL; elem->next = NULL; @@ -111,7 +111,7 @@ DagNodeQueue * queue_create (int slots) void queue_raz(DagNodeQueue *queue) { - DagNodeQueueElem * elem; + DagNodeQueueElem *elem; elem = queue->first; if (queue->freenodes->last) @@ -132,8 +132,8 @@ void queue_raz(DagNodeQueue *queue) void queue_delete(DagNodeQueue *queue) { - DagNodeQueueElem * elem; - DagNodeQueueElem * temp; + DagNodeQueueElem *elem; + DagNodeQueueElem *temp; elem = queue->first; while (elem) { @@ -156,7 +156,7 @@ void queue_delete(DagNodeQueue *queue) /* insert in queue, remove in front */ void push_queue(DagNodeQueue *queue, DagNode *node) { - DagNodeQueueElem * elem; + DagNodeQueueElem *elem; int i; if (node == NULL) { @@ -168,7 +168,7 @@ void push_queue(DagNodeQueue *queue, DagNode *node) elem = queue->freenodes->first; if (elem != NULL) { queue->freenodes->first = elem->next; - if ( queue->freenodes->last == elem) { + if (queue->freenodes->last == elem) { queue->freenodes->last = NULL; queue->freenodes->first = NULL; } @@ -180,7 +180,7 @@ void push_queue(DagNodeQueue *queue, DagNode *node) elem->next = NULL; queue->freenodes->first = queue->freenodes->last = elem; - for (i = 1; i node = NULL; elem->next = NULL; @@ -207,13 +207,13 @@ void push_queue(DagNodeQueue *queue, DagNode *node) /* insert in front, remove in front */ void push_stack(DagNodeQueue *queue, DagNode *node) { - DagNodeQueueElem * elem; + DagNodeQueueElem *elem; int i; elem = queue->freenodes->first; if (elem != NULL) { queue->freenodes->first = elem->next; - if ( queue->freenodes->last == elem) { + if (queue->freenodes->last == elem) { queue->freenodes->last = NULL; queue->freenodes->first = NULL; } @@ -225,7 +225,7 @@ void push_stack(DagNodeQueue *queue, DagNode *node) elem->next = NULL; queue->freenodes->first = queue->freenodes->last = elem; - for (i = 1; i node = NULL; elem->next = NULL; @@ -246,24 +246,24 @@ void push_stack(DagNodeQueue *queue, DagNode *node) } -DagNode * pop_queue(DagNodeQueue *queue) +DagNode *pop_queue(DagNodeQueue *queue) { - DagNodeQueueElem * elem; + DagNodeQueueElem *elem; DagNode *node; elem = queue->first; if (elem) { queue->first = elem->next; if (queue->last == elem) { - queue->last=NULL; - queue->first=NULL; + queue->last = NULL; + queue->first = NULL; } queue->count--; if (queue->freenodes->last) - queue->freenodes->last->next=elem; - queue->freenodes->last=elem; + queue->freenodes->last->next = elem; + queue->freenodes->last = elem; if (queue->freenodes->first == NULL) - queue->freenodes->first=elem; + queue->freenodes->first = elem; node = elem->node; elem->node = NULL; elem->next = NULL; @@ -276,17 +276,17 @@ DagNode * pop_queue(DagNodeQueue *queue) } } -void *pop_ob_queue(struct DagNodeQueue *queue) +void *pop_ob_queue(struct DagNodeQueue *queue) { return(pop_queue(queue)->ob); } -DagNode * get_top_node_queue(DagNodeQueue *queue) +DagNode *get_top_node_queue(DagNodeQueue *queue) { return queue->first->node; } -int queue_count(struct DagNodeQueue *queue) +int queue_count(struct DagNodeQueue *queue) { return queue->count; } @@ -307,37 +307,37 @@ static void dag_add_driver_relation(AnimData *adt, DagForest *dag, DagNode *node FCurve *fcu; DagNode *node1; - for (fcu= adt->drivers.first; fcu; fcu= fcu->next) { - ChannelDriver *driver= fcu->driver; + for (fcu = adt->drivers.first; fcu; fcu = fcu->next) { + ChannelDriver *driver = fcu->driver; DriverVar *dvar; int isdata_fcu = isdata || (fcu->rna_path && strstr(fcu->rna_path, "modifiers[")); /* loop over variables to get the target relationships */ - for (dvar= driver->variables.first; dvar; dvar= dvar->next) { + for (dvar = driver->variables.first; dvar; dvar = dvar->next) { /* only used targets */ DRIVER_TARGETS_USED_LOOPER(dvar) { if (dtar->id) { // FIXME: other data types need to be added here so that they can work! - if (GS(dtar->id->name)==ID_OB) { - Object *ob= (Object *)dtar->id; + if (GS(dtar->id->name) == ID_OB) { + Object *ob = (Object *)dtar->id; /* normal channel-drives-channel */ node1 = dag_get_node(dag, dtar->id); /* check if bone... */ - if ((ob->type==OB_ARMATURE) && - ( ((dtar->rna_path) && strstr(dtar->rna_path, "pose.bones[")) || - ((dtar->flag & DTAR_FLAG_STRUCT_REF) && (dtar->pchan_name[0])) )) + if ((ob->type == OB_ARMATURE) && + ( ((dtar->rna_path) && strstr(dtar->rna_path, "pose.bones[")) || + ((dtar->flag & DTAR_FLAG_STRUCT_REF) && (dtar->pchan_name[0])) )) { - dag_add_relation(dag, node1, node, isdata_fcu?DAG_RL_DATA_DATA:DAG_RL_DATA_OB, "Driver"); + dag_add_relation(dag, node1, node, isdata_fcu ? DAG_RL_DATA_DATA : DAG_RL_DATA_OB, "Driver"); } /* check if ob data */ else if (dtar->rna_path && strstr(dtar->rna_path, "data.")) - dag_add_relation(dag, node1, node, isdata_fcu?DAG_RL_DATA_DATA:DAG_RL_DATA_OB, "Driver"); + dag_add_relation(dag, node1, node, isdata_fcu ? DAG_RL_DATA_DATA : DAG_RL_DATA_OB, "Driver"); /* normal */ else - dag_add_relation(dag, node1, node, isdata_fcu?DAG_RL_OB_DATA:DAG_RL_OB_OB, "Driver"); + dag_add_relation(dag, node1, node, isdata_fcu ? DAG_RL_OB_DATA : DAG_RL_OB_OB, "Driver"); } } } @@ -353,12 +353,12 @@ static void dag_add_collision_field_relation(DagForest *dag, Scene *scene, Objec // would be nice to have a list of colliders here // so for now walk all objects in scene check 'same layer rule' - for (base = scene->base.first; base; base= base->next) { + for (base = scene->base.first; base; base = base->next) { if ((base->lay & ob->lay) && base->object->pd) { - Object *ob1= base->object; + Object *ob1 = base->object; if ((ob1->pd->deflect || ob1->pd->forcefield) && (ob1 != ob)) { node2 = dag_get_node(dag, ob1); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Field Collision"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Field Collision"); } } } @@ -367,16 +367,16 @@ static void dag_add_collision_field_relation(DagForest *dag, Scene *scene, Objec static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, Object *ob, int mask) { bConstraint *con; - DagNode * node; - DagNode * node2; - DagNode * node3; + DagNode *node; + DagNode *node2; + DagNode *node3; Key *key; ParticleSystem *psys; - int addtoroot= 1; + int addtoroot = 1; node = dag_get_node(dag, ob); - if ((ob->data) && (mask&DAG_RL_DATA)) { + if ((ob->data) && (mask & DAG_RL_DATA)) { node2 = dag_get_node(dag, ob->data); dag_add_relation(dag, node, node2, DAG_RL_DATA, "Object-Data Relation"); node2->first_ancestor = ob; @@ -384,34 +384,34 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O } /* also build a custom data mask for dependencies that need certain layers */ - node->customdata_mask= 0; + node->customdata_mask = 0; if (ob->type == OB_ARMATURE) { if (ob->pose) { bPoseChannel *pchan; bConstraint *con; - for (pchan = ob->pose->chanbase.first; pchan; pchan=pchan->next) { - for (con = pchan->constraints.first; con; con=con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) { + for (con = pchan->constraints.first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); ListBase targets = {NULL, NULL}; bConstraintTarget *ct; if (cti && cti->get_constraint_targets) { cti->get_constraint_targets(con, &targets); - for (ct= targets.first; ct; ct= ct->next) { + for (ct = targets.first; ct; ct = ct->next) { if (ct->tar && ct->tar != ob) { // fprintf(stderr, "armature %s target :%s\n", ob->id.name, target->id.name); node3 = dag_get_node(dag, ct->tar); if (ct->subtarget[0]) { - dag_add_relation(dag, node3, node, DAG_RL_OB_DATA|DAG_RL_DATA_DATA, cti->name); + dag_add_relation(dag, node3, node, DAG_RL_OB_DATA | DAG_RL_DATA_DATA, cti->name); if (ct->tar->type == OB_MESH) node3->customdata_mask |= CD_MASK_MDEFORMVERT; } else if (ELEM3(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO, CONSTRAINT_TYPE_SPLINEIK)) - dag_add_relation(dag, node3, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, cti->name); + dag_add_relation(dag, node3, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, cti->name); else dag_add_relation(dag, node3, node, DAG_RL_OB_DATA, cti->name); } @@ -431,13 +431,13 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O if (ob->nlastrips.first) { bActionStrip *strip; bActionChannel *chan; - for (strip= ob->nlastrips.first; strip; strip= strip->next) { + for (strip = ob->nlastrips.first; strip; strip = strip->next) { if (strip->modifiers.first) { bActionModifier *amod; - for (amod= strip->modifiers.first; amod; amod= amod->next) { + for (amod = strip->modifiers.first; amod; amod = amod->next) { if (amod->ob) { node2 = dag_get_node(dag, amod->ob); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "NLA Strip Modifier"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "NLA Strip Modifier"); } } } @@ -445,16 +445,16 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O } #endif // XXX old animation system if (ob->adt) - dag_add_driver_relation(ob->adt, dag, node, (ob->type == OB_ARMATURE)); // XXX isdata arg here doesn't give an accurate picture of situation + dag_add_driver_relation(ob->adt, dag, node, (ob->type == OB_ARMATURE)); // XXX isdata arg here doesn't give an accurate picture of situation - key= ob_get_key(ob); + key = ob_get_key(ob); if (key && key->adt) dag_add_driver_relation(key->adt, dag, node, 1); if (ob->modifiers.first) { ModifierData *md; - for (md=ob->modifiers.first; md; md=md->next) { + for (md = ob->modifiers.first; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); if (mti->updateDepgraph) mti->updateDepgraph(md, dag, scene, ob, node); @@ -465,22 +465,22 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O switch (ob->partype) { case PARSKEL: - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_OB, "Parent"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Parent"); break; case PARVERT1: case PARVERT3: - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, "Vertex Parent"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, "Vertex Parent"); node2->customdata_mask |= CD_MASK_ORIGINDEX; break; case PARBONE: - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, "Bone Parent"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, "Bone Parent"); break; default: - if (ob->parent->type==OB_LATTICE) - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_OB, "Lattice Parent"); - else if (ob->parent->type==OB_CURVE) { - Curve *cu= ob->parent->data; + if (ob->parent->type == OB_LATTICE) + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Lattice Parent"); + else if (ob->parent->type == OB_CURVE) { + Curve *cu = ob->parent->data; if (cu->flag & CU_PATH) - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, "Curve Parent"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, "Curve Parent"); else dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Curve Parent"); } @@ -488,22 +488,22 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Parent"); } /* exception case: parent is duplivert */ - if (ob->type==OB_MBALL && (ob->parent->transflag & OB_DUPLIVERTS)) { - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_OB, "Duplivert"); + if (ob->type == OB_MBALL && (ob->parent->transflag & OB_DUPLIVERTS)) { + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Duplivert"); } addtoroot = 0; } if (ob->proxy) { node2 = dag_get_node(dag, ob->proxy); - dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA|DAG_RL_OB_OB, "Proxy"); + dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Proxy"); /* inverted relation, so addtoroot shouldn't be set to zero */ } if (ob->transflag & OB_DUPLI) { if ((ob->transflag & OB_DUPLIGROUP) && ob->dup_group) { GroupObject *go; - for (go= ob->dup_group->gobject.first; go; go= go->next) { + for (go = ob->dup_group->gobject.first; go; go = go->next) { if (go->ob) { node2 = dag_get_node(dag, go->ob); /* node2 changes node1, this keeps animations updated in groups?? not logical? */ @@ -514,14 +514,14 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O } /* softbody collision */ - if ((ob->type==OB_MESH) || (ob->type==OB_CURVE) || (ob->type==OB_LATTICE)) { + if ((ob->type == OB_MESH) || (ob->type == OB_CURVE) || (ob->type == OB_LATTICE)) { if (modifiers_isSoftbodyEnabled(ob) || modifiers_isClothEnabled(ob) || ob->particlesystem.first) - dag_add_collision_field_relation(dag, scene, ob, node); /* TODO: use effectorweight->group */ + dag_add_collision_field_relation(dag, scene, ob, node); /* TODO: use effectorweight->group */ } /* object data drivers */ if (ob->data) { - AnimData *adt= BKE_animdata_from_id((ID *)ob->data); + AnimData *adt = BKE_animdata_from_id((ID *)ob->data); if (adt) dag_add_driver_relation(adt, dag, node, 1); } @@ -537,49 +537,49 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Camera DoF"); } } - break; + break; case OB_MBALL: { - Object *mom= BKE_metaball_basis_find(scene, ob); + Object *mom = BKE_metaball_basis_find(scene, ob); - if (mom!=ob) { + if (mom != ob) { node2 = dag_get_node(dag, mom); - dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Metaball"); // mom depends on children! + dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Metaball"); // mom depends on children! } } - break; + break; case OB_CURVE: case OB_FONT: { - Curve *cu= ob->data; + Curve *cu = ob->data; if (cu->bevobj) { node2 = dag_get_node(dag, cu->bevobj); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Curve Bevel"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Curve Bevel"); } if (cu->taperobj) { node2 = dag_get_node(dag, cu->taperobj); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Curve Taper"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Curve Taper"); } if (ob->type == OB_FONT) { if (cu->textoncurve) { node2 = dag_get_node(dag, cu->textoncurve); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Texture On Curve"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Texture On Curve"); } } } - break; + break; } /* particles */ - psys= ob->particlesystem.first; + psys = ob->particlesystem.first; if (psys) { GroupObject *go; - for (; psys; psys=psys->next) { + for (; psys; psys = psys->next) { BoidRule *rule = NULL; BoidState *state = NULL; - ParticleSettings *part= psys->part; + ParticleSettings *part = psys->part; ListBase *effectors = NULL; EffectorCache *eff; @@ -591,12 +591,12 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O if (ELEM(part->phystype, PART_PHYS_KEYED, PART_PHYS_BOIDS)) { ParticleTarget *pt = psys->targets.first; - for (; pt; pt=pt->next) { - if (pt->ob && BLI_findlink(&pt->ob->particlesystem, pt->psys-1)) { + for (; pt; pt = pt->next) { + if (pt->ob && BLI_findlink(&pt->ob->particlesystem, pt->psys - 1)) { node2 = dag_get_node(dag, pt->ob); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Particle Targets"); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Particle Targets"); } - } + } } if (part->ren_as == PART_DRAW_OB && part->dup_ob) { @@ -610,7 +610,7 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O } if (part->ren_as == PART_DRAW_GR && part->dup_group) { - for (go=part->dup_group->gobject.first; go; go=go->next) { + for (go = part->dup_group->gobject.first; go; go = go->next) { node2 = dag_get_node(dag, go->ob); dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Particle Group Visualisation"); } @@ -618,23 +618,25 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O effectors = pdInitEffectors(scene, ob, psys, part->effector_weights); - if (effectors) for (eff = effectors->first; eff; eff=eff->next) { - if (eff->psys) { - node2 = dag_get_node(dag, eff->ob); - dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA|DAG_RL_OB_DATA, "Particle Field"); + if (effectors) { + for (eff = effectors->first; eff; eff = eff->next) { + if (eff->psys) { + node2 = dag_get_node(dag, eff->ob); + dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Particle Field"); + } } } pdEndEffectors(&effectors); if (part->boids) { - for (state = part->boids->states.first; state; state=state->next) { - for (rule = state->rules.first; rule; rule=rule->next) { + for (state = part->boids->states.first; state; state = state->next) { + for (rule = state->rules.first; rule; rule = rule->next) { Object *ruleob = NULL; - if (rule->type==eBoidRuleType_Avoid) - ruleob = ((BoidRuleGoalAvoid*)rule)->ob; - else if (rule->type==eBoidRuleType_FollowLeader) - ruleob = ((BoidRuleFollowLeader*)rule)->ob; + if (rule->type == eBoidRuleType_Avoid) + ruleob = ((BoidRuleGoalAvoid *)rule)->ob; + else if (rule->type == eBoidRuleType_FollowLeader) + ruleob = ((BoidRuleFollowLeader *)rule)->ob; if (ruleob) { node2 = dag_get_node(dag, ruleob); @@ -647,8 +649,8 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O } /* object constraints */ - for (con = ob->constraints.first; con; con=con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = ob->constraints.first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); ListBase targets = {NULL, NULL}; bConstraintTarget *ct; @@ -657,25 +659,25 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O /* special case for camera tracking -- it doesn't use targets to define relations */ if (ELEM3(cti->type, CONSTRAINT_TYPE_FOLLOWTRACK, CONSTRAINT_TYPE_CAMERASOLVER, CONSTRAINT_TYPE_OBJECTSOLVER)) { - int depends_on_camera= 0; + int depends_on_camera = 0; - if (cti->type==CONSTRAINT_TYPE_FOLLOWTRACK) { - bFollowTrackConstraint *data= (bFollowTrackConstraint *)con->data; + if (cti->type == CONSTRAINT_TYPE_FOLLOWTRACK) { + bFollowTrackConstraint *data = (bFollowTrackConstraint *)con->data; - if ((data->clip || data->flag&FOLLOWTRACK_ACTIVECLIP) && data->track[0]) - depends_on_camera= 1; + if ((data->clip || data->flag & FOLLOWTRACK_ACTIVECLIP) && data->track[0]) + depends_on_camera = 1; if (data->depth_ob) { node2 = dag_get_node(dag, data->depth_ob); - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, cti->name); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, cti->name); } } - else if (cti->type==CONSTRAINT_TYPE_OBJECTSOLVER) - depends_on_camera= 1; + else if (cti->type == CONSTRAINT_TYPE_OBJECTSOLVER) + depends_on_camera = 1; if (depends_on_camera && scene->camera) { node2 = dag_get_node(dag, scene->camera); - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, cti->name); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, cti->name); } dag_add_relation(dag, scenenode, node, DAG_RL_SCENE, "Scene Relation"); @@ -684,20 +686,20 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O else if (cti->get_constraint_targets) { cti->get_constraint_targets(con, &targets); - for (ct= targets.first; ct; ct= ct->next) { + for (ct = targets.first; ct; ct = ct->next) { Object *obt; if (ct->tar) - obt= ct->tar; + obt = ct->tar; else continue; node2 = dag_get_node(dag, obt); if (ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO)) - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, cti->name); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, cti->name); else { if (ELEM3(obt->type, OB_ARMATURE, OB_MESH, OB_LATTICE) && (ct->subtarget[0])) { - dag_add_relation(dag, node2, node, DAG_RL_DATA_OB|DAG_RL_OB_OB, cti->name); + dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, cti->name); if (obt->type == OB_MESH) node2->customdata_mask |= CD_MASK_MDEFORMVERT; } @@ -712,12 +714,11 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O } } - if (addtoroot == 1 ) + if (addtoroot == 1) dag_add_relation(dag, scenenode, node, DAG_RL_SCENE, "Scene Relation"); } -struct DagForest *build_dag(Main *bmain, Scene *sce, short mask) -{ +struct DagForest *build_dag(Main *bmain, Scene *sce, short mask){ Base *base; Object *ob; Group *group; @@ -728,8 +729,8 @@ struct DagForest *build_dag(Main *bmain, Scene *sce, short mask) DagAdjList *itA; dag = sce->theDag; - sce->dagisvalid=1; - if ( dag) + sce->dagisvalid = 1; + if (dag) free_forest(dag); else { dag = dag_init(); @@ -740,8 +741,8 @@ struct DagForest *build_dag(Main *bmain, Scene *sce, short mask) scenenode = dag_add_node(dag, sce); /* add current scene objects */ - for (base = sce->base.first; base; base= base->next) { - ob= base->object; + for (base = sce->base.first; base; base = base->next) { + ob = base->object; build_dag_object(dag, scenenode, sce, ob, mask); if (ob->proxy) @@ -753,9 +754,9 @@ struct DagForest *build_dag(Main *bmain, Scene *sce, short mask) } /* add groups used in current scene objects */ - for (group= bmain->group.first; group; group= group->id.next) { + for (group = bmain->group.first; group; group = group->id.next) { if (group->id.flag & LIB_DOIT) { - for (go= group->gobject.first; go; go= go->next) { + for (go = group->gobject.first; go; go = go->next) { build_dag_object(dag, scenenode, sce, go->ob, mask); } group->id.flag &= ~LIB_DOIT; @@ -767,23 +768,23 @@ struct DagForest *build_dag(Main *bmain, Scene *sce, short mask) * the relation type has to be synced. One of the parents can change, and should give same event to child */ /* nodes were callocced, so we can use node->color for temporal storage */ - for (node = sce->theDag->DagNode.first; node; node= node->next) { - if (node->type==ID_OB) { - for (itA = node->child; itA; itA= itA->next) { - if (itA->node->type==ID_OB) { + for (node = sce->theDag->DagNode.first; node; node = node->next) { + if (node->type == ID_OB) { + for (itA = node->child; itA; itA = itA->next) { + if (itA->node->type == ID_OB) { itA->node->color |= itA->type; } } /* also flush custom data mask */ - ((Object*)node->ob)->customdata_mask= node->customdata_mask; + ((Object *)node->ob)->customdata_mask = node->customdata_mask; } } /* now set relations equal, so that when only one parent changes, the correct recalcs are found */ - for (node = sce->theDag->DagNode.first; node; node= node->next) { - if (node->type==ID_OB) { - for (itA = node->child; itA; itA= itA->next) { - if (itA->node->type==ID_OB) { + for (node = sce->theDag->DagNode.first; node; node = node->next) { + if (node->type == ID_OB) { + for (itA = node->child; itA; itA = itA->next) { + if (itA->node->type == ID_OB) { itA->type |= itA->node->color; } } @@ -825,14 +826,14 @@ void free_forest(DagForest *Dag) } BLI_ghash_free(Dag->nodeHash, NULL, NULL); - Dag->nodeHash= NULL; + Dag->nodeHash = NULL; Dag->DagNode.first = NULL; Dag->DagNode.last = NULL; Dag->numNodes = 0; } -DagNode * dag_find_node (DagForest *forest, void * fob) +DagNode *dag_find_node(DagForest *forest, void *fob) { if (forest->nodeHash) return BLI_ghash_lookup(forest->nodeHash, fob); @@ -840,11 +841,11 @@ DagNode * dag_find_node (DagForest *forest, void * fob) return NULL; } -static int ugly_hack_sorry= 1; // prevent type check -static int dag_print_dependencies= 0; // debugging +static int ugly_hack_sorry = 1; // prevent type check +static int dag_print_dependencies = 0; // debugging /* no checking of existence, use dag_find_node first or dag_get_node */ -DagNode * dag_add_node (DagForest *forest, void * fob) +DagNode *dag_add_node(DagForest *forest, void *fob) { DagNode *node; @@ -853,7 +854,7 @@ DagNode * dag_add_node (DagForest *forest, void * fob) node->ob = fob; node->color = DAG_WHITE; - if (ugly_hack_sorry) node->type = GS(((ID *) fob)->name); // sorry, done for pose sorting + if (ugly_hack_sorry) node->type = GS(((ID *) fob)->name); // sorry, done for pose sorting if (forest->numNodes) { ((DagNode *) forest->DagNode.last)->next = node; forest->DagNode.last = node; @@ -866,18 +867,18 @@ DagNode * dag_add_node (DagForest *forest, void * fob) } if (!forest->nodeHash) - forest->nodeHash= BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "dag_add_node gh"); + forest->nodeHash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "dag_add_node gh"); BLI_ghash_insert(forest->nodeHash, fob, node); } return node; } -DagNode * dag_get_node (DagForest *forest, void * fob) +DagNode *dag_get_node(DagForest *forest, void *fob) { DagNode *node; - node = dag_find_node (forest, fob); + node = dag_find_node(forest, fob); if (!node) node = dag_add_node(forest, fob); return node; @@ -885,10 +886,10 @@ DagNode * dag_get_node (DagForest *forest, void * fob) -DagNode * dag_get_sub_node (DagForest *forest, void * fob) +DagNode *dag_get_sub_node(DagForest *forest, void *fob) { DagNode *node; - DagAdjList *mainchild, *prev=NULL; + DagAdjList *mainchild, *prev = NULL; mainchild = ((DagNode *) forest->DagNode.first)->child; /* remove from first node (scene) adj list if present */ @@ -908,7 +909,7 @@ DagNode * dag_get_sub_node (DagForest *forest, void * fob) prev = mainchild; mainchild = mainchild->next; } - node = dag_find_node (forest, fob); + node = dag_find_node(forest, fob); if (!node) node = dag_add_node(forest, fob); return node; @@ -966,9 +967,9 @@ static const char *dag_node_name(DagNode *node) if (node->ob == NULL) return "null"; else if (ugly_hack_sorry) - return ((ID*)(node->ob))->name+2; + return ((ID *)(node->ob))->name + 2; else - return ((bPoseChannel*)(node->ob))->name; + return ((bPoseChannel *)(node->ob))->name; } static void dag_node_print_dependencies(DagNode *node) @@ -977,7 +978,7 @@ static void dag_node_print_dependencies(DagNode *node) printf("%s depends on:\n", dag_node_name(node)); - for (itA= node->parent; itA; itA= itA->next) + for (itA = node->parent; itA; itA = itA->next) printf(" %s through %s\n", dag_node_name(itA->node), itA->name); printf("\n"); } @@ -989,12 +990,12 @@ static int dag_node_print_dependency_recurs(DagNode *node, DagNode *endnode) if (node->color == DAG_BLACK) return 0; - node->color= DAG_BLACK; + node->color = DAG_BLACK; if (node == endnode) return 1; - for (itA= node->parent; itA; itA= itA->next) { + for (itA = node->parent; itA; itA = itA->next) { if (dag_node_print_dependency_recurs(itA->node, endnode)) { printf(" %s depends on %s through %s.\n", dag_node_name(node), dag_node_name(itA->node), itA->name); return 1; @@ -1008,8 +1009,8 @@ static void dag_node_print_dependency_cycle(DagForest *dag, DagNode *startnode, { DagNode *node; - for (node = dag->DagNode.first; node; node= node->next) - node->color= DAG_WHITE; + for (node = dag->DagNode.first; node; node = node->next) + node->color = DAG_WHITE; printf(" %s depends on %s through %s.\n", dag_node_name(endnode), dag_node_name(startnode), name); dag_node_print_dependency_recurs(startnode, endnode); @@ -1021,16 +1022,16 @@ static int dag_node_recurs_level(DagNode *node, int level) DagAdjList *itA; int newlevel; - node->color= DAG_BLACK; /* done */ - newlevel= ++level; + node->color = DAG_BLACK; /* done */ + newlevel = ++level; - for (itA= node->parent; itA; itA= itA->next) { - if (itA->node->color==DAG_WHITE) { - itA->node->ancestor_count= dag_node_recurs_level(itA->node, level); - newlevel= MAX2(newlevel, level+itA->node->ancestor_count); + for (itA = node->parent; itA; itA = itA->next) { + if (itA->node->color == DAG_WHITE) { + itA->node->ancestor_count = dag_node_recurs_level(itA->node, level); + newlevel = MAX2(newlevel, level + itA->node->ancestor_count); } else - newlevel= MAX2(newlevel, level+itA->node->ancestor_count); + newlevel = MAX2(newlevel, level + itA->node->ancestor_count); } return newlevel; @@ -1043,22 +1044,22 @@ static void dag_check_cycle(DagForest *dag) /* debugging print */ if (dag_print_dependencies) - for (node = dag->DagNode.first; node; node= node->next) + for (node = dag->DagNode.first; node; node = node->next) dag_node_print_dependencies(node); /* tag nodes unchecked */ - for (node = dag->DagNode.first; node; node= node->next) - node->color= DAG_WHITE; + for (node = dag->DagNode.first; node; node = node->next) + node->color = DAG_WHITE; - for (node = dag->DagNode.first; node; node= node->next) { - if (node->color==DAG_WHITE) { - node->ancestor_count= dag_node_recurs_level(node, 0); + for (node = dag->DagNode.first; node; node = node->next) { + if (node->color == DAG_WHITE) { + node->ancestor_count = dag_node_recurs_level(node, 0); } } /* check relations, and print errors */ - for (node = dag->DagNode.first; node; node= node->next) { - for (itA= node->parent; itA; itA= itA->next) { + for (node = dag->DagNode.first; node; node = node->next) { + for (itA = node->parent; itA; itA = itA->next) { if (itA->node->ancestor_count > node->ancestor_count) { if (node->ob && itA->node->ob) { printf("Dependency cycle detected:\n"); @@ -1069,7 +1070,7 @@ static void dag_check_cycle(DagForest *dag) } /* parent relations are only needed for cycle checking, so free now */ - for (node = dag->DagNode.first; node; node= node->next) { + for (node = dag->DagNode.first; node; node = node->next) { while (node->parent) { itA = node->parent->next; MEM_freeN(node->parent); @@ -1082,7 +1083,7 @@ static void dag_check_cycle(DagForest *dag) * MainDAG is the DAG of all objects in current scene * used only for drawing there is one also in each scene */ -static DagForest * MainDag = NULL; +static DagForest *MainDag = NULL; DagForest *getMainDag(void) { @@ -1121,7 +1122,7 @@ void graph_bfs(void) /* fprintf(stderr, "starting BFS\n ------------\n"); */ nqueue = queue_create(DAGQUEUEALLOC); - for ( i=0; i<50; i++) + for (i = 0; i < 50; i++) pos[i] = 0; /* Init @@ -1160,14 +1161,14 @@ void graph_bfs(void) itA = itA->next; } - if (pos[node->BFS_dist] > node->k ) { + if (pos[node->BFS_dist] > node->k) { pos[node->BFS_dist] += 1; node->k = (float) pos[node->BFS_dist]; } else { - pos[node->BFS_dist] = (int) node->k +1; + pos[node->BFS_dist] = (int) node->k + 1; } - set_node_xy(node, node->BFS_dist*DEPSX*2, pos[node->BFS_dist]*DEPSY*2); + set_node_xy(node, node->BFS_dist * DEPSX * 2, pos[node->BFS_dist] * DEPSY * 2); node->color = DAG_BLACK; // fprintf(stderr, "BFS node : %20s %i %5.0f %5.0f\n", ((ID *) node->ob)->name, node->BFS_dist, node->x, node->y); @@ -1190,7 +1191,7 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a DagNode *node; DagNodeQueue *nqueue; DagAdjList *itA; - int retval = 0; + int retval = 0; /* fprintf(stderr, "starting BFS\n ------------\n"); */ /* Init @@ -1238,7 +1239,7 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a } /* non recursive version of DFS, return queue -- outer loop present to catch odd cases (first level cycles)*/ -DagNodeQueue * graph_dfs(void) +DagNodeQueue *graph_dfs(void) { DagNode *node; DagNodeQueue *nqueue; @@ -1249,14 +1250,14 @@ DagNodeQueue * graph_dfs(void) int time; int skip = 0; int minheight; - int maxpos=0; + int maxpos = 0; /* int is_cycle = 0; */ /* UNUSED */ /* - *fprintf(stderr, "starting DFS\n ------------\n"); + *fprintf(stderr, "starting DFS\n ------------\n"); */ nqueue = queue_create(DAGQUEUEALLOC); retqueue = queue_create(MainDag->numNodes); - for ( i=0; i<50; i++) + for (i = 0; i < 50; i++) pos[i] = 0; /* Init @@ -1276,86 +1277,86 @@ DagNodeQueue * graph_dfs(void) node = MainDag->DagNode.first; do { - if (node->color == DAG_WHITE) { - node->color = DAG_GRAY; - node->DFS_dist = 1; - node->DFS_dvtm = time; - time++; - push_stack(nqueue, node); + if (node->color == DAG_WHITE) { + node->color = DAG_GRAY; + node->DFS_dist = 1; + node->DFS_dvtm = time; + time++; + push_stack(nqueue, node); - while (nqueue->count) { - //graph_print_queue(nqueue); + while (nqueue->count) { + //graph_print_queue(nqueue); - skip = 0; - node = get_top_node_queue(nqueue); + skip = 0; + node = get_top_node_queue(nqueue); - minheight = pos[node->DFS_dist]; + minheight = pos[node->DFS_dist]; - itA = node->child; - while (itA != NULL) { - if (itA->node->color == DAG_WHITE) { - itA->node->DFS_dvtm = time; - itA->node->color = DAG_GRAY; + itA = node->child; + while (itA != NULL) { + if (itA->node->color == DAG_WHITE) { + itA->node->DFS_dvtm = time; + itA->node->color = DAG_GRAY; - time++; - itA->node->DFS_dist = node->DFS_dist + 1; - itA->node->k = (float) minheight; - push_stack(nqueue, itA->node); - skip = 1; - break; - } - else { - if (itA->node->color == DAG_GRAY) { // back edge - fprintf(stderr, "dfs back edge :%15s %15s\n", ((ID *) node->ob)->name, ((ID *) itA->node->ob)->name); - /* is_cycle = 1; */ /* UNUSED */ + time++; + itA->node->DFS_dist = node->DFS_dist + 1; + itA->node->k = (float) minheight; + push_stack(nqueue, itA->node); + skip = 1; + break; } - else if (itA->node->color == DAG_BLACK) { - /* already processed node but we may want later to change distance either to shorter to longer. - * DFS_dist is the first encounter - */ + else { + if (itA->node->color == DAG_GRAY) { // back edge + fprintf(stderr, "dfs back edge :%15s %15s\n", ((ID *) node->ob)->name, ((ID *) itA->node->ob)->name); + /* is_cycle = 1; */ /* UNUSED */ + } + else if (itA->node->color == DAG_BLACK) { + /* already processed node but we may want later to change distance either to shorter to longer. + * DFS_dist is the first encounter + */ #if 0 - if (node->DFS_dist >= itA->node->DFS_dist) - itA->node->DFS_dist = node->DFS_dist + 1; + if (node->DFS_dist >= itA->node->DFS_dist) + itA->node->DFS_dist = node->DFS_dist + 1; fprintf(stderr, "dfs forward or cross edge :%15s %i-%i %15s %i-%i\n", - ((ID *) node->ob)->name, - node->DFS_dvtm, - node->DFS_fntm, - ((ID *) itA->node->ob)->name, - itA->node->DFS_dvtm, - itA->node->DFS_fntm); + ((ID *) node->ob)->name, + node->DFS_dvtm, + node->DFS_fntm, + ((ID *) itA->node->ob)->name, + itA->node->DFS_dvtm, + itA->node->DFS_fntm); #endif + } + else + fprintf(stderr, "dfs unknown edge\n"); } - else - fprintf(stderr, "dfs unknown edge\n"); + itA = itA->next; } - itA = itA->next; - } - if (!skip) { - node = pop_queue(nqueue); - node->color = DAG_BLACK; + if (!skip) { + node = pop_queue(nqueue); + node->color = DAG_BLACK; - node->DFS_fntm = time; - time++; - if (node->DFS_dist > maxpos) - maxpos = node->DFS_dist; - if (pos[node->DFS_dist] > node->k ) { - pos[node->DFS_dist] += 1; - node->k = (float) pos[node->DFS_dist]; - } - else { - pos[node->DFS_dist] = (int) node->k +1; - } - set_node_xy(node, node->DFS_dist*DEPSX*2, pos[node->DFS_dist]*DEPSY*2); + node->DFS_fntm = time; + time++; + if (node->DFS_dist > maxpos) + maxpos = node->DFS_dist; + if (pos[node->DFS_dist] > node->k) { + pos[node->DFS_dist] += 1; + node->k = (float) pos[node->DFS_dist]; + } + else { + pos[node->DFS_dist] = (int) node->k + 1; + } + set_node_xy(node, node->DFS_dist * DEPSX * 2, pos[node->DFS_dist] * DEPSY * 2); - // fprintf(stderr, "DFS node : %20s %i %i %i %i\n", ((ID *) node->ob)->name, node->BFS_dist, node->DFS_dist, node->DFS_dvtm, node->DFS_fntm ); + // fprintf(stderr, "DFS node : %20s %i %i %i %i\n", ((ID *) node->ob)->name, node->BFS_dist, node->DFS_dist, node->DFS_dvtm, node->DFS_fntm ); - push_stack(retqueue, node); + push_stack(retqueue, node); + } } } - } node = node->next; } while (node); // fprintf(stderr, "i size : %i\n", maxpos); @@ -1382,7 +1383,7 @@ int pre_and_post_source_DFS(DagForest *dag, short mask, DagNode *source, graph_a int skip = 0; int retval = 0; /* - *fprintf(stderr, "starting DFS\n ------------\n"); + * fprintf(stderr, "starting DFS\n ------------\n"); */ nqueue = queue_create(DAGQUEUEALLOC); @@ -1429,7 +1430,7 @@ int pre_and_post_source_DFS(DagForest *dag, short mask, DagNode *source, graph_a break; } else { - if (itA->node->color == DAG_GRAY) {// back edge + if (itA->node->color == DAG_GRAY) { // back edge retval = 1; } // else if (itA->node->color == DAG_BLACK) { // cross or forward @@ -1457,14 +1458,13 @@ int pre_and_post_source_DFS(DagForest *dag, short mask, DagNode *source, graph_a // used to get the obs owning a datablock -struct DagNodeQueue *get_obparents(struct DagForest *dag, void *ob) -{ - DagNode * node, *node1; +struct DagNodeQueue *get_obparents(struct DagForest *dag, void *ob){ + DagNode *node, *node1; DagNodeQueue *nqueue; DagAdjList *itA; node = dag_find_node(dag, ob); - if (node==NULL) { + if (node == NULL) { return NULL; } else if (node->ancestor_count == 1) { // simple case @@ -1491,9 +1491,8 @@ struct DagNodeQueue *get_obparents(struct DagForest *dag, void *ob) return nqueue; } -struct DagNodeQueue *get_first_ancestors(struct DagForest *dag, void *ob) -{ - DagNode * node, *node1; +struct DagNodeQueue *get_first_ancestors(struct DagForest *dag, void *ob){ + DagNode *node, *node1; DagNodeQueue *nqueue; DagAdjList *itA; @@ -1520,8 +1519,7 @@ struct DagNodeQueue *get_first_ancestors(struct DagForest *dag, void *ob) } // standard DFS list -struct DagNodeQueue *get_all_childs(struct DagForest *dag, void *ob) -{ +struct DagNodeQueue *get_all_childs(struct DagForest *dag, void *ob){ DagNode *node; DagNodeQueue *nqueue; DagNodeQueue *retqueue; @@ -1581,9 +1579,9 @@ struct DagNodeQueue *get_all_childs(struct DagForest *dag, void *ob) /* unused */ #if 0 -short are_obs_related(struct DagForest *dag, void *ob1, void *ob2) +short are_obs_related(struct DagForest *dag, void *ob1, void *ob2) { - DagNode * node; + DagNode *node; DagAdjList *itA; node = dag_find_node(dag, ob1); @@ -1599,7 +1597,7 @@ short are_obs_related(struct DagForest *dag, void *ob1, void *ob2) } #endif -int is_acyclic(DagForest *dag) +int is_acyclic(DagForest *dag) { return dag->is_acyclic; } @@ -1634,9 +1632,9 @@ void graph_print_queue_dist(DagNodeQueue *nqueue) count = 0; while (queueElem) { fprintf(stderr, "** %25s %2.2i-%2.2i ", ((ID *) queueElem->node->ob)->name, queueElem->node->DFS_dvtm, queueElem->node->DFS_fntm); - while (count < queueElem->node->DFS_dvtm-1) { fputc(' ', stderr); count++;} + while (count < queueElem->node->DFS_dvtm - 1) { fputc(' ', stderr); count++; } fputc('|', stderr); - while (count < queueElem->node->DFS_fntm-2) { fputc('-', stderr); count++;} + while (count < queueElem->node->DFS_fntm - 2) { fputc('-', stderr); count++; } fputc('|', stderr); fputc('\n', stderr); count = 0; @@ -1668,13 +1666,13 @@ void graph_print_adj_list(void) /* mechanism to allow editors to be informed of depsgraph updates, * to do their own updates based on changes... */ -static void (*EditorsUpdateIDCb)(Main *bmain, ID *id)= NULL; -static void (*EditorsUpdateSceneCb)(Main *bmain, Scene *scene, int updated)= NULL; +static void (*EditorsUpdateIDCb)(Main *bmain, ID *id) = NULL; +static void (*EditorsUpdateSceneCb)(Main *bmain, Scene *scene, int updated) = NULL; void DAG_editors_update_cb(void (*id_func)(Main *bmain, ID *id), void (*scene_func)(Main *bmain, Scene *scene, int updated)) { - EditorsUpdateIDCb= id_func; - EditorsUpdateSceneCb= scene_func; + EditorsUpdateIDCb = id_func; + EditorsUpdateSceneCb = scene_func; } static void dag_editors_id_update(Main *bmain, ID *id) @@ -1698,37 +1696,37 @@ static void scene_sort_groups(Main *bmain, Scene *sce) Object *ob; /* test; are group objects all in this scene? */ - for (ob= bmain->object.first; ob; ob= ob->id.next) { + for (ob = bmain->object.first; ob; ob = ob->id.next) { ob->id.flag &= ~LIB_DOIT; - ob->id.newid= NULL; /* newid abuse for GroupObject */ + ob->id.newid = NULL; /* newid abuse for GroupObject */ } - for (base = sce->base.first; base; base= base->next) + for (base = sce->base.first; base; base = base->next) base->object->id.flag |= LIB_DOIT; - for (group= bmain->group.first; group; group= group->id.next) { - for (go= group->gobject.first; go; go= go->next) { - if ((go->ob->id.flag & LIB_DOIT)==0) + for (group = bmain->group.first; group; group = group->id.next) { + for (go = group->gobject.first; go; go = go->next) { + if ((go->ob->id.flag & LIB_DOIT) == 0) break; } /* this group is entirely in this scene */ - if (go==NULL) { - ListBase listb= {NULL, NULL}; + if (go == NULL) { + ListBase listb = {NULL, NULL}; - for (go= group->gobject.first; go; go= go->next) - go->ob->id.newid= (ID *)go; + for (go = group->gobject.first; go; go = go->next) + go->ob->id.newid = (ID *)go; /* in order of sorted bases we reinsert group objects */ - for (base = sce->base.first; base; base= base->next) { + for (base = sce->base.first; base; base = base->next) { if (base->object->id.newid) { - go= (GroupObject *)base->object->id.newid; - base->object->id.newid= NULL; + go = (GroupObject *)base->object->id.newid; + base->object->id.newid = NULL; BLI_remlink(&group->gobject, go); BLI_addtail(&listb, go); } } /* copy the newly sorted listbase */ - group->gobject= listb; + group->gobject = listb; } } } @@ -1744,7 +1742,7 @@ void DAG_scene_sort(Main *bmain, Scene *sce) ListBase tempbase; Base *base; - tempbase.first= tempbase.last= NULL; + tempbase.first = tempbase.last = NULL; build_dag(bmain, sce, DAG_RL_ALL_BUT_DATA); @@ -1752,7 +1750,7 @@ void DAG_scene_sort(Main *bmain, Scene *sce) nqueue = queue_create(DAGQUEUEALLOC); - for (node = sce->theDag->DagNode.first; node; node= node->next) { + for (node = sce->theDag->DagNode.first; node; node = node->next) { node->color = DAG_WHITE; } @@ -1785,7 +1783,7 @@ void DAG_scene_sort(Main *bmain, Scene *sce) if (!skip) { if (node) { node = pop_queue(nqueue); - if (node->ob == sce) // we are done + if (node->ob == sce) // we are done break; node->color = DAG_BLACK; @@ -1807,7 +1805,7 @@ void DAG_scene_sort(Main *bmain, Scene *sce) BLI_remlink(&sce->base, base); BLI_addhead(&tempbase, base); //if (G.debug & G_DEBUG) - printf("cyclic %s\n", base->object->id.name); + printf("cyclic %s\n", base->object->id.name); base = sce->base.first; } @@ -1819,12 +1817,12 @@ void DAG_scene_sort(Main *bmain, Scene *sce) if (G.debug & G_DEBUG) { printf("\nordered\n"); - for (base = sce->base.first; base; base= base->next) { + for (base = sce->base.first; base; base = base->next) { printf(" %s\n", base->object->id.name); } } /* temporal...? */ - sce->recalc |= SCE_PRV_CHANGED; /* test for 3d preview */ + sce->recalc |= SCE_PRV_CHANGED; /* test for 3d preview */ } static void lib_id_recalc_tag(Main *bmain, ID *id) @@ -1842,26 +1840,26 @@ static void lib_id_recalc_data_tag(Main *bmain, ID *id) /* node was checked to have lasttime != curtime and is if type ID_OB */ static void flush_update_node(DagNode *node, unsigned int layer, int curtime) { - Main *bmain= G.main; + Main *bmain = G.main; DagAdjList *itA; Object *ob, *obc; - int oldflag, changed=0; + int oldflag, changed = 0; unsigned int all_layer; - node->lasttime= curtime; + node->lasttime = curtime; - ob= node->ob; + ob = node->ob; if (ob && (ob->recalc & OB_RECALC_ALL)) { - all_layer= node->scelay; + all_layer = node->scelay; /* got an object node that changes, now check relations */ - for (itA = node->child; itA; itA= itA->next) { + for (itA = node->child; itA; itA = itA->next) { all_layer |= itA->lay; /* the relationship is visible */ if ((itA->lay & layer)) { // XXX || (itA->node->ob == obedit) - if (itA->node->type==ID_OB) { - obc= itA->node->ob; - oldflag= obc->recalc; + if (itA->node->type == ID_OB) { + obc = itA->node->ob; + oldflag = obc->recalc; /* got a ob->obc relation, now check if flag needs flush */ if (ob->recalc & OB_RECALC_OB) { @@ -1888,12 +1886,12 @@ static void flush_update_node(DagNode *node, unsigned int layer, int curtime) lib_id_recalc_data_tag(bmain, &obc->id); } } - if (oldflag!=obc->recalc) changed= 1; + if (oldflag != obc->recalc) changed = 1; } } } /* even nicer, we can clear recalc flags... */ - if ((all_layer & layer)==0) { // XXX && (ob != obedit)) { + if ((all_layer & layer) == 0) { // XXX && (ob != obedit)) { /* but existing displaylists or derivedmesh should be freed */ if (ob->recalc & OB_RECALC_DATA) BKE_object_free_display(ob); @@ -1905,15 +1903,15 @@ static void flush_update_node(DagNode *node, unsigned int layer, int curtime) /* check case where child changes and parent forcing obdata to change */ /* should be done regardless if this ob has recalc set */ /* could merge this in with loop above...? (ton) */ - for (itA = node->child; itA; itA= itA->next) { + for (itA = node->child; itA; itA = itA->next) { /* the relationship is visible */ - if ((itA->lay & layer)) { // XXX || (itA->node->ob == obedit) - if (itA->node->type==ID_OB) { - obc= itA->node->ob; + if ((itA->lay & layer)) { // XXX || (itA->node->ob == obedit) + if (itA->node->type == ID_OB) { + obc = itA->node->ob; /* child moves */ - if ((obc->recalc & OB_RECALC_ALL)==OB_RECALC_OB) { + if ((obc->recalc & OB_RECALC_ALL) == OB_RECALC_OB) { /* parent has deforming info */ - if (itA->type & (DAG_RL_OB_DATA|DAG_RL_DATA_DATA)) { + if (itA->type & (DAG_RL_OB_DATA | DAG_RL_DATA_DATA)) { // printf("parent %s changes ob %s\n", ob->id.name, obc->id.name); obc->recalc |= OB_RECALC_DATA; lib_id_recalc_data_tag(bmain, &obc->id); @@ -1924,8 +1922,8 @@ static void flush_update_node(DagNode *node, unsigned int layer, int curtime) } /* we only go deeper if node not checked or something changed */ - for (itA = node->child; itA; itA= itA->next) { - if (changed || itA->node->lasttime!=curtime) + for (itA = node->child; itA; itA = itA->next) { + if (changed || itA->node->lasttime != curtime) flush_update_node(itA->node, layer, curtime); } @@ -1936,15 +1934,15 @@ static unsigned int flush_layer_node(Scene *sce, DagNode *node, int curtime) { DagAdjList *itA; - node->lasttime= curtime; - node->lay= node->scelay; + node->lasttime = curtime; + node->lay = node->scelay; - for (itA = node->child; itA; itA= itA->next) { - if (itA->node->type==ID_OB) { - if (itA->node->lasttime!=curtime) { - itA->lay= flush_layer_node(sce, itA->node, curtime); // lay is only set once for each relation + for (itA = node->child; itA; itA = itA->next) { + if (itA->node->type == ID_OB) { + if (itA->node->lasttime != curtime) { + itA->lay = flush_layer_node(sce, itA->node, curtime); // lay is only set once for each relation } - else itA->lay= itA->node->lay; + else itA->lay = itA->node->lay; node->lay |= itA->lay; } @@ -1956,16 +1954,16 @@ static unsigned int flush_layer_node(Scene *sce, DagNode *node, int curtime) /* node was checked to have lasttime != curtime, and is of type ID_OB */ static void flush_pointcache_reset(Scene *scene, DagNode *node, int curtime, int reset) { - Main *bmain= G.main; + Main *bmain = G.main; DagAdjList *itA; Object *ob; - node->lasttime= curtime; + node->lasttime = curtime; - for (itA = node->child; itA; itA= itA->next) { - if (itA->node->type==ID_OB) { - if (itA->node->lasttime!=curtime) { - ob= (Object*)(itA->node->ob); + for (itA = node->child; itA; itA = itA->next) { + if (itA->node->type == ID_OB) { + if (itA->node->lasttime != curtime) { + ob = (Object *)(itA->node->ob); if (reset || (ob->recalc & OB_RECALC_ALL)) { if (BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_DEPSGRAPH)) { @@ -1990,18 +1988,18 @@ static void dag_scene_flush_layers(Scene *sce, int lay) Base *base; int lasttime; - firstnode= sce->theDag->DagNode.first; // always scene node + firstnode = sce->theDag->DagNode.first; // always scene node - for (itA = firstnode->child; itA; itA= itA->next) - itA->lay= 0; + for (itA = firstnode->child; itA; itA = itA->next) + itA->lay = 0; - sce->theDag->time++; // so we know which nodes were accessed - lasttime= sce->theDag->time; + sce->theDag->time++; // so we know which nodes were accessed + lasttime = sce->theDag->time; /* update layer flags in nodes */ - for (base= sce->base.first; base; base= base->next) { - node= dag_get_node(sce->theDag, base->object); - node->scelay= base->object->lay; + for (base = sce->base.first; base; base = base->next) { + node = dag_get_node(sce->theDag, base->object); + node->scelay = base->object->lay; } /* ensure cameras are set as if they are on a visible layer, because @@ -2009,7 +2007,7 @@ static void dag_scene_flush_layers(Scene *sce, int lay) * * XXX, this wont work for local view / unlocked camera's */ if (sce->camera) { - node= dag_get_node(sce->theDag, sce->camera); + node = dag_get_node(sce->theDag, sce->camera); node->scelay |= lay; } @@ -2017,9 +2015,9 @@ static void dag_scene_flush_layers(Scene *sce, int lay) { TimeMarker *m; - for (m= sce->markers.first; m; m= m->next) { + for (m = sce->markers.first; m; m = m->next) { if (m->camera) { - node= dag_get_node(sce->theDag, m->camera); + node = dag_get_node(sce->theDag, m->camera); node->scelay |= lay; } } @@ -2027,8 +2025,8 @@ static void dag_scene_flush_layers(Scene *sce, int lay) #endif /* flush layer nodes to dependencies */ - for (itA = firstnode->child; itA; itA= itA->next) - if (itA->node->lasttime!=lasttime && itA->node->type==ID_OB) + for (itA = firstnode->child; itA; itA = itA->next) + if (itA->node->lasttime != lasttime && itA->node->type == ID_OB) flush_layer_node(sce, itA->node, lasttime); } @@ -2037,16 +2035,16 @@ static void dag_tag_renderlayers(Scene *sce, unsigned int lay) if (sce->nodetree) { bNode *node; Base *base; - unsigned int lay_changed= 0; + unsigned int lay_changed = 0; - for (base= sce->base.first; base; base= base->next) + for (base = sce->base.first; base; base = base->next) if (base->lay & lay) if (base->object->recalc) lay_changed |= base->lay; - for (node= sce->nodetree->nodes.first; node; node= node->next) { - if (node->id==(ID *)sce) { - SceneRenderLayer *srl= BLI_findlink(&sce->r.layers, node->custom1); + for (node = sce->nodetree->nodes.first; node; node = node->next) { + if (node->id == (ID *)sce) { + SceneRenderLayer *srl = BLI_findlink(&sce->r.layers, node->custom1); if (srl && (srl->lay & lay_changed)) nodeUpdate(sce->nodetree, node); } @@ -2062,30 +2060,30 @@ void DAG_scene_flush_update(Main *bmain, Scene *sce, unsigned int lay, const sho Object *ob; int lasttime; - if (sce->theDag==NULL) { + if (sce->theDag == NULL) { printf("DAG zero... not allowed to happen!\n"); DAG_scene_sort(bmain, sce); } - firstnode= sce->theDag->DagNode.first; // always scene node + firstnode = sce->theDag->DagNode.first; // always scene node /* first we flush the layer flags */ dag_scene_flush_layers(sce, lay); /* then we use the relationships + layer info to flush update events */ - sce->theDag->time++; // so we know which nodes were accessed - lasttime= sce->theDag->time; - for (itA = firstnode->child; itA; itA= itA->next) - if (itA->node->lasttime!=lasttime && itA->node->type==ID_OB) + sce->theDag->time++; // so we know which nodes were accessed + lasttime = sce->theDag->time; + for (itA = firstnode->child; itA; itA = itA->next) + if (itA->node->lasttime != lasttime && itA->node->type == ID_OB) flush_update_node(itA->node, lay, lasttime); /* if update is not due to time change, do pointcache clears */ if (!time) { - sce->theDag->time++; // so we know which nodes were accessed - lasttime= sce->theDag->time; - for (itA = firstnode->child; itA; itA= itA->next) { - if (itA->node->lasttime!=lasttime && itA->node->type==ID_OB) { - ob= (Object*)(itA->node->ob); + sce->theDag->time++; // so we know which nodes were accessed + lasttime = sce->theDag->time; + for (itA = firstnode->child; itA; itA = itA->next) { + if (itA->node->lasttime != lasttime && itA->node->type == ID_OB) { + ob = (Object *)(itA->node->ob); if (ob->recalc & OB_RECALC_ALL) { if (BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH)) { @@ -2109,7 +2107,7 @@ static int object_modifiers_use_time(Object *ob) ModifierData *md; /* check if a modifier in modifier stack needs time input */ - for (md=ob->modifiers.first; md; md=md->next) + for (md = ob->modifiers.first; md; md = md->next) if (modifier_dependsOnTime(md)) return 1; @@ -2148,14 +2146,14 @@ static short animdata_use_time(AnimData *adt) { NlaTrack *nlt; - if (adt==NULL) return 0; + if (adt == NULL) return 0; /* check action - only if assigned, and it has anim curves */ if (adt->action && adt->action->curves.first) return 1; /* check NLA tracks + strips */ - for (nlt= adt->nla_tracks.first; nlt; nlt= nlt->next) { + for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) { if (nlt->strips.first) return 1; } @@ -2184,8 +2182,8 @@ static void dag_object_time_update_flags(Object *ob) { if (ob->constraints.first) { bConstraint *con; - for (con = ob->constraints.first; con; con=con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = ob->constraints.first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); ListBase targets = {NULL, NULL}; bConstraintTarget *ct; @@ -2197,7 +2195,7 @@ static void dag_object_time_update_flags(Object *ob) else if (cti->get_constraint_targets) { cti->get_constraint_targets(con, &targets); - for (ct= targets.first; ct; ct= ct->next) { + for (ct = targets.first; ct; ct = ct->next) { if (ct->tar) { ob->recalc |= OB_RECALC_OB; break; @@ -2214,7 +2212,7 @@ static void dag_object_time_update_flags(Object *ob) if (ob->parent) { /* motion path or bone child */ - if (ob->parent->type==OB_CURVE || ob->parent->type==OB_ARMATURE) ob->recalc |= OB_RECALC_OB; + if (ob->parent->type == OB_CURVE || ob->parent->type == OB_ARMATURE) ob->recalc |= OB_RECALC_OB; } #if 0 // XXX old animation system @@ -2222,7 +2220,7 @@ static void dag_object_time_update_flags(Object *ob) if (ob->dup_group) { bActionStrip *strip; /* this case is for groups with nla, whilst nla target has no action or nla */ - for (strip= ob->nlastrips.first; strip; strip= strip->next) { + for (strip = ob->nlastrips.first; strip; strip = strip->next) { if (strip->object) strip->object->recalc |= OB_RECALC_ALL; } @@ -2235,20 +2233,20 @@ static void dag_object_time_update_flags(Object *ob) ob->adt->recalc |= ADT_RECALC_ANIM; } - if ((ob->adt) && (ob->type==OB_ARMATURE)) ob->recalc |= OB_RECALC_DATA; + if ((ob->adt) && (ob->type == OB_ARMATURE)) ob->recalc |= OB_RECALC_DATA; if (object_modifiers_use_time(ob)) ob->recalc |= OB_RECALC_DATA; if ((ob->pose) && (ob->pose->flag & POSE_CONSTRAINTS_TIMEDEPEND)) ob->recalc |= OB_RECALC_DATA; { - AnimData *adt= BKE_animdata_from_id((ID *)ob->data); + AnimData *adt = BKE_animdata_from_id((ID *)ob->data); Mesh *me; Curve *cu; Lattice *lt; switch (ob->type) { case OB_MESH: - me= ob->data; + me = ob->data; if (me->key) { if (!(ob->shapeflag & OB_SHAPE_LOCK)) { ob->recalc |= OB_RECALC_DATA; @@ -2259,7 +2257,7 @@ static void dag_object_time_update_flags(Object *ob) break; case OB_CURVE: case OB_SURF: - cu= ob->data; + cu = ob->data; if (cu->key) { if (!(ob->shapeflag & OB_SHAPE_LOCK)) { ob->recalc |= OB_RECALC_DATA; @@ -2267,18 +2265,18 @@ static void dag_object_time_update_flags(Object *ob) } break; case OB_FONT: - cu= ob->data; - if (cu->nurb.first==NULL && cu->str && cu->vfont) + cu = ob->data; + if (cu->nurb.first == NULL && cu->str && cu->vfont) ob->recalc |= OB_RECALC_DATA; break; case OB_LATTICE: - lt= ob->data; + lt = ob->data; if (lt->key) { if (!(ob->shapeflag & OB_SHAPE_LOCK)) { ob->recalc |= OB_RECALC_DATA; } } - break; + break; case OB_MBALL: if (ob->transflag & OB_DUPLI) ob->recalc |= OB_RECALC_DATA; break; @@ -2290,9 +2288,9 @@ static void dag_object_time_update_flags(Object *ob) } if (ob->particlesystem.first) { - ParticleSystem *psys= ob->particlesystem.first; + ParticleSystem *psys = ob->particlesystem.first; - for (; psys; psys=psys->next) { + for (; psys; psys = psys->next) { if (psys_check_enabled(ob, psys)) { ob->recalc |= OB_RECALC_DATA; break; @@ -2319,7 +2317,7 @@ void DAG_scene_update_flags(Main *bmain, Scene *scene, unsigned int lay, const s /* set ob flags where animated systems are */ for (SETLOOPER(scene, sce_iter, base)) { - ob= base->object; + ob = base->object; if (do_time) { /* now if DagNode were part of base, the node->lay could be checked... */ @@ -2334,22 +2332,22 @@ void DAG_scene_update_flags(Main *bmain, Scene *scene, unsigned int lay, const s if (do_time) { /* we do groups each once */ - for (group= bmain->group.first; group; group= group->id.next) { + for (group = bmain->group.first; group; group = group->id.next) { if (group->id.flag & LIB_DOIT) { - for (go= group->gobject.first; go; go= go->next) { + for (go = group->gobject.first; go; go = go->next) { dag_object_time_update_flags(go->ob); } } } } - for (sce_iter= scene; sce_iter; sce_iter= sce_iter->set) + for (sce_iter = scene; sce_iter; sce_iter = sce_iter->set) DAG_scene_flush_update(bmain, sce_iter, lay, 1); if (do_time) { /* test: set time flag, to disable baked systems to update */ for (SETLOOPER(scene, sce_iter, base)) { - ob= base->object; + ob = base->object; if (ob->recalc) ob->recalc |= OB_RECALC_TIME; } @@ -2360,10 +2358,10 @@ void DAG_scene_update_flags(Main *bmain, Scene *scene, unsigned int lay, const s } /* and store the info in groupobject */ - for (group= bmain->group.first; group; group= group->id.next) { + for (group = bmain->group.first; group; group = group->id.next) { if (group->id.flag & LIB_DOIT) { - for (go= group->gobject.first; go; go= go->next) { - go->recalc= go->ob->recalc; + for (go = group->gobject.first; go; go = go->next) { + go->recalc = go->ob->recalc; // printf("ob %s recalc %d\n", go->ob->id.name, go->recalc); } group->id.flag &= ~LIB_DOIT; @@ -2380,22 +2378,22 @@ static void dag_current_scene_layers(Main *bmain, Scene **sce, unsigned int *lay /* only one scene supported currently, making more scenes work * correctly requires changes beyond just the dependency graph */ - *sce= NULL; - *lay= 0; + *sce = NULL; + *lay = 0; - if ((wm= bmain->wm.first)) { + if ((wm = bmain->wm.first)) { /* if we have a windowmanager, look into windows */ - for (win=wm->windows.first; win; win=win->next) { + for (win = wm->windows.first; win; win = win->next) { if (win->screen) { - if (!*sce) *sce= win->screen->scene; + if (!*sce) *sce = win->screen->scene; *lay |= BKE_screen_visible_layers(win->screen, win->screen->scene); } } } else { /* if not, use the first sce */ - *sce= bmain->scene.first; - if (*sce) *lay= (*sce)->lay; + *sce = bmain->scene.first; + if (*sce) *lay = (*sce)->lay; /* XXX for background mode, we should get the scene * from somewhere, for the -S option, but it's in @@ -2435,9 +2433,9 @@ void DAG_on_visible_update(Main *bmain, const short do_time) dag_scene_flush_layers(scene, lay); for (SETLOOPER(scene, sce_iter, base)) { - ob= base->object; - node= (sce_iter->theDag)? dag_get_node(sce_iter->theDag, ob): NULL; - oblay= (node)? node->lay: ob->lay; + ob = base->object; + node = (sce_iter->theDag) ? dag_get_node(sce_iter->theDag, ob) : NULL; + oblay = (node) ? node->lay : ob->lay; if ((oblay & lay) & ~scene->lay_updated) { if (ELEM6(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL, OB_LATTICE)) @@ -2447,9 +2445,9 @@ void DAG_on_visible_update(Main *bmain, const short do_time) } } - for (group= bmain->group.first; group; group= group->id.next) { + for (group = bmain->group.first; group; group = group->id.next) { if (group->id.flag & LIB_DOIT) { - for (go= group->gobject.first; go; go= go->next) { + for (go = group->gobject.first; go; go = go->next) { if (ELEM6(go->ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL, OB_LATTICE)) go->ob->recalc |= OB_RECALC_DATA; if (go->ob->proxy_from) @@ -2473,7 +2471,7 @@ static void dag_id_flush_update__isDependentTexture(void *userData, Object *UNUS { struct { ID *id; int is_dependent; } *data = userData; - if (*idpoin && GS((*idpoin)->name)==ID_TE) { + if (*idpoin && GS((*idpoin)->name) == ID_TE) { if (data->id == (*idpoin)) data->is_dependent = 1; } @@ -2481,8 +2479,8 @@ static void dag_id_flush_update__isDependentTexture(void *userData, Object *UNUS static void dag_id_flush_update(Scene *sce, ID *id) { - Main *bmain= G.main; - Object *obt, *ob= NULL; + Main *bmain = G.main; + Object *obt, *ob = NULL; short idtype; /* here we flush a few things before actual scene wide flush, mostly @@ -2490,27 +2488,27 @@ static void dag_id_flush_update(Scene *sce, ID *id) /* set flags & pointcache for object */ if (GS(id->name) == ID_OB) { - ob= (Object*)id; + ob = (Object *)id; BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH); if (ob->recalc & OB_RECALC_DATA) { /* all users of this ob->data should be checked */ - id= ob->data; + id = ob->data; /* no point in trying in this cases */ if (id && id->us <= 1) { dag_editors_id_update(bmain, id); - id= NULL; + id = NULL; } } } /* set flags & pointcache for object data */ if (id) { - idtype= GS(id->name); + idtype = GS(id->name); if (ELEM8(idtype, ID_ME, ID_CU, ID_MB, ID_LA, ID_LT, ID_CA, ID_AR, ID_SPK)) { - for (obt=bmain->object.first; obt; obt= obt->id.next) { + for (obt = bmain->object.first; obt; obt = obt->id.next) { if (!(ob && obt == ob) && obt->data == id) { obt->recalc |= OB_RECALC_DATA; lib_id_recalc_data_tag(bmain, &obt->id); @@ -2521,10 +2519,10 @@ static void dag_id_flush_update(Scene *sce, ID *id) /* set flags based on textures - can influence depgraph via modifiers */ if (idtype == ID_TE) { - for (obt=bmain->object.first; obt; obt= obt->id.next) { + for (obt = bmain->object.first; obt; obt = obt->id.next) { struct { ID *id; int is_dependent; } data; - data.id= id; - data.is_dependent= 0; + data.id = id; + data.is_dependent = 0; modifiers_foreachIDLink(obt, dag_id_flush_update__isDependentTexture, &data); if (data.is_dependent) { @@ -2537,11 +2535,11 @@ static void dag_id_flush_update(Scene *sce, ID *id) ParticleSystem *psys = obt->particlesystem.first; MTex **mtexp, *mtex; int a; - for (; psys; psys=psys->next) { + for (; psys; psys = psys->next) { mtexp = psys->part->mtex; - for (a=0; atex == (Tex*)id) { + if (mtex && mtex->tex == (Tex *)id) { obt->recalc |= OB_RECALC_DATA; lib_id_recalc_data_tag(bmain, &obt->id); @@ -2560,10 +2558,10 @@ static void dag_id_flush_update(Scene *sce, ID *id) /* set flags based on ShapeKey */ if (idtype == ID_KE) { - for (obt=bmain->object.first; obt; obt= obt->id.next) { - Key *key= ob_get_key(obt); + for (obt = bmain->object.first; obt; obt = obt->id.next) { + Key *key = ob_get_key(obt); if (!(ob && obt == ob) && ((ID *)key == id)) { - obt->flag |= (OB_RECALC_OB|OB_RECALC_DATA); + obt->flag |= (OB_RECALC_OB | OB_RECALC_DATA); lib_id_recalc_tag(bmain, &obt->id); lib_id_recalc_data_tag(bmain, &obt->id); BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH); @@ -2574,8 +2572,8 @@ static void dag_id_flush_update(Scene *sce, ID *id) /* set flags based on particle settings */ if (idtype == ID_PA) { ParticleSystem *psys; - for (obt=bmain->object.first; obt; obt= obt->id.next) - for (psys=obt->particlesystem.first; psys; psys=psys->next) + for (obt = bmain->object.first; obt; obt = obt->id.next) + for (psys = obt->particlesystem.first; psys; psys = psys->next) if (&psys->part->id == id) BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH); } @@ -2585,12 +2583,12 @@ static void dag_id_flush_update(Scene *sce, ID *id) BKE_tracking_dopesheet_tag_update(&clip->tracking); - for (obt=bmain->object.first; obt; obt= obt->id.next) { + for (obt = bmain->object.first; obt; obt = obt->id.next) { bConstraint *con; - for (con = obt->constraints.first; con; con=con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = obt->constraints.first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); if (ELEM3(cti->type, CONSTRAINT_TYPE_FOLLOWTRACK, CONSTRAINT_TYPE_CAMERASOLVER, - CONSTRAINT_TYPE_OBJECTSOLVER)) + CONSTRAINT_TYPE_OBJECTSOLVER)) { obt->recalc |= OB_RECALC_OB; break; @@ -2601,8 +2599,8 @@ static void dag_id_flush_update(Scene *sce, ID *id) if (sce->nodetree) { bNode *node; - for (node= sce->nodetree->nodes.first; node; node= node->next) { - if (node->id==id) { + for (node = sce->nodetree->nodes.first; node; node = node->next) { + if (node->id == id) { nodeUpdate(sce->nodetree, node); } } @@ -2646,8 +2644,8 @@ void DAG_ids_flush_tagged(Main *bmain) /* we tag based on first ID type character to avoid * looping over all ID's in case there are no tags */ if (id && bmain->id_tag_update[id->name[0]]) { - for (; id; id=id->next) { - if (id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA)) { + for (; id; id = id->next) { + if (id->flag & (LIB_ID_RECALC | LIB_ID_RECALC_DATA)) { dag_id_flush_update(sce, id); do_flush = 1; } @@ -2675,7 +2673,7 @@ void DAG_ids_check_recalc(Main *bmain, Scene *scene, int time) /* we tag based on first ID type character to avoid * looping over all ID's in case there are no tags */ if (id && bmain->id_tag_update[id->name[0]]) { - updated= 1; + updated = 1; break; } } @@ -2698,9 +2696,9 @@ void DAG_ids_clear_recalc(Main *bmain) /* we tag based on first ID type character to avoid * looping over all ID's in case there are no tags */ if (id && bmain->id_tag_update[id->name[0]]) { - for (; id; id=id->next) - if (id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA)) - id->flag &= ~(LIB_ID_RECALC|LIB_ID_RECALC_DATA); + for (; id; id = id->next) + if (id->flag & (LIB_ID_RECALC | LIB_ID_RECALC_DATA)) + id->flag &= ~(LIB_ID_RECALC | LIB_ID_RECALC_DATA); } } @@ -2709,15 +2707,15 @@ void DAG_ids_clear_recalc(Main *bmain) void DAG_id_tag_update(ID *id, short flag) { - Main *bmain= G.main; + Main *bmain = G.main; - if (id==NULL) return; + if (id == NULL) return; /* tag ID for update */ if (flag) { if (flag & OB_RECALC_OB) lib_id_recalc_tag(bmain, id); - if (flag & (OB_RECALC_DATA|PSYS_RECALC)) + if (flag & (OB_RECALC_DATA | PSYS_RECALC)) lib_id_recalc_data_tag(bmain, id); } else @@ -2730,14 +2728,14 @@ void DAG_id_tag_update(ID *id, short flag) if (idtype == ID_OB) { /* only quick tag */ - ob = (Object*)id; + ob = (Object *)id; ob->recalc |= (flag & OB_RECALC_ALL); } else if (idtype == ID_PA) { ParticleSystem *psys; /* this is weak still, should be done delayed as well */ - for (ob=bmain->object.first; ob; ob=ob->id.next) { - for (psys=ob->particlesystem.first; psys; psys=psys->next) { + for (ob = bmain->object.first; ob; ob = ob->id.next) { + for (psys = ob->particlesystem.first; psys; psys = psys->next) { if (&psys->part->id == id) { ob->recalc |= (flag & OB_RECALC_ALL); psys->recalc |= (flag & PSYS_RECALC); @@ -2757,12 +2755,12 @@ void DAG_id_tag_update(ID *id, short flag) void DAG_id_type_tag(struct Main *bmain, short idtype) { - bmain->id_tag_update[((char*)&idtype)[0]] = 1; + bmain->id_tag_update[((char *)&idtype)[0]] = 1; } int DAG_id_type_tagged(Main *bmain, short idtype) { - return bmain->id_tag_update[((char*)&idtype)[0]]; + return bmain->id_tag_update[((char *)&idtype)[0]]; } #if 0 // UNUSED @@ -2772,22 +2770,22 @@ static int parent_check_node(DagNode *node, int curtime) { DagAdjList *itA; - node->lasttime= curtime; + node->lasttime = curtime; - if (node->color==DAG_GRAY) + if (node->color == DAG_GRAY) return DAG_GRAY; - for (itA = node->child; itA; itA= itA->next) { - if (itA->node->type==ID_OB) { + for (itA = node->child; itA; itA = itA->next) { + if (itA->node->type == ID_OB) { - if (itA->node->color==DAG_GRAY) + if (itA->node->color == DAG_GRAY) return DAG_GRAY; /* descend if not done */ - if (itA->node->lasttime!=curtime) { - itA->node->color= parent_check_node(itA->node, curtime); + if (itA->node->lasttime != curtime) { + itA->node->color = parent_check_node(itA->node, curtime); - if (itA->node->color==DAG_GRAY) + if (itA->node->color == DAG_GRAY) return DAG_GRAY; } } @@ -2802,7 +2800,7 @@ static int parent_check_node(DagNode *node, int curtime) /* we assume its an armature with pose */ void DAG_pose_sort(Object *ob) { - bPose *pose= ob->pose; + bPose *pose = ob->pose; bPoseChannel *pchan; bConstraint *con; DagNode *node; @@ -2815,12 +2813,12 @@ void DAG_pose_sort(Object *ob) int skip = 0; dag = dag_init(); - ugly_hack_sorry= 0; // no ID structs + ugly_hack_sorry = 0; // no ID structs - rootnode = dag_add_node(dag, NULL); // node->ob becomes NULL + rootnode = dag_add_node(dag, NULL); // node->ob becomes NULL /* we add the hierarchy and the constraints */ - for (pchan = pose->chanbase.first; pchan; pchan= pchan->next) { + for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) { int addtoroot = 1; node = dag_get_node(dag, pchan); @@ -2830,40 +2828,40 @@ void DAG_pose_sort(Object *ob) dag_add_relation(dag, node2, node, 0, "Parent Relation"); addtoroot = 0; } - for (con = pchan->constraints.first; con; con=con->next) { - bConstraintTypeInfo *cti= constraint_get_typeinfo(con); + for (con = pchan->constraints.first; con; con = con->next) { + bConstraintTypeInfo *cti = constraint_get_typeinfo(con); ListBase targets = {NULL, NULL}; bConstraintTarget *ct; if (cti && cti->get_constraint_targets) { cti->get_constraint_targets(con, &targets); - for (ct= targets.first; ct; ct= ct->next) { - if (ct->tar==ob && ct->subtarget[0]) { - bPoseChannel *target= BKE_pose_channel_find_name(ob->pose, ct->subtarget); + for (ct = targets.first; ct; ct = ct->next) { + if (ct->tar == ob && ct->subtarget[0]) { + bPoseChannel *target = BKE_pose_channel_find_name(ob->pose, ct->subtarget); if (target) { - node2= dag_get_node(dag, target); + node2 = dag_get_node(dag, target); dag_add_relation(dag, node2, node, 0, "Pose Constraint"); - if (con->type==CONSTRAINT_TYPE_KINEMATIC) { + if (con->type == CONSTRAINT_TYPE_KINEMATIC) { bKinematicConstraint *data = (bKinematicConstraint *)con->data; bPoseChannel *parchan; - int segcount= 0; + int segcount = 0; /* exclude tip from chain? */ if (!(data->flag & CONSTRAINT_IK_TIP)) - parchan= pchan->parent; + parchan = pchan->parent; else - parchan= pchan; + parchan = pchan; /* Walk to the chain's root */ while (parchan) { - node3= dag_get_node(dag, parchan); + node3 = dag_get_node(dag, parchan); dag_add_relation(dag, node2, node3, 0, "IK Constraint"); segcount++; - if (segcount==data->rootbone || segcount>255) break; // 255 is weak - parchan= parchan->parent; + if (segcount == data->rootbone || segcount > 255) break; // 255 is weak + parchan = parchan->parent; } } } @@ -2874,7 +2872,7 @@ void DAG_pose_sort(Object *ob) cti->flush_constraint_targets(con, &targets, 1); } } - if (addtoroot == 1 ) { + if (addtoroot == 1) { dag_add_relation(dag, rootnode, node, 0, "Root Bone Relation"); } } @@ -2882,12 +2880,12 @@ void DAG_pose_sort(Object *ob) dag_check_cycle(dag); /* now we try to sort... */ - tempbase.first= tempbase.last= NULL; + tempbase.first = tempbase.last = NULL; nqueue = queue_create(DAGQUEUEALLOC); /* tag nodes unchecked */ - for (node = dag->DagNode.first; node; node= node->next) + for (node = dag->DagNode.first; node; node = node->next) node->color = DAG_WHITE; rootnode->color = DAG_GRAY; @@ -2912,7 +2910,7 @@ void DAG_pose_sort(Object *ob) if (!skip) { if (node) { node = pop_queue(nqueue); - if (node->ob == NULL) // we are done + if (node->ob == NULL) // we are done break; node->color = DAG_BLACK; @@ -2925,7 +2923,7 @@ void DAG_pose_sort(Object *ob) /* temporal correction for circular dependencies */ while (pose->chanbase.first) { - pchan= pose->chanbase.first; + pchan = pose->chanbase.first; BLI_remlink(&pose->chanbase, pchan); BLI_addhead(&tempbase, pchan); @@ -2943,7 +2941,7 @@ void DAG_pose_sort(Object *ob) free_forest(dag); MEM_freeN(dag); - ugly_hack_sorry= 1; + ugly_hack_sorry = 1; } /* ************************ DAG DEBUGGING ********************* */ @@ -2951,17 +2949,17 @@ void DAG_pose_sort(Object *ob) void DAG_print_dependencies(Main *bmain, Scene *scene, Object *ob) { /* utility for debugging dependencies */ - dag_print_dependencies= 1; + dag_print_dependencies = 1; if (ob && (ob->mode & OB_MODE_POSE)) { - printf("\nDEPENDENCY RELATIONS for %s\n\n", ob->id.name+2); + printf("\nDEPENDENCY RELATIONS for %s\n\n", ob->id.name + 2); DAG_pose_sort(ob); } else { - printf("\nDEPENDENCY RELATIONS for %s\n\n", scene->id.name+2); + printf("\nDEPENDENCY RELATIONS for %s\n\n", scene->id.name + 2); DAG_scene_sort(bmain, scene); } - dag_print_dependencies= 0; + dag_print_dependencies = 0; } diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c index 04e559388ca..d74a688f121 100644 --- a/source/blender/blenkernel/intern/displist.c +++ b/source/blender/blenkernel/intern/displist.c @@ -81,11 +81,11 @@ void freedisplist(ListBase *lb) { DispList *dl; - dl= lb->first; + dl = lb->first; while (dl) { BLI_remlink(lb, dl); free_disp_elem(dl); - dl= lb->first; + dl = lb->first; } } @@ -93,14 +93,14 @@ DispList *find_displist_create(ListBase *lb, int type) { DispList *dl; - dl= lb->first; + dl = lb->first; while (dl) { - if (dl->type==type) return dl; - dl= dl->next; + if (dl->type == type) return dl; + dl = dl->next; } - dl= MEM_callocN(sizeof(DispList), "find_disp"); - dl->type= type; + dl = MEM_callocN(sizeof(DispList), "find_disp"); + dl->type = type; BLI_addtail(lb, dl); return dl; @@ -110,10 +110,10 @@ DispList *find_displist(ListBase *lb, int type) { DispList *dl; - dl= lb->first; + dl = lb->first; while (dl) { - if (dl->type==type) return dl; - dl= dl->next; + if (dl->type == type) return dl; + dl = dl->next; } return NULL; @@ -122,7 +122,7 @@ DispList *find_displist(ListBase *lb, int type) int displist_has_faces(ListBase *lb) { DispList *dl; - for (dl= lb->first; dl; dl= dl->next) { + for (dl = lb->first; dl; dl = dl->next) { if (ELEM3(dl->type, DL_INDEX3, DL_INDEX4, DL_SURF)) { return 1; } @@ -136,21 +136,21 @@ void copy_displist(ListBase *lbn, ListBase *lb) freedisplist(lbn); - dl= lb->first; + dl = lb->first; while (dl) { - dln= MEM_dupallocN(dl); + dln = MEM_dupallocN(dl); BLI_addtail(lbn, dln); - dln->verts= MEM_dupallocN(dl->verts); - dln->nors= MEM_dupallocN(dl->nors); - dln->index= MEM_dupallocN(dl->index); - dln->col1= MEM_dupallocN(dl->col1); - dln->col2= MEM_dupallocN(dl->col2); + dln->verts = MEM_dupallocN(dl->verts); + dln->nors = MEM_dupallocN(dl->nors); + dln->index = MEM_dupallocN(dl->index); + dln->col1 = MEM_dupallocN(dl->col1); + dln->col2 = MEM_dupallocN(dl->col2); if (dl->bevelSplitFlag) - dln->bevelSplitFlag= MEM_dupallocN(dl->bevelSplitFlag); + dln->bevelSplitFlag = MEM_dupallocN(dl->bevelSplitFlag); - dl= dl->next; + dl = dl->next; } } @@ -163,38 +163,38 @@ void addnormalsDispList(ListBase *lb) int a, b, p1, p2, p3, p4; - dl= lb->first; + dl = lb->first; while (dl) { - if (dl->type==DL_INDEX3) { - if (dl->nors==NULL) { - dl->nors= MEM_callocN(sizeof(float)*3, "dlnors"); - if (dl->verts[2] < 0.0f) dl->nors[2]= -1.0f; - else dl->nors[2]= 1.0f; + if (dl->type == DL_INDEX3) { + if (dl->nors == NULL) { + dl->nors = MEM_callocN(sizeof(float) * 3, "dlnors"); + if (dl->verts[2] < 0.0f) dl->nors[2] = -1.0f; + else dl->nors[2] = 1.0f; } } - else if (dl->type==DL_SURF) { - if (dl->nors==NULL) { - dl->nors= MEM_callocN(sizeof(float)*3*dl->nr*dl->parts, "dlnors"); + else if (dl->type == DL_SURF) { + if (dl->nors == NULL) { + dl->nors = MEM_callocN(sizeof(float) * 3 * dl->nr * dl->parts, "dlnors"); - vdata= dl->verts; - ndata= dl->nors; + vdata = dl->verts; + ndata = dl->nors; - for (a=0; aparts; a++) { + for (a = 0; a < dl->parts; a++) { - if (surfindex_displist(dl, a, &b, &p1, &p2, &p3, &p4)==0) + if (surfindex_displist(dl, a, &b, &p1, &p2, &p3, &p4) == 0) break; - v1= vdata+ 3*p1; - n1= ndata+ 3*p1; - v2= vdata+ 3*p2; - n2= ndata+ 3*p2; - v3= vdata+ 3*p3; - n3= ndata+ 3*p3; - v4= vdata+ 3*p4; - n4= ndata+ 3*p4; + v1 = vdata + 3 * p1; + n1 = ndata + 3 * p1; + v2 = vdata + 3 * p2; + n2 = ndata + 3 * p2; + v3 = vdata + 3 * p3; + n3 = ndata + 3 * p3; + v4 = vdata + 3 * p4; + n4 = ndata + 3 * p4; - for (; bnr; b++) { + for (; b < dl->nr; b++) { normal_quad_v3(nor, v1, v3, v4, v2); @@ -203,21 +203,21 @@ void addnormalsDispList(ListBase *lb) add_v3_v3(n3, nor); add_v3_v3(n4, nor); - v2= v1; v1+= 3; - v4= v3; v3+= 3; - n2= n1; n1+= 3; - n4= n3; n3+= 3; + v2 = v1; v1 += 3; + v4 = v3; v3 += 3; + n2 = n1; n1 += 3; + n4 = n3; n3 += 3; } } - a= dl->parts*dl->nr; - v1= ndata; + a = dl->parts * dl->nr; + v1 = ndata; while (a--) { normalize_v3(v1); - v1+= 3; + v1 += 3; } } } - dl= dl->next; + dl = dl->next; } } @@ -225,52 +225,52 @@ void count_displist(ListBase *lb, int *totvert, int *totface) { DispList *dl; - dl= lb->first; + dl = lb->first; while (dl) { switch (dl->type) { case DL_SURF: - *totvert+= dl->nr*dl->parts; - *totface+= (dl->nr-1)*(dl->parts-1); + *totvert += dl->nr * dl->parts; + *totface += (dl->nr - 1) * (dl->parts - 1); break; case DL_INDEX3: case DL_INDEX4: - *totvert+= dl->nr; - *totface+= dl->parts; + *totvert += dl->nr; + *totface += dl->parts; break; case DL_POLY: case DL_SEGM: - *totvert+= dl->nr*dl->parts; + *totvert += dl->nr * dl->parts; } - dl= dl->next; + dl = dl->next; } } int surfindex_displist(DispList *dl, int a, int *b, int *p1, int *p2, int *p3, int *p4) { - if ((dl->flag & DL_CYCL_V)==0 && a==(dl->parts)-1) { + if ((dl->flag & DL_CYCL_V) == 0 && a == (dl->parts) - 1) { return 0; } if (dl->flag & DL_CYCL_U) { - (*p1)= dl->nr*a; - (*p2)= (*p1)+ dl->nr-1; - (*p3)= (*p1)+ dl->nr; - (*p4)= (*p2)+ dl->nr; - (*b)= 0; + (*p1) = dl->nr * a; + (*p2) = (*p1) + dl->nr - 1; + (*p3) = (*p1) + dl->nr; + (*p4) = (*p2) + dl->nr; + (*b) = 0; } else { - (*p2)= dl->nr*a; - (*p1)= (*p2)+1; - (*p4)= (*p2)+ dl->nr; - (*p3)= (*p1)+ dl->nr; - (*b)= 1; + (*p2) = dl->nr * a; + (*p1) = (*p2) + 1; + (*p4) = (*p2) + dl->nr; + (*p3) = (*p1) + dl->nr; + (*b) = 1; } - if ( (dl->flag & DL_CYCL_V) && a==dl->parts-1) { - (*p3)-= dl->nr*dl->parts; - (*p4)-= dl->nr*dl->parts; + if ( (dl->flag & DL_CYCL_V) && a == dl->parts - 1) { + (*p3) -= dl->nr * dl->parts; + (*p4) -= dl->nr * dl->parts; } return 1; @@ -287,70 +287,70 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i float *data; int a, len, resolu; - nu= nubase->first; + nu = nubase->first; while (nu) { - if (nu->hide==0) { + if (nu->hide == 0) { - if (forRender && cu->resolu_ren!=0) - resolu= cu->resolu_ren; + if (forRender && cu->resolu_ren != 0) + resolu = cu->resolu_ren; else - resolu= nu->resolu; + resolu = nu->resolu; - if (!BKE_nurb_check_valid_u(nu)); + if (!BKE_nurb_check_valid_u(nu)) ; else if (nu->type == CU_BEZIER) { /* count */ - len= 0; - a= nu->pntsu-1; + len = 0; + a = nu->pntsu - 1; if (nu->flagu & CU_NURB_CYCLIC) a++; - prevbezt= nu->bezt; - bezt= prevbezt+1; + prevbezt = nu->bezt; + bezt = prevbezt + 1; while (a--) { - if (a==0 && (nu->flagu & CU_NURB_CYCLIC)) bezt= nu->bezt; + if (a == 0 && (nu->flagu & CU_NURB_CYCLIC)) bezt = nu->bezt; - if (prevbezt->h2==HD_VECT && bezt->h1==HD_VECT) len++; - else len+= resolu; + if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) len++; + else len += resolu; - if (a==0 && (nu->flagu & CU_NURB_CYCLIC)==0) len++; + if (a == 0 && (nu->flagu & CU_NURB_CYCLIC) == 0) len++; - prevbezt= bezt; + prevbezt = bezt; bezt++; } - dl= MEM_callocN(sizeof(DispList), "makeDispListbez"); + dl = MEM_callocN(sizeof(DispList), "makeDispListbez"); /* len+1 because of 'forward_diff_bezier' function */ - dl->verts= MEM_callocN((len+1)*3*sizeof(float), "dlverts"); + dl->verts = MEM_callocN((len + 1) * 3 * sizeof(float), "dlverts"); BLI_addtail(dispbase, dl); - dl->parts= 1; - dl->nr= len; - dl->col= nu->mat_nr; - dl->charidx= nu->charidx; + dl->parts = 1; + dl->nr = len; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; - data= dl->verts; + data = dl->verts; if (nu->flagu & CU_NURB_CYCLIC) { - dl->type= DL_POLY; - a= nu->pntsu; + dl->type = DL_POLY; + a = nu->pntsu; } else { - dl->type= DL_SEGM; - a= nu->pntsu-1; + dl->type = DL_SEGM; + a = nu->pntsu - 1; } - prevbezt= nu->bezt; - bezt= prevbezt+1; + prevbezt = nu->bezt; + bezt = prevbezt + 1; while (a--) { - if (a==0 && dl->type== DL_POLY) bezt= nu->bezt; + if (a == 0 && dl->type == DL_POLY) bezt = nu->bezt; - if (prevbezt->h2==HD_VECT && bezt->h1==HD_VECT) { + if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) { copy_v3_v3(data, prevbezt->vec[1]); - data+= 3; + data += 3; } else { int j; - for (j=0; j<3; j++) { + for (j = 0; j < 3; j++) { BKE_curve_forward_diff_bezier(prevbezt->vec[1][j], prevbezt->vec[2][j], bezt->vec[0][j], @@ -358,58 +358,58 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i data + j, resolu, 3 * sizeof(float)); } - data+= 3*resolu; + data += 3 * resolu; } - if (a==0 && dl->type==DL_SEGM) { + if (a == 0 && dl->type == DL_SEGM) { copy_v3_v3(data, bezt->vec[1]); } - prevbezt= bezt; + prevbezt = bezt; bezt++; } } else if (nu->type == CU_NURBS) { - len= (resolu*SEGMENTSU(nu)); + len = (resolu * SEGMENTSU(nu)); - dl= MEM_callocN(sizeof(DispList), "makeDispListsurf"); - dl->verts= MEM_callocN(len*3*sizeof(float), "dlverts"); + dl = MEM_callocN(sizeof(DispList), "makeDispListsurf"); + dl->verts = MEM_callocN(len * 3 * sizeof(float), "dlverts"); BLI_addtail(dispbase, dl); - dl->parts= 1; + dl->parts = 1; - dl->nr= len; - dl->col= nu->mat_nr; + dl->nr = len; + dl->col = nu->mat_nr; dl->charidx = nu->charidx; - data= dl->verts; - if (nu->flagu & CU_NURB_CYCLIC) dl->type= DL_POLY; - else dl->type= DL_SEGM; - BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, 3*sizeof(float)); + data = dl->verts; + if (nu->flagu & CU_NURB_CYCLIC) dl->type = DL_POLY; + else dl->type = DL_SEGM; + BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, 3 * sizeof(float)); } else if (nu->type == CU_POLY) { - len= nu->pntsu; - dl= MEM_callocN(sizeof(DispList), "makeDispListpoly"); - dl->verts= MEM_callocN(len*3*sizeof(float), "dlverts"); + len = nu->pntsu; + dl = MEM_callocN(sizeof(DispList), "makeDispListpoly"); + dl->verts = MEM_callocN(len * 3 * sizeof(float), "dlverts"); BLI_addtail(dispbase, dl); - dl->parts= 1; - dl->nr= len; - dl->col= nu->mat_nr; + dl->parts = 1; + dl->nr = len; + dl->col = nu->mat_nr; dl->charidx = nu->charidx; - data= dl->verts; - if (nu->flagu & CU_NURB_CYCLIC) dl->type= DL_POLY; - else dl->type= DL_SEGM; + data = dl->verts; + if (nu->flagu & CU_NURB_CYCLIC) dl->type = DL_POLY; + else dl->type = DL_SEGM; - a= len; - bp= nu->bp; + a = len; + bp = nu->bp; while (a--) { copy_v3_v3(data, bp->vec); bp++; - data+= 3; + data += 3; } } } - nu= nu->next; + nu = nu->next; } } @@ -419,99 +419,99 @@ void filldisplist(ListBase *dispbase, ListBase *to, int flipnormal) ScanFillContext sf_ctx; ScanFillVert *eve, *v1, *vlast; ScanFillFace *efa; - DispList *dlnew=NULL, *dl; + DispList *dlnew = NULL, *dl; float *f1; - int colnr=0, charidx=0, cont=1, tot, a, *index, nextcol= 0; + int colnr = 0, charidx = 0, cont = 1, tot, a, *index, nextcol = 0; intptr_t totvert; - if (dispbase==NULL) return; - if (dispbase->first==NULL) return; + if (dispbase == NULL) return; + if (dispbase->first == NULL) return; while (cont) { - cont= 0; - totvert= 0; - nextcol= 0; + cont = 0; + totvert = 0; + nextcol = 0; BLI_scanfill_begin(&sf_ctx); - dl= dispbase->first; + dl = dispbase->first; while (dl) { - if (dl->type==DL_POLY) { - if (charidxcharidx) cont= 1; - else if (charidx==dl->charidx) { /* character with needed index */ - if (colnr==dl->col) { + if (dl->type == DL_POLY) { + if (charidx < dl->charidx) cont = 1; + else if (charidx == dl->charidx) { /* character with needed index */ + if (colnr == dl->col) { /* make editverts and edges */ - f1= dl->verts; - a= dl->nr; - eve= v1= NULL; + f1 = dl->verts; + a = dl->nr; + eve = v1 = NULL; while (a--) { - vlast= eve; + vlast = eve; eve = BLI_scanfill_vert_add(&sf_ctx, f1); totvert++; - if (vlast==NULL) v1= eve; + if (vlast == NULL) v1 = eve; else { BLI_scanfill_edge_add(&sf_ctx, vlast, eve); } - f1+=3; + f1 += 3; } - if (eve!=NULL && v1!=NULL) { + if (eve != NULL && v1 != NULL) { BLI_scanfill_edge_add(&sf_ctx, eve, v1); } } - else if (colnrcol) { + else if (colnr < dl->col) { /* got poly with next material at current char */ - cont= 1; - nextcol= 1; + cont = 1; + nextcol = 1; } } } - dl= dl->next; + dl = dl->next; } - if (totvert && (tot= BLI_scanfill_calc(&sf_ctx, FALSE))) { // XXX (obedit && obedit->actcol)?(obedit->actcol-1):0)) { + if (totvert && (tot = BLI_scanfill_calc(&sf_ctx, FALSE))) { // XXX (obedit && obedit->actcol)?(obedit->actcol-1):0)) { if (tot) { - dlnew= MEM_callocN(sizeof(DispList), "filldisplist"); - dlnew->type= DL_INDEX3; - dlnew->col= colnr; - dlnew->nr= totvert; - dlnew->parts= tot; - - dlnew->index= MEM_mallocN(tot*3*sizeof(int), "dlindex"); - dlnew->verts= MEM_mallocN(totvert*3*sizeof(float), "dlverts"); + dlnew = MEM_callocN(sizeof(DispList), "filldisplist"); + dlnew->type = DL_INDEX3; + dlnew->col = colnr; + dlnew->nr = totvert; + dlnew->parts = tot; + + dlnew->index = MEM_mallocN(tot * 3 * sizeof(int), "dlindex"); + dlnew->verts = MEM_mallocN(totvert * 3 * sizeof(float), "dlverts"); /* vert data */ - f1= dlnew->verts; - totvert= 0; - eve= sf_ctx.fillvertbase.first; + f1 = dlnew->verts; + totvert = 0; + eve = sf_ctx.fillvertbase.first; while (eve) { copy_v3_v3(f1, eve->co); - f1+= 3; + f1 += 3; /* index number */ eve->tmp.l = totvert; totvert++; - eve= eve->next; + eve = eve->next; } /* index data */ efa = sf_ctx.fillfacebase.first; - index= dlnew->index; + index = dlnew->index; while (efa) { - index[0]= (intptr_t)efa->v1->tmp.l; - index[1]= (intptr_t)efa->v2->tmp.l; - index[2]= (intptr_t)efa->v3->tmp.l; + index[0] = (intptr_t)efa->v1->tmp.l; + index[1] = (intptr_t)efa->v2->tmp.l; + index[2] = (intptr_t)efa->v3->tmp.l; if (flipnormal) SWAP(int, index[0], index[2]); - index+= 3; - efa= efa->next; + index += 3; + efa = efa->next; } } @@ -527,7 +527,7 @@ void filldisplist(ListBase *dispbase, ListBase *to, int flipnormal) else { /* switch to next char and start filling from first material */ charidx++; - colnr= 0; + colnr = 0; } } @@ -542,55 +542,55 @@ static void bevels_to_filledpoly(Curve *cu, ListBase *dispbase) float *fp, *fp1; int a, dpoly; - front.first= front.last= back.first= back.last= NULL; + front.first = front.last = back.first = back.last = NULL; - dl= dispbase->first; + dl = dispbase->first; while (dl) { - if (dl->type==DL_SURF) { - if ( (dl->flag & DL_CYCL_V) && (dl->flag & DL_CYCL_U)==0 ) { + if (dl->type == DL_SURF) { + if ( (dl->flag & DL_CYCL_V) && (dl->flag & DL_CYCL_U) == 0) { if ( (cu->flag & CU_BACK) && (dl->flag & DL_BACK_CURVE) ) { - dlnew= MEM_callocN(sizeof(DispList), "filldisp"); + dlnew = MEM_callocN(sizeof(DispList), "filldisp"); BLI_addtail(&front, dlnew); - dlnew->verts= fp1= MEM_mallocN(sizeof(float)*3*dl->parts, "filldisp1"); - dlnew->nr= dl->parts; - dlnew->parts= 1; - dlnew->type= DL_POLY; - dlnew->col= dl->col; + dlnew->verts = fp1 = MEM_mallocN(sizeof(float) * 3 * dl->parts, "filldisp1"); + dlnew->nr = dl->parts; + dlnew->parts = 1; + dlnew->type = DL_POLY; + dlnew->col = dl->col; dlnew->charidx = dl->charidx; - fp= dl->verts; - dpoly= 3*dl->nr; + fp = dl->verts; + dpoly = 3 * dl->nr; - a= dl->parts; + a = dl->parts; while (a--) { copy_v3_v3(fp1, fp); - fp1+= 3; - fp+= dpoly; + fp1 += 3; + fp += dpoly; } } if ( (cu->flag & CU_FRONT) && (dl->flag & DL_FRONT_CURVE) ) { - dlnew= MEM_callocN(sizeof(DispList), "filldisp"); + dlnew = MEM_callocN(sizeof(DispList), "filldisp"); BLI_addtail(&back, dlnew); - dlnew->verts= fp1= MEM_mallocN(sizeof(float)*3*dl->parts, "filldisp1"); - dlnew->nr= dl->parts; - dlnew->parts= 1; - dlnew->type= DL_POLY; - dlnew->col= dl->col; - dlnew->charidx= dl->charidx; + dlnew->verts = fp1 = MEM_mallocN(sizeof(float) * 3 * dl->parts, "filldisp1"); + dlnew->nr = dl->parts; + dlnew->parts = 1; + dlnew->type = DL_POLY; + dlnew->col = dl->col; + dlnew->charidx = dl->charidx; - fp= dl->verts+3*(dl->nr-1); - dpoly= 3*dl->nr; + fp = dl->verts + 3 * (dl->nr - 1); + dpoly = 3 * dl->nr; - a= dl->parts; + a = dl->parts; while (a--) { copy_v3_v3(fp1, fp); - fp1+= 3; - fp+= dpoly; + fp1 += 3; + fp += dpoly; } } } } - dl= dl->next; + dl = dl->next; } filldisplist(&front, dispbase, 1); @@ -607,7 +607,7 @@ static void curve_to_filledpoly(Curve *cu, ListBase *UNUSED(nurb), ListBase *dis { if (cu->flag & CU_3D) return; - if (dispbase->first && ((DispList*) dispbase->first)->type==DL_SURF) { + if (dispbase->first && ((DispList *) dispbase->first)->type == DL_SURF) { bevels_to_filledpoly(cu, dispbase); } else { @@ -624,37 +624,37 @@ float calc_taper(Scene *scene, Object *taperobj, int cur, int tot) { DispList *dl; - if (taperobj==NULL || taperobj->type!=OB_CURVE) return 1.0; + if (taperobj == NULL || taperobj->type != OB_CURVE) return 1.0; - dl= taperobj->disp.first; - if (dl==NULL) { + dl = taperobj->disp.first; + if (dl == NULL) { makeDispListCurveTypes(scene, taperobj, 0); - dl= taperobj->disp.first; + dl = taperobj->disp.first; } if (dl) { - float fac= ((float)cur)/(float)(tot-1); + float fac = ((float)cur) / (float)(tot - 1); float minx, dx, *fp; int a; /* horizontal size */ - minx= dl->verts[0]; - dx= dl->verts[3*(dl->nr-1)] - minx; + minx = dl->verts[0]; + dx = dl->verts[3 * (dl->nr - 1)] - minx; if (dx > 0.0f) { - fp= dl->verts; - for (a=0; anr; a++, fp+=3) { - if ( (fp[0]-minx)/dx >= fac) { + fp = dl->verts; + for (a = 0; a < dl->nr; a++, fp += 3) { + if ( (fp[0] - minx) / dx >= fac) { /* interpolate with prev */ - if (a>0) { - float fac1= (fp[-3]-minx)/dx; - float fac2= (fp[0]-minx)/dx; - if (fac1!=fac2) - return fp[1]*(fac1-fac)/(fac1-fac2) + fp[-2]*(fac-fac2)/(fac1-fac2); + if (a > 0) { + float fac1 = (fp[-3] - minx) / dx; + float fac2 = (fp[0] - minx) / dx; + if (fac1 != fac2) + return fp[1] * (fac1 - fac) / (fac1 - fac2) + fp[-2] * (fac - fac2) / (fac1 - fac2); } return fp[1]; } } - return fp[-2]; // last y coord + return fp[-2]; // last y coord } } @@ -663,7 +663,7 @@ float calc_taper(Scene *scene, Object *taperobj, int cur, int tot) void makeDispListMBall(Scene *scene, Object *ob) { - if (!ob || ob->type!=OB_MBALL) return; + if (!ob || ob->type != OB_MBALL) return; // XXX: mball stuff uses plenty of global variables // while this is unchanged updating during render is unsafe @@ -671,8 +671,8 @@ void makeDispListMBall(Scene *scene, Object *ob) freedisplist(&(ob->disp)); - if (ob->type==OB_MBALL) { - if (ob==BKE_metaball_basis_find(scene, ob)) { + if (ob->type == OB_MBALL) { + if (ob == BKE_metaball_basis_find(scene, ob)) { BKE_metaball_polygonize(scene, ob, &ob->disp); BKE_metaball_texspace_calc(ob); @@ -703,7 +703,7 @@ static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob, int fo if (editmode) required_mode |= eModifierMode_Editmode; pretessellatePoint = NULL; - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); if (!modifier_isEnabled(scene, md, required_mode)) continue; @@ -717,7 +717,7 @@ static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob, int fo * for incformation button in modifier's header */ md->mode |= eModifierMode_ApplyOnSpline; } - else if (md->mode&eModifierMode_ApplyOnSpline) { + else if (md->mode & eModifierMode_ApplyOnSpline) { pretessellatePoint = md; } } @@ -729,13 +729,13 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl { ModifierData *md = modifiers_getVirtualModifierList(ob); ModifierData *pretessellatePoint; - Curve *cu= ob->data; - ListBase *nurb= BKE_curve_nurbs_get(cu); + Curve *cu = ob->data; + ListBase *nurb = BKE_curve_nurbs_get(cu); int numVerts = 0; int editmode = (!forRender && cu->editnurb); float (*originalVerts)[3] = NULL; float (*deformedVerts)[3] = NULL; - float *keyVerts= NULL; + float *keyVerts = NULL; int required_mode; if (forRender) required_mode = eModifierMode_Render; @@ -745,29 +745,29 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl if (editmode) required_mode |= eModifierMode_Editmode; - if (cu->editnurb==NULL) { - keyVerts= do_ob_key(scene, ob); + if (cu->editnurb == NULL) { + keyVerts = do_ob_key(scene, ob); if (keyVerts) { /* split coords from key data, the latter also includes * tilts, which is passed through in the modifier stack. * this is also the reason curves do not use a virtual * shape key modifier yet. */ - deformedVerts= BKE_curve_keyVertexCos_get(cu, nurb, keyVerts); - originalVerts= MEM_dupallocN(deformedVerts); + deformedVerts = BKE_curve_keyVertexCos_get(cu, nurb, keyVerts); + originalVerts = MEM_dupallocN(deformedVerts); numVerts = BKE_nurbList_verts_count_without_handles(nurb); } } if (pretessellatePoint) { - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - md->scene= scene; + md->scene = scene; if ((md->mode & required_mode) != required_mode) continue; if (mti->isDisabled && mti->isDisabled(md, forRender)) continue; - if (mti->type!=eModifierTypeType_OnlyDeform) continue; + if (mti->type != eModifierTypeType_OnlyDeform) continue; if (!deformedVerts) { deformedVerts = BKE_curve_vertexCos_get(cu, nurb, &numVerts); @@ -776,7 +776,7 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl mti->deformVerts(md, ob, NULL, deformedVerts, numVerts, forRender, editmode); - if (md==pretessellatePoint) + if (md == pretessellatePoint) break; } } @@ -794,22 +794,22 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl *numVerts_r = numVerts; } -static float (*displist_get_allverts (ListBase *dispbase, int *totvert))[3] +static float (*displist_get_allverts(ListBase * dispbase, int *totvert))[3] { DispList *dl; float (*allverts)[3], *fp; - *totvert= 0; + *totvert = 0; - for (dl=dispbase->first; dl; dl=dl->next) - *totvert+= (dl->type==DL_INDEX3)?dl->nr:dl->parts*dl->nr; + for (dl = dispbase->first; dl; dl = dl->next) + *totvert += (dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr; - allverts= MEM_mallocN((*totvert)*sizeof(float)*3, "displist_get_allverts allverts"); - fp= (float*)allverts; - for (dl=dispbase->first; dl; dl=dl->next) { - int offs= 3 * ((dl->type==DL_INDEX3)?dl->nr:dl->parts*dl->nr); + allverts = MEM_mallocN((*totvert) * sizeof(float) * 3, "displist_get_allverts allverts"); + fp = (float *)allverts; + for (dl = dispbase->first; dl; dl = dl->next) { + int offs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr); memcpy(fp, dl->verts, sizeof(float) * offs); - fp+= offs; + fp += offs; } return allverts; @@ -820,24 +820,24 @@ static void displist_apply_allverts(ListBase *dispbase, float (*allverts)[3]) DispList *dl; float *fp; - fp= (float*)allverts; - for (dl=dispbase->first; dl; dl=dl->next) { - int offs= 3 * ((dl->type==DL_INDEX3)?dl->nr:dl->parts*dl->nr); + fp = (float *)allverts; + for (dl = dispbase->first; dl; dl = dl->next) { + int offs = 3 * ((dl->type == DL_INDEX3) ? dl->nr : dl->parts * dl->nr); memcpy(dl->verts, fp, sizeof(float) * offs); - fp+= offs; + fp += offs; } } static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispbase, - DerivedMesh **derivedFinal, int forRender, float (*originalVerts)[3], float (*deformedVerts)[3]) + DerivedMesh **derivedFinal, int forRender, float (*originalVerts)[3], float (*deformedVerts)[3]) { ModifierData *md = modifiers_getVirtualModifierList(ob); ModifierData *pretessellatePoint; - Curve *cu= ob->data; - ListBase *nurb= BKE_curve_nurbs_get(cu); + Curve *cu = ob->data; + ListBase *nurb = BKE_curve_nurbs_get(cu); int required_mode = 0, totvert = 0; int editmode = (!forRender && cu->editnurb); - DerivedMesh *dm= NULL, *ndm; + DerivedMesh *dm = NULL, *ndm; float (*vertCos)[3] = NULL; int useCache = !forRender; @@ -853,19 +853,19 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba } if (derivedFinal && *derivedFinal) { - (*derivedFinal)->release (*derivedFinal); + (*derivedFinal)->release(*derivedFinal); } - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - md->scene= scene; + md->scene = scene; if ((md->mode & required_mode) != required_mode) continue; if (mti->isDisabled && mti->isDisabled(md, forRender)) continue; if (mti->type == eModifierTypeType_OnlyDeform || - (mti->type == eModifierTypeType_DeformOrConstruct && !dm)) { + (mti->type == eModifierTypeType_DeformOrConstruct && !dm)) { if (dm) { if (!vertCos) { totvert = dm->getNumVerts(dm); @@ -877,7 +877,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba } else { if (!vertCos) { - vertCos= displist_get_allverts(dispbase, &totvert); + vertCos = displist_get_allverts(dispbase, &totvert); } mti->deformVerts(md, ob, NULL, vertCos, totvert, forRender, editmode); @@ -910,7 +910,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba curve_to_filledpoly(cu, nurb, dispbase); } - dm= CDDM_from_curve_customDB(ob, dispbase); + dm = CDDM_from_curve_customDB(ob, dispbase); CDDM_calc_normals_mapping(dm); } @@ -918,7 +918,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba if (vertCos) { /* Vertex coordinates were applied to necessary data, could free it */ MEM_freeN(vertCos); - vertCos= NULL; + vertCos = NULL; } ndm = mti->applyModifier(md, ob, dm, forRender, useCache); @@ -927,7 +927,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba /* Modifier returned a new derived mesh */ if (dm && dm != ndm) /* Modifier */ - dm->release (dm); + dm->release(dm); dm = ndm; } } @@ -946,12 +946,12 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba else { displist_apply_allverts(dispbase, vertCos); MEM_freeN(vertCos); - vertCos= NULL; + vertCos = NULL; } } if (derivedFinal) { - if (dm) DM_ensure_tessface(dm); /* needed for drawing */ + if (dm) DM_ensure_tessface(dm); /* needed for drawing */ (*derivedFinal) = dm; } @@ -967,25 +967,25 @@ static void displist_surf_indices(DispList *dl) int a, b, p1, p2, p3, p4; int *index; - dl->totindex= 0; + dl->totindex = 0; - index=dl->index= MEM_mallocN(4*sizeof(int)*(dl->parts+1)*(dl->nr+1), "index array nurbs"); + index = dl->index = MEM_mallocN(4 * sizeof(int) * (dl->parts + 1) * (dl->nr + 1), "index array nurbs"); - for (a=0; aparts; a++) { + for (a = 0; a < dl->parts; a++) { - if (surfindex_displist(dl, a, &b, &p1, &p2, &p3, &p4)==0) + if (surfindex_displist(dl, a, &b, &p1, &p2, &p3, &p4) == 0) break; - for (; bnr; b++, index+=4) { - index[0]= p1; - index[1]= p2; - index[2]= p4; - index[3]= p3; + for (; b < dl->nr; b++, index += 4) { + index[0] = p1; + index[1] = p2; + index[2] = p4; + index[3] = p3; dl->totindex++; - p2= p1; p1++; - p4= p3; p3++; + p2 = p1; p1++; + p4 = p3; p3++; } } @@ -995,11 +995,11 @@ static void displist_surf_indices(DispList *dl) static DerivedMesh *create_orco_dm(Scene *scene, Object *ob) { DerivedMesh *dm; - ListBase disp= {NULL, NULL}; + ListBase disp = {NULL, NULL}; /* OrcoDM should be created from underformed disp lists */ makeDispListCurveTypes_forOrco(scene, ob, &disp); - dm= CDDM_from_curve_customDB(ob, &disp); + dm = CDDM_from_curve_customDB(ob, &disp); freedisplist(&disp); @@ -1010,12 +1010,12 @@ static void add_orco_dm(Scene *scene, Object *ob, DerivedMesh *dm, DerivedMesh * { float (*orco)[3], (*layerorco)[3]; int totvert, a; - Curve *cu= ob->data; + Curve *cu = ob->data; - totvert= dm->getNumVerts(dm); + totvert = dm->getNumVerts(dm); if (orcodm) { - orco= MEM_callocN(sizeof(float)*3*totvert, "dm orco"); + orco = MEM_callocN(sizeof(float) * 3 * totvert, "dm orco"); if (orcodm->getNumVerts(orcodm) == totvert) orcodm->getVertCos(orcodm, orco); @@ -1023,18 +1023,18 @@ static void add_orco_dm(Scene *scene, Object *ob, DerivedMesh *dm, DerivedMesh * dm->getVertCos(dm, orco); } else { - orco= (float(*)[3])BKE_curve_make_orco(scene, ob); + orco = (float(*)[3])BKE_curve_make_orco(scene, ob); } - for (a=0; aloc[0])/cu->size[0]; - co[1] = (co[1]-cu->loc[1])/cu->size[1]; - co[2] = (co[2]-cu->loc[2])/cu->size[2]; + co[0] = (co[0] - cu->loc[0]) / cu->size[0]; + co[1] = (co[1] - cu->loc[1]) / cu->size[1]; + co[2] = (co[2] - cu->loc[2]) / cu->size[2]; } if ((layerorco = DM_get_vert_data_layer(dm, CD_ORCO))) { - memcpy(layerorco, orco, sizeof(float)*totvert); + memcpy(layerorco, orco, sizeof(float) * totvert); MEM_freeN(orco); } else @@ -1048,10 +1048,10 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina ModifierData *md = modifiers_getVirtualModifierList(ob); ModifierData *pretessellatePoint; - Curve *cu= ob->data; + Curve *cu = ob->data; int required_mode; int editmode = (!forRender && cu->editnurb); - DerivedMesh *ndm, *orcodm= NULL; + DerivedMesh *ndm, *orcodm = NULL; if (forRender) required_mode = eModifierMode_Render; else required_mode = eModifierMode_Realtime; @@ -1064,17 +1064,17 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina md = pretessellatePoint->next; } - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - md->scene= scene; + md->scene = scene; if ((md->mode & required_mode) != required_mode) continue; if (mti->isDisabled && mti->isDisabled(md, forRender)) continue; - if (mti->type!=eModifierTypeType_Constructive) continue; + if (mti->type != eModifierTypeType_Constructive) continue; if (!orcodm) - orcodm= create_orco_dm(scene, ob); + orcodm = create_orco_dm(scene, ob); ndm = mti->applyModifier(md, ob, orcodm, forRender, 0); @@ -1095,7 +1095,7 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina } void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase, - DerivedMesh **derivedFinal, int forRender, int forOrco) + DerivedMesh **derivedFinal, int forRender, int forOrco) { ListBase *nubase; Nurb *nu; @@ -1108,65 +1108,65 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase, float (*deformedVerts)[3]; if (!forRender && cu->editnurb) - nubase= BKE_curve_editNurbs_get(cu); + nubase = BKE_curve_editNurbs_get(cu); else - nubase= &cu->nurb; + nubase = &cu->nurb; if (!forOrco) curve_calc_modifiers_pre(scene, ob, forRender, &originalVerts, &deformedVerts, &numVerts); - for (nu=nubase->first; nu; nu=nu->next) { - if (forRender || nu->hide==0) { - int resolu= nu->resolu, resolv= nu->resolv; + for (nu = nubase->first; nu; nu = nu->next) { + if (forRender || nu->hide == 0) { + int resolu = nu->resolu, resolv = nu->resolv; if (forRender) { - if (cu->resolu_ren) resolu= cu->resolu_ren; - if (cu->resolv_ren) resolv= cu->resolv_ren; + if (cu->resolu_ren) resolu = cu->resolu_ren; + if (cu->resolv_ren) resolv = cu->resolv_ren; } - if (nu->pntsv==1) { - len= SEGMENTSU(nu)*resolu; + if (nu->pntsv == 1) { + len = SEGMENTSU(nu) * resolu; - dl= MEM_callocN(sizeof(DispList), "makeDispListsurf"); - dl->verts= MEM_callocN(len*3*sizeof(float), "dlverts"); + dl = MEM_callocN(sizeof(DispList), "makeDispListsurf"); + dl->verts = MEM_callocN(len * 3 * sizeof(float), "dlverts"); BLI_addtail(dispbase, dl); - dl->parts= 1; - dl->nr= len; - dl->col= nu->mat_nr; - dl->charidx= nu->charidx; + dl->parts = 1; + dl->nr = len; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; /* dl->rt will be used as flag for render face and */ /* CU_2D conflicts with R_NOPUNOFLIP */ - dl->rt= nu->flag & ~CU_2D; + dl->rt = nu->flag & ~CU_2D; - data= dl->verts; - if (nu->flagu & CU_NURB_CYCLIC) dl->type= DL_POLY; - else dl->type= DL_SEGM; + data = dl->verts; + if (nu->flagu & CU_NURB_CYCLIC) dl->type = DL_POLY; + else dl->type = DL_SEGM; - BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, 3*sizeof(float)); + BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, 3 * sizeof(float)); } else { - len= (nu->pntsu*resolu) * (nu->pntsv*resolv); + len = (nu->pntsu * resolu) * (nu->pntsv * resolv); - dl= MEM_callocN(sizeof(DispList), "makeDispListsurf"); - dl->verts= MEM_callocN(len*3*sizeof(float), "dlverts"); + dl = MEM_callocN(sizeof(DispList), "makeDispListsurf"); + dl->verts = MEM_callocN(len * 3 * sizeof(float), "dlverts"); BLI_addtail(dispbase, dl); - dl->col= nu->mat_nr; - dl->charidx= nu->charidx; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; /* dl->rt will be used as flag for render face and */ /* CU_2D conflicts with R_NOPUNOFLIP */ - dl->rt= nu->flag & ~CU_2D; + dl->rt = nu->flag & ~CU_2D; - data= dl->verts; - dl->type= DL_SURF; + data = dl->verts; + dl->type = DL_SURF; - dl->parts= (nu->pntsu*resolu); /* in reverse, because makeNurbfaces works that way */ - dl->nr= (nu->pntsv*resolv); - if (nu->flagv & CU_NURB_CYCLIC) dl->flag|= DL_CYCL_U; /* reverse too! */ - if (nu->flagu & CU_NURB_CYCLIC) dl->flag|= DL_CYCL_V; + dl->parts = (nu->pntsu * resolu); /* in reverse, because makeNurbfaces works that way */ + dl->nr = (nu->pntsv * resolv); + if (nu->flagv & CU_NURB_CYCLIC) dl->flag |= DL_CYCL_U; /* reverse too! */ + if (nu->flagu & CU_NURB_CYCLIC) dl->flag |= DL_CYCL_V; BKE_nurb_makeFaces(nu, data, 0, resolu, resolv); @@ -1187,7 +1187,7 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase, if (!forOrco) curve_calc_modifiers_post(scene, ob, dispbase, derivedFinal, - forRender, originalVerts, deformedVerts); + forRender, originalVerts, deformedVerts); } static void rotateBevelPiece(Curve *cu, BevPoint *bevp, DispList *dlb, float widfac, float fac, float **data_r) @@ -1196,24 +1196,24 @@ static void rotateBevelPiece(Curve *cu, BevPoint *bevp, DispList *dlb, float wid int b; fp = dlb->verts; - for (b = 0; bnr; b++, fp += 3, data += 3) { + for (b = 0; b < dlb->nr; b++, fp += 3, data += 3) { if (cu->flag & CU_3D) { float vec[3]; - vec[0] = fp[1]+widfac; + vec[0] = fp[1] + widfac; vec[1] = fp[2]; - vec[2 ]= 0.0; + vec[2] = 0.0; mul_qt_v3(bevp->quat, vec); - data[0] = bevp->vec[0] + fac*vec[0]; - data[1] = bevp->vec[1] + fac*vec[1]; - data[2] = bevp->vec[2] + fac*vec[2]; + data[0] = bevp->vec[0] + fac * vec[0]; + data[1] = bevp->vec[1] + fac * vec[1]; + data[2] = bevp->vec[2] + fac * vec[2]; } else { - data[0] = bevp->vec[0] + fac*(widfac+fp[1])*bevp->sina; - data[1] = bevp->vec[1] + fac*(widfac+fp[1])*bevp->cosa; - data[2] = bevp->vec[2] + fac*fp[2]; + data[0] = bevp->vec[0] + fac * (widfac + fp[1]) * bevp->sina; + data[1] = bevp->vec[1] + fac * (widfac + fp[1]) * bevp->cosa; + data[2] = bevp->vec[2] + fac * fp[2]; } } @@ -1226,19 +1226,19 @@ static void fillBevelCap(Nurb *nu, DispList *dlb, float *prev_fp, ListBase *disp float *data; int b; - dl= MEM_callocN(sizeof(DispList), "makeDispListbev2"); - dl->verts= data= MEM_callocN(3*sizeof(float)*dlb->nr, "dlverts"); + dl = MEM_callocN(sizeof(DispList), "makeDispListbev2"); + dl->verts = data = MEM_callocN(3 * sizeof(float) * dlb->nr, "dlverts"); - dl->type= DL_POLY; + dl->type = DL_POLY; - dl->parts= 1; - dl->nr= dlb->nr; - dl->col= nu->mat_nr; - dl->charidx= nu->charidx; + dl->parts = 1; + dl->nr = dlb->nr; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; /* dl->rt will be used as flag for render face and */ /* CU_2D conflicts with R_NOPUNOFLIP */ - dl->rt= nu->flag & ~CU_2D; + dl->rt = nu->flag & ~CU_2D; for (b = 0; b < dlb->nr; b++, prev_fp += 3, data += 3) copy_v3_v3(data, prev_fp); @@ -1247,14 +1247,14 @@ static void fillBevelCap(Nurb *nu, DispList *dlb, float *prev_fp, ListBase *disp } static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispbase, - DerivedMesh **derivedFinal, int forRender, int forOrco) + DerivedMesh **derivedFinal, int forRender, int forOrco) { Curve *cu = ob->data; /* we do allow duplis... this is only displist on curve level */ if (!ELEM3(ob->type, OB_SURF, OB_CURVE, OB_FONT)) return; - if (ob->type==OB_SURF) { + if (ob->type == OB_SURF) { makeDispListSurf(scene, ob, dispbase, derivedFinal, forRender, forOrco); } else if (ELEM(ob->type, OB_CURVE, OB_FONT)) { @@ -1264,14 +1264,14 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba float (*deformedVerts)[3]; int numVerts; - nubase= BKE_curve_nurbs_get(cu); + nubase = BKE_curve_nurbs_get(cu); BLI_freelistN(&(cu->bev)); if (cu->path) free_path(cu->path); - cu->path= NULL; + cu->path = NULL; - if (ob->type==OB_FONT) BKE_vfont_to_curve(G.main, scene, ob, 0); + if (ob->type == OB_FONT) BKE_vfont_to_curve(G.main, scene, ob, 0); if (!forOrco) curve_calc_modifiers_pre(scene, ob, forRender, &originalVerts, &deformedVerts, &numVerts); @@ -1281,15 +1281,15 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba BKE_curve_bevel_make(scene, ob, &dlbev, forRender); /* no bevel or extrude, and no width correction? */ - if (!dlbev.first && cu->width==1.0f) { + if (!dlbev.first && cu->width == 1.0f) { curve_to_displist(cu, nubase, dispbase, forRender); } else { - float widfac= cu->width - 1.0f; - BevList *bl= cu->bev.first; - Nurb *nu= nubase->first; + float widfac = cu->width - 1.0f; + BevList *bl = cu->bev.first; + Nurb *nu = nubase->first; - for (; bl && nu; bl=bl->next, nu=nu->next) { + for (; bl && nu; bl = bl->next, nu = nu->next) { DispList *dl; float *data; BevPoint *bevp; @@ -1298,34 +1298,34 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba if (bl->nr) { /* blank bevel lists can happen */ /* exception handling; curve without bevel or extrude, with width correction */ - if (dlbev.first==NULL) { - dl= MEM_callocN(sizeof(DispList), "makeDispListbev"); - dl->verts= MEM_callocN(3*sizeof(float)*bl->nr, "dlverts"); + if (dlbev.first == NULL) { + dl = MEM_callocN(sizeof(DispList), "makeDispListbev"); + dl->verts = MEM_callocN(3 * sizeof(float) * bl->nr, "dlverts"); BLI_addtail(dispbase, dl); - if (bl->poly!= -1) dl->type= DL_POLY; - else dl->type= DL_SEGM; + if (bl->poly != -1) dl->type = DL_POLY; + else dl->type = DL_SEGM; - if (dl->type==DL_SEGM) dl->flag = (DL_FRONT_CURVE|DL_BACK_CURVE); + if (dl->type == DL_SEGM) dl->flag = (DL_FRONT_CURVE | DL_BACK_CURVE); - dl->parts= 1; - dl->nr= bl->nr; - dl->col= nu->mat_nr; - dl->charidx= nu->charidx; + dl->parts = 1; + dl->nr = bl->nr; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; /* dl->rt will be used as flag for render face and */ /* CU_2D conflicts with R_NOPUNOFLIP */ - dl->rt= nu->flag & ~CU_2D; + dl->rt = nu->flag & ~CU_2D; - a= dl->nr; - bevp= (BevPoint *)(bl+1); - data= dl->verts; + a = dl->nr; + bevp = (BevPoint *)(bl + 1); + data = dl->verts; while (a--) { - data[0]= bevp->vec[0]+widfac*bevp->sina; - data[1]= bevp->vec[1]+widfac*bevp->cosa; - data[2]= bevp->vec[2]; + data[0] = bevp->vec[0] + widfac * bevp->sina; + data[1] = bevp->vec[1] + widfac * bevp->cosa; + data[2] = bevp->vec[2]; bevp++; - data+=3; + data += 3; } } else { @@ -1333,7 +1333,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba ListBase bottom_capbase = {NULL, NULL}; ListBase top_capbase = {NULL, NULL}; - for (dlb=dlbev.first; dlb; dlb=dlb->next) { + for (dlb = dlbev.first; dlb; dlb = dlb->next) { int i, start, steps; float bevfac1 = MIN2(cu->bevfac1, cu->bevfac2), bevfac2 = MAX2(cu->bevfac1, cu->bevfac2); float firstblend = 0.0f, lastblend = 0.0f; @@ -1341,10 +1341,10 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba if (cu->bevfac1 - cu->bevfac2 == 0.0f) continue; - start = (int)(bevfac1*(bl->nr-1)); - steps = 2+(int)((bevfac2)*(bl->nr-1)) - start; - firstblend = 1.0f - ((float)bevfac1*(bl->nr-1) - (int)((float)bevfac1*(bl->nr-1))); - lastblend = (float)bevfac2*(bl->nr-1) - (int)((float)bevfac2*(bl->nr-1)); + start = (int)(bevfac1 * (bl->nr - 1)); + steps = 2 + (int)((bevfac2) * (bl->nr - 1)) - start; + firstblend = 1.0f - ((float)bevfac1 * (bl->nr - 1) - (int)((float)bevfac1 * (bl->nr - 1))); + lastblend = (float)bevfac2 * (bl->nr - 1) - (int)((float)bevfac2 * (bl->nr - 1)); if (steps > bl->nr) { steps = bl->nr; @@ -1352,35 +1352,35 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba } /* for each part of the bevel use a separate displblock */ - dl= MEM_callocN(sizeof(DispList), "makeDispListbev1"); - dl->verts= data= MEM_callocN(3*sizeof(float)*dlb->nr*steps, "dlverts"); + dl = MEM_callocN(sizeof(DispList), "makeDispListbev1"); + dl->verts = data = MEM_callocN(3 * sizeof(float) * dlb->nr * steps, "dlverts"); BLI_addtail(dispbase, dl); - dl->type= DL_SURF; + dl->type = DL_SURF; - dl->flag= dlb->flag & (DL_FRONT_CURVE|DL_BACK_CURVE); - if (dlb->type==DL_POLY) dl->flag |= DL_CYCL_U; - if (bl->poly>=0) dl->flag |= DL_CYCL_V; + dl->flag = dlb->flag & (DL_FRONT_CURVE | DL_BACK_CURVE); + if (dlb->type == DL_POLY) dl->flag |= DL_CYCL_U; + if (bl->poly >= 0) dl->flag |= DL_CYCL_V; - dl->parts= steps; - dl->nr= dlb->nr; - dl->col= nu->mat_nr; - dl->charidx= nu->charidx; + dl->parts = steps; + dl->nr = dlb->nr; + dl->col = nu->mat_nr; + dl->charidx = nu->charidx; /* dl->rt will be used as flag for render face and */ /* CU_2D conflicts with R_NOPUNOFLIP */ - dl->rt= nu->flag & ~CU_2D; + dl->rt = nu->flag & ~CU_2D; - dl->bevelSplitFlag= MEM_callocN(sizeof(*dl->col2)*((steps+0x1F)>>5), "bevelSplitFlag"); + dl->bevelSplitFlag = MEM_callocN(sizeof(*dl->col2) * ((steps + 0x1F) >> 5), "bevelSplitFlag"); /* for each point of poly make a bevel piece */ - bevp= (BevPoint *)(bl+1) + start; - for (i=start, a=0; ataperobj==NULL) { - if ( (cu->bevobj!=NULL) || !((cu->flag & CU_FRONT) || (cu->flag & CU_BACK)) ) + if (cu->taperobj == NULL) { + if ( (cu->bevobj != NULL) || !((cu->flag & CU_FRONT) || (cu->flag & CU_BACK)) ) fac = bevp->radius; } else { @@ -1388,14 +1388,14 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba } if (bevp->split_tag) { - dl->bevelSplitFlag[a>>5] |= 1<<(a&0x1F); + dl->bevelSplitFlag[a >> 5] |= 1 << (a & 0x1F); } /* rotate bevel piece and write in data */ rotateBevelPiece(cu, bevp, dlb, widfac, fac, &data); if (a == 1 || a == steps - 1) { - float *cur_fp = cur_data, *prev_fp = cur_data - 3*dlb->nr; + float *cur_fp = cur_data, *prev_fp = cur_data - 3 * dlb->nr; int b; for (b = 0; b < dlb->nr; b++, prev_fp += 3, cur_fp += 3) { @@ -1416,7 +1416,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba if (cu->bevobj && (cu->flag & CU_FILL_CAPS)) { if (a == 1) - fillBevelCap(nu, dlb, cur_data - 3*dlb->nr, &bottom_capbase); + fillBevelCap(nu, dlb, cur_data - 3 * dlb->nr, &bottom_capbase); if (a == steps - 1) fillBevelCap(nu, dlb, cur_data, &top_capbase); } @@ -1464,7 +1464,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba void makeDispListCurveTypes(Scene *scene, Object *ob, int forOrco) { - Curve *cu= ob->data; + Curve *cu = ob->data; ListBase *dispbase; /* The same check for duplis as in do_makeDispListCurveTypes. @@ -1473,7 +1473,7 @@ void makeDispListCurveTypes(Scene *scene, Object *ob, int forOrco) if (!ELEM3(ob->type, OB_SURF, OB_CURVE, OB_FONT)) return; freedisplist(&(ob->disp)); - dispbase= &(ob->disp); + dispbase = &(ob->disp); freedisplist(dispbase); /* free displist used for textspace */ @@ -1482,21 +1482,21 @@ void makeDispListCurveTypes(Scene *scene, Object *ob, int forOrco) do_makeDispListCurveTypes(scene, ob, dispbase, &ob->derivedFinal, 0, forOrco); if (ob->derivedFinal) { - DM_set_object_boundbox (ob, ob->derivedFinal); + DM_set_object_boundbox(ob, ob->derivedFinal); } else { - boundbox_displist (ob); + boundbox_displist(ob); /* if there is no derivedMesh, object's boundbox is unneeded */ if (ob->bb) { MEM_freeN(ob->bb); - ob->bb= NULL; + ob->bb = NULL; } } } void makeDispListCurveTypes_forRender(Scene *scene, Object *ob, ListBase *dispbase, - DerivedMesh **derivedFinal, int forOrco) + DerivedMesh **derivedFinal, int forOrco) { do_makeDispListCurveTypes(scene, ob, dispbase, derivedFinal, 1, forOrco); } @@ -1512,16 +1512,16 @@ float *makeOrcoDispList(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int float *orco; if (derivedFinal == NULL) - derivedFinal= ob->derivedFinal; + derivedFinal = ob->derivedFinal; if (!derivedFinal->getVertDataArray(derivedFinal, CD_ORCO)) { curve_calc_orcodm(scene, ob, derivedFinal, forRender); } - orco= derivedFinal->getVertDataArray(derivedFinal, CD_ORCO); + orco = derivedFinal->getVertDataArray(derivedFinal, CD_ORCO); if (orco) { - orco= MEM_dupallocN(orco); + orco = MEM_dupallocN(orco); } return orco; @@ -1530,34 +1530,34 @@ float *makeOrcoDispList(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int /* this is confusing, there's also min_max_object, appplying the obmat... */ static void boundbox_displist(Object *ob) { - BoundBox *bb=NULL; + BoundBox *bb = NULL; float min[3], max[3]; DispList *dl; float *vert; - int a, tot=0; + int a, tot = 0; INIT_MINMAX(min, max); if (ELEM3(ob->type, OB_CURVE, OB_SURF, OB_FONT)) { - Curve *cu= ob->data; - int doit= 0; + Curve *cu = ob->data; + int doit = 0; - if (cu->bb==NULL) cu->bb= MEM_callocN(sizeof(BoundBox), "boundbox"); - bb= cu->bb; + if (cu->bb == NULL) cu->bb = MEM_callocN(sizeof(BoundBox), "boundbox"); + bb = cu->bb; - dl= ob->disp.first; + dl = ob->disp.first; while (dl) { - if (dl->type==DL_INDEX3) tot= dl->nr; - else tot= dl->nr*dl->parts; + if (dl->type == DL_INDEX3) tot = dl->nr; + else tot = dl->nr * dl->parts; - vert= dl->verts; - for (a=0; averts; + for (a = 0; a < tot; a++, vert += 3) { + doit = 1; DO_MINMAX(vert, min, max); } - dl= dl->next; + dl = dl->next; } if (!doit) { diff --git a/source/blender/blenkernel/intern/fcurve.c b/source/blender/blenkernel/intern/fcurve.c index f1942b24810..9d878cd185f 100644 --- a/source/blender/blenkernel/intern/fcurve.c +++ b/source/blender/blenkernel/intern/fcurve.c @@ -107,19 +107,19 @@ void free_fcurves(ListBase *list) * as we store reference to next, and freeing only touches the curve * it's given */ - for (fcu= list->first; fcu; fcu= fcn) { - fcn= fcu->next; + for (fcu = list->first; fcu; fcu = fcn) { + fcn = fcu->next; free_fcurve(fcu); } /* clear pointers just in case */ - list->first= list->last= NULL; + list->first = list->last = NULL; } /* ---------------------- Copy --------------------------- */ /* duplicate an F-Curve */ -FCurve *copy_fcurve (FCurve *fcu) +FCurve *copy_fcurve(FCurve *fcu) { FCurve *fcu_d; @@ -128,20 +128,20 @@ FCurve *copy_fcurve (FCurve *fcu) return NULL; /* make a copy */ - fcu_d= MEM_dupallocN(fcu); + fcu_d = MEM_dupallocN(fcu); - fcu_d->next= fcu_d->prev= NULL; - fcu_d->grp= NULL; + fcu_d->next = fcu_d->prev = NULL; + fcu_d->grp = NULL; /* copy curve data */ - fcu_d->bezt= MEM_dupallocN(fcu_d->bezt); - fcu_d->fpt= MEM_dupallocN(fcu_d->fpt); + fcu_d->bezt = MEM_dupallocN(fcu_d->bezt); + fcu_d->fpt = MEM_dupallocN(fcu_d->fpt); /* copy rna-path */ - fcu_d->rna_path= MEM_dupallocN(fcu_d->rna_path); + fcu_d->rna_path = MEM_dupallocN(fcu_d->rna_path); /* copy driver */ - fcu_d->driver= fcurve_copy_driver(fcu_d->driver); + fcu_d->driver = fcurve_copy_driver(fcu_d->driver); /* copy modifiers */ copy_fmodifiers(&fcu_d->modifiers, &fcu->modifiers); @@ -160,11 +160,11 @@ void copy_fcurves(ListBase *dst, ListBase *src) return; /* clear destination list first */ - dst->first= dst->last= NULL; + dst->first = dst->last = NULL; /* copy one-by-one */ - for (sfcu= src->first; sfcu; sfcu= sfcu->next) { - dfcu= copy_fcurve(sfcu); + for (sfcu = src->first; sfcu; sfcu = sfcu->next) { + dfcu = copy_fcurve(sfcu); BLI_addtail(dst, dfcu); } } @@ -175,8 +175,8 @@ void copy_fcurves(ListBase *dst, ListBase *src) FCurve *id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *prop_name, int index, char *driven) { /* anim vars */ - AnimData *adt= BKE_animdata_from_id(id); - FCurve *fcu= NULL; + AnimData *adt = BKE_animdata_from_id(id); + FCurve *fcu = NULL; /* rna vars */ PointerRNA ptr; @@ -194,16 +194,16 @@ FCurve *id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *pro prop = RNA_struct_find_property(&ptr, prop_name); if (prop) { - path= RNA_path_from_ID_to_property(&ptr, prop); + path = RNA_path_from_ID_to_property(&ptr, prop); if (path) { /* animation takes priority over drivers */ if ((adt->action) && (adt->action->curves.first)) - fcu= list_find_fcurve(&adt->action->curves, path, index); + fcu = list_find_fcurve(&adt->action->curves, path, index); /* if not animated, check if driven */ if ((fcu == NULL) && (adt->drivers.first)) { - fcu= list_find_fcurve(&adt->drivers, path, index); + fcu = list_find_fcurve(&adt->drivers, path, index); if (fcu && driven) *driven = TRUE; fcu = NULL; @@ -218,16 +218,16 @@ FCurve *id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *pro /* Find the F-Curve affecting the given RNA-access path + index, in the list of F-Curves provided */ -FCurve *list_find_fcurve (ListBase *list, const char rna_path[], const int array_index) +FCurve *list_find_fcurve(ListBase *list, const char rna_path[], const int array_index) { FCurve *fcu; /* sanity checks */ - if ( ELEM(NULL, list, rna_path) || (array_index < 0) ) + if (ELEM(NULL, list, rna_path) || (array_index < 0) ) return NULL; /* check paths of curves, then array indices... */ - for (fcu= list->first; fcu; fcu= fcu->next) { + for (fcu = list->first; fcu; fcu = fcu->next) { /* simple string-compare (this assumes that they have the same root...) */ if (fcu->rna_path && !strcmp(fcu->rna_path, rna_path)) { /* now check indices */ @@ -241,7 +241,7 @@ FCurve *list_find_fcurve (ListBase *list, const char rna_path[], const int array } /* quick way to loop over all fcurves of a given 'path' */ -FCurve *iter_step_fcurve (FCurve *fcu_iter, const char rna_path[]) +FCurve *iter_step_fcurve(FCurve *fcu_iter, const char rna_path[]) { FCurve *fcu; @@ -250,7 +250,7 @@ FCurve *iter_step_fcurve (FCurve *fcu_iter, const char rna_path[]) return NULL; /* check paths of curves, then array indices... */ - for (fcu= fcu_iter; fcu; fcu= fcu->next) { + for (fcu = fcu_iter; fcu; fcu = fcu->next) { /* simple string-compare (this assumes that they have the same root...) */ if (fcu->rna_path && !strcmp(fcu->rna_path, rna_path)) { return fcu; @@ -267,8 +267,8 @@ FCurve *iter_step_fcurve (FCurve *fcu_iter, const char rna_path[]) * List must be freed after use, and is assumed to be empty when passed. * - src: list of F-Curves to search through * Filters... - * - dataPrefix: i.e. 'pose.bones[' or 'nodes[' - * - dataName: name of entity within "" immediately following the prefix + * - dataPrefix: i.e. 'pose.bones[' or 'nodes[' + * - dataName: name of entity within "" immediately following the prefix */ int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, const char *dataName) { @@ -282,17 +282,17 @@ int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, return 0; /* search each F-Curve one by one */ - for (fcu= src->first; fcu; fcu= fcu->next) { + for (fcu = src->first; fcu; fcu = fcu->next) { /* check if quoted string matches the path */ if ((fcu->rna_path) && strstr(fcu->rna_path, dataPrefix)) { - char *quotedName= BLI_getQuotedStr(fcu->rna_path, dataPrefix); + char *quotedName = BLI_getQuotedStr(fcu->rna_path, dataPrefix); if (quotedName) { /* check if the quoted name matches the required name */ if (strcmp(quotedName, dataName) == 0) { - LinkData *ld= MEM_callocN(sizeof(LinkData), "list_find_data_fcurves"); + LinkData *ld = MEM_callocN(sizeof(LinkData), "list_find_data_fcurves"); - ld->data= fcu; + ld->data = fcu; BLI_addtail(dst, ld); matches++; @@ -308,37 +308,37 @@ int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, return matches; } -FCurve *rna_get_fcurve (PointerRNA *ptr, PropertyRNA *prop, int rnaindex, bAction **action, int *driven) +FCurve *rna_get_fcurve(PointerRNA *ptr, PropertyRNA *prop, int rnaindex, bAction **action, int *driven) { - FCurve *fcu= NULL; + FCurve *fcu = NULL; - *driven= 0; + *driven = 0; /* there must be some RNA-pointer + property combon */ if (prop && ptr->id.data && RNA_property_animateable(ptr, prop)) { - AnimData *adt= BKE_animdata_from_id(ptr->id.data); + AnimData *adt = BKE_animdata_from_id(ptr->id.data); char *path; if (adt) { if ((adt->action && adt->action->curves.first) || (adt->drivers.first)) { /* XXX this function call can become a performance bottleneck */ - path= RNA_path_from_ID_to_property(ptr, prop); + path = RNA_path_from_ID_to_property(ptr, prop); if (path) { /* animation takes priority over drivers */ if (adt->action && adt->action->curves.first) - fcu= list_find_fcurve(&adt->action->curves, path, rnaindex); + fcu = list_find_fcurve(&adt->action->curves, path, rnaindex); /* if not animated, check if driven */ if (!fcu && (adt->drivers.first)) { - fcu= list_find_fcurve(&adt->drivers, path, rnaindex); + fcu = list_find_fcurve(&adt->drivers, path, rnaindex); if (fcu) - *driven= 1; + *driven = 1; } if (fcu && action) - *action= adt->action; + *action = adt->action; MEM_freeN(path); } @@ -352,18 +352,18 @@ FCurve *rna_get_fcurve (PointerRNA *ptr, PropertyRNA *prop, int rnaindex, bActio /* ----------------- Finding Keyframes/Extents -------------------------- */ /* threshold for binary-searching keyframes - threshold here should be good enough for now, but should become userpref */ -#define BEZT_BINARYSEARCH_THRESH 0.01f /* was 0.00001, but giving errors */ +#define BEZT_BINARYSEARCH_THRESH 0.01f /* was 0.00001, but giving errors */ /* Binary search algorithm for finding where to insert BezTriple. (for use by insert_bezt_fcurve) * Returns the index to insert at (data already at that index will be offset if replace is 0) */ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short *replace) { - int start=0, end=arraylen; - int loopbreaker= 0, maxloop= arraylen * 2; + int start = 0, end = arraylen; + int loopbreaker = 0, maxloop = arraylen * 2; /* initialize replace-flag first */ - *replace= 0; + *replace = 0; /* sneaky optimisations (don't go through searching process if...): * - keyframe to be added is to be added out of current bounds @@ -378,7 +378,7 @@ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short float framenum; /* 'First' Keyframe (when only one keyframe, this case is used) */ - framenum= array[0].vec[1][0]; + framenum = array[0].vec[1][0]; if (IS_EQT(frame, framenum, BEZT_BINARYSEARCH_THRESH)) { *replace = 1; return 0; @@ -387,9 +387,9 @@ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short return 0; /* 'Last' Keyframe */ - framenum= array[(arraylen-1)].vec[1][0]; + framenum = array[(arraylen - 1)].vec[1][0]; if (IS_EQT(frame, framenum, BEZT_BINARYSEARCH_THRESH)) { - *replace= 1; + *replace = 1; return (arraylen - 1); } else if (frame > framenum) @@ -400,10 +400,10 @@ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short /* most of the time, this loop is just to find where to put it * 'loopbreaker' is just here to prevent infinite loops */ - for (loopbreaker=0; (start <= end) && (loopbreaker < maxloop); loopbreaker++) { + for (loopbreaker = 0; (start <= end) && (loopbreaker < maxloop); loopbreaker++) { /* compute and get midpoint */ - int mid = start + ((end - start) / 2); /* we calculate the midpoint this way to avoid int overflows... */ - float midfra= array[mid].vec[1][0]; + int mid = start + ((end - start) / 2); /* we calculate the midpoint this way to avoid int overflows... */ + float midfra = array[mid].vec[1][0]; /* check if exactly equal to midpoint */ if (IS_EQT(frame, midfra, BEZT_BINARYSEARCH_THRESH)) { @@ -413,13 +413,13 @@ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short /* repeat in upper/lower half */ if (frame > midfra) - start= mid + 1; + start = mid + 1; else if (frame < midfra) - end= mid - 1; + end = mid - 1; } /* print error if loop-limit exceeded */ - if (loopbreaker == (maxloop-1)) { + if (loopbreaker == (maxloop - 1)) { printf("Error: binarysearch_bezt_index() was taking too long\n"); // include debug info @@ -433,8 +433,8 @@ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short /* ...................................... */ /* helper for calc_fcurve_* functions -> find first and last BezTriple to be used */ -static void get_fcurve_end_keyframes (FCurve *fcu, BezTriple **first, BezTriple **last, - const short do_sel_only) +static void get_fcurve_end_keyframes(FCurve *fcu, BezTriple **first, BezTriple **last, + const short do_sel_only) { /* init outputs */ *first = NULL; @@ -451,18 +451,18 @@ static void get_fcurve_end_keyframes (FCurve *fcu, BezTriple **first, BezTriple /* find first selected */ bezt = fcu->bezt; - for (i=0; i < fcu->totvert; bezt++, i++) { + for (i = 0; i < fcu->totvert; bezt++, i++) { if (BEZSELECTED(bezt)) { - *first= bezt; + *first = bezt; break; } } /* find last selected */ bezt = ARRAY_LAST_ITEM(fcu->bezt, BezTriple, sizeof(BezTriple), fcu->totvert); - for (i=0; i < fcu->totvert; bezt--, i++) { + for (i = 0; i < fcu->totvert; bezt--, i++) { if (BEZSELECTED(bezt)) { - *last= bezt; + *last = bezt; break; } } @@ -479,14 +479,14 @@ static void get_fcurve_end_keyframes (FCurve *fcu, BezTriple **first, BezTriple void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax, const short do_sel_only) { - float xminv=999999999.0f, xmaxv=-999999999.0f; - float yminv=999999999.0f, ymaxv=-999999999.0f; - short foundvert= FALSE; + float xminv = 999999999.0f, xmaxv = -999999999.0f; + float yminv = 999999999.0f, ymaxv = -999999999.0f; + short foundvert = FALSE; unsigned int i; if (fcu->totvert) { if (fcu->bezt) { - BezTriple *bezt_first= NULL, *bezt_last= NULL; + BezTriple *bezt_first = NULL, *bezt_last = NULL; if (xmin || xmax) { /* get endpoint keyframes */ @@ -495,8 +495,8 @@ void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, floa if (bezt_first) { BLI_assert(bezt_last != NULL); - xminv= MIN2(xminv, bezt_first->vec[1][0]); - xmaxv= MAX2(xmaxv, bezt_last->vec[1][0]); + xminv = MIN2(xminv, bezt_first->vec[1][0]); + xmaxv = MAX2(xmaxv, bezt_last->vec[1][0]); } } @@ -504,13 +504,13 @@ void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, floa if (ymin || ymax) { BezTriple *bezt; - for (bezt=fcu->bezt, i=0; i < fcu->totvert; bezt++, i++) { + for (bezt = fcu->bezt, i = 0; i < fcu->totvert; bezt++, i++) { if ((do_sel_only == 0) || BEZSELECTED(bezt)) { if (bezt->vec[1][1] < yminv) - yminv= bezt->vec[1][1]; + yminv = bezt->vec[1][1]; if (bezt->vec[1][1] > ymaxv) - ymaxv= bezt->vec[1][1]; - foundvert= TRUE; + ymaxv = bezt->vec[1][1]; + foundvert = TRUE; } } } @@ -518,42 +518,42 @@ void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, floa else if (fcu->fpt) { /* frame range can be directly calculated from end verts */ if (xmin || xmax) { - xminv= MIN2(xminv, fcu->fpt[0].vec[0]); - xmaxv= MAX2(xmaxv, fcu->fpt[fcu->totvert-1].vec[0]); + xminv = MIN2(xminv, fcu->fpt[0].vec[0]); + xmaxv = MAX2(xmaxv, fcu->fpt[fcu->totvert - 1].vec[0]); } /* only loop over keyframes to find extents for values if needed */ if (ymin || ymax) { FPoint *fpt; - for (fpt=fcu->fpt, i=0; i < fcu->totvert; fpt++, i++) { + for (fpt = fcu->fpt, i = 0; i < fcu->totvert; fpt++, i++) { if (fpt->vec[1] < yminv) - yminv= fpt->vec[1]; + yminv = fpt->vec[1]; if (fpt->vec[1] > ymaxv) - ymaxv= fpt->vec[1]; + ymaxv = fpt->vec[1]; - foundvert= TRUE; + foundvert = TRUE; } } } } if (foundvert) { - if (xmin) *xmin= xminv; - if (xmax) *xmax= xmaxv; + if (xmin) *xmin = xminv; + if (xmax) *xmax = xmaxv; - if (ymin) *ymin= yminv; - if (ymax) *ymax= ymaxv; + if (ymin) *ymin = yminv; + if (ymax) *ymax = ymaxv; } else { if (G.debug & G_DEBUG) printf("F-Curve calc bounds didn't find anything, so assuming minimum bounds of 1.0\n"); - if (xmin) *xmin= 0.0f; - if (xmax) *xmax= 1.0f; + if (xmin) *xmin = 0.0f; + if (xmax) *xmax = 1.0f; - if (ymin) *ymin= 0.0f; - if (ymax) *ymax= 1.0f; + if (ymin) *ymin = 0.0f; + if (ymax) *ymax = 1.0f; } } @@ -561,12 +561,12 @@ void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, floa void calc_fcurve_range(FCurve *fcu, float *start, float *end, const short do_sel_only, const short do_min_length) { - float min=999999999.0f, max=-999999999.0f; - short foundvert= FALSE; + float min = 999999999.0f, max = -999999999.0f; + short foundvert = FALSE; if (fcu->totvert) { if (fcu->bezt) { - BezTriple *bezt_first= NULL, *bezt_last= NULL; + BezTriple *bezt_first = NULL, *bezt_last = NULL; /* get endpoint keyframes */ get_fcurve_end_keyframes(fcu, &bezt_first, &bezt_last, do_sel_only); @@ -574,23 +574,23 @@ void calc_fcurve_range(FCurve *fcu, float *start, float *end, if (bezt_first) { BLI_assert(bezt_last != NULL); - min= MIN2(min, bezt_first->vec[1][0]); - max= MAX2(max, bezt_last->vec[1][0]); + min = MIN2(min, bezt_first->vec[1][0]); + max = MAX2(max, bezt_last->vec[1][0]); - foundvert= TRUE; + foundvert = TRUE; } } else if (fcu->fpt) { - min= MIN2(min, fcu->fpt[0].vec[0]); - max= MAX2(max, fcu->fpt[fcu->totvert-1].vec[0]); + min = MIN2(min, fcu->fpt[0].vec[0]); + max = MAX2(max, fcu->fpt[fcu->totvert - 1].vec[0]); - foundvert= TRUE; + foundvert = TRUE; } } if (foundvert == FALSE) { - min= max= 0.0f; + min = max = 0.0f; } if (do_min_length) { @@ -600,8 +600,8 @@ void calc_fcurve_range(FCurve *fcu, float *start, float *end, } } - *start= min; - *end= max; + *start = min; + *end = max; } /* ----------------- Status Checks -------------------------- */ @@ -628,7 +628,7 @@ short fcurve_are_keyframes_usable(FCurve *fcu) // TODO: optionally, only check modifier if it is the active one... for (fcm = fcu->modifiers.last; fcm; fcm = fcm->prev) { /* ignore if muted/disabled */ - if (fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) + if (fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) continue; /* type checks */ @@ -647,7 +647,7 @@ short fcurve_are_keyframes_usable(FCurve *fcu) if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) return 0; } - break; + break; case FMODIFIER_TYPE_FN_GENERATOR: { FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)fcm->data; @@ -655,7 +655,7 @@ short fcurve_are_keyframes_usable(FCurve *fcu) if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) return 0; } - break; + break; /* always harmful - cannot allow */ default: @@ -692,10 +692,10 @@ void bezt_add_to_cfra_elem(ListBase *lb, BezTriple *bezt) { CfraElem *ce, *cen; - for (ce= lb->first; ce; ce= ce->next) { + for (ce = lb->first; ce; ce = ce->next) { /* double key? */ if (ce->cfra == bezt->vec[1][0]) { - if (bezt->f2 & SELECT) ce->sel= bezt->f2; + if (bezt->f2 & SELECT) ce->sel = bezt->f2; return; } /* should key be inserted before this column? */ @@ -703,12 +703,12 @@ void bezt_add_to_cfra_elem(ListBase *lb, BezTriple *bezt) } /* create a new column */ - cen= MEM_callocN(sizeof(CfraElem), "add_to_cfra_elem"); + cen = MEM_callocN(sizeof(CfraElem), "add_to_cfra_elem"); if (ce) BLI_insertlinkbefore(lb, ce, cen); else BLI_addtail(lb, cen); - cen->cfra= bezt->vec[1][0]; - cen->sel= bezt->f2; + cen->cfra = bezt->vec[1][0]; + cen->sel = bezt->f2; } /* ***************************** Samples Utilities ******************************* */ @@ -748,12 +748,12 @@ void fcurve_store_samples(FCurve *fcu, void *data, int start, int end, FcuSample } /* set up sample data */ - fpt= new_fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "FPoint Samples"); + fpt = new_fpt = MEM_callocN(sizeof(FPoint) * (end - start + 1), "FPoint Samples"); /* use the sampling callback at 1-frame intervals from start to end frames */ - for (cfra= start; cfra <= end; cfra++, fpt++) { - fpt->vec[0]= (float)cfra; - fpt->vec[1]= sample_cb(fcu, data, (float)cfra); + for (cfra = start; cfra <= end; cfra++, fpt++) { + fpt->vec[0] = (float)cfra; + fpt->vec[1] = sample_cb(fcu, data, (float)cfra); } /* free any existing sample/keyframe data on curve */ @@ -761,9 +761,9 @@ void fcurve_store_samples(FCurve *fcu, void *data, int start, int end, FcuSample if (fcu->fpt) MEM_freeN(fcu->fpt); /* store the samples */ - fcu->bezt= NULL; - fcu->fpt= new_fpt; - fcu->totvert= end - start + 1; + fcu->bezt = NULL; + fcu->fpt = new_fpt; + fcu->totvert = end - start + 1; } /* ***************************** F-Curve Sanity ********************************* */ @@ -778,7 +778,7 @@ void fcurve_store_samples(FCurve *fcu, void *data, int start, int end, FcuSample void calchandles_fcurve(FCurve *fcu) { BezTriple *bezt, *prev, *next; - int a= fcu->totvert; + int a = fcu->totvert; /* Error checking: * - need at least two points @@ -789,33 +789,33 @@ void calchandles_fcurve(FCurve *fcu) return; /* get initial pointers */ - bezt= fcu->bezt; - prev= NULL; - next= (bezt + 1); + bezt = fcu->bezt; + prev = NULL; + next = (bezt + 1); /* loop over all beztriples, adjusting handles */ while (a--) { /* clamp timing of handles to be on either side of beztriple */ - if (bezt->vec[0][0] > bezt->vec[1][0]) bezt->vec[0][0]= bezt->vec[1][0]; - if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0]= bezt->vec[1][0]; + if (bezt->vec[0][0] > bezt->vec[1][0]) bezt->vec[0][0] = bezt->vec[1][0]; + if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0] = bezt->vec[1][0]; /* calculate auto-handles */ - BKE_nurb_handle_calc(bezt, prev, next, 1); /* 1==special autohandle */ + BKE_nurb_handle_calc(bezt, prev, next, 1); /* 1==special autohandle */ /* for automatic ease in and out */ if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) && ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) { /* only do this on first or last beztriple */ - if ((a == 0) || (a == fcu->totvert-1)) { + if ((a == 0) || (a == fcu->totvert - 1)) { /* set both handles to have same horizontal value as keyframe */ if (fcu->extend == FCURVE_EXTRAPOLATE_CONSTANT) { - bezt->vec[0][1]= bezt->vec[2][1]= bezt->vec[1][1]; + bezt->vec[0][1] = bezt->vec[2][1] = bezt->vec[1][1]; } } } /* advance pointers for next iteration */ - prev= bezt; - if (a == 1) next= NULL; + prev = bezt; + if (a == 1) next = NULL; else next++; bezt++; } @@ -824,8 +824,8 @@ void calchandles_fcurve(FCurve *fcu) /* Use when F-Curve with handles has changed * It treats all BezTriples with the following rules: * - PHASE 1: do types have to be altered? - * -> Auto handles: become aligned when selection status is NOT(000 || 111) - * -> Vector handles: become 'nothing' when (one half selected AND other not) + * -> Auto handles: become aligned when selection status is NOT(000 || 111) + * -> Vector handles: become 'nothing' when (one half selected AND other not) * - PHASE 2: recalculate handles */ void testhandles_fcurve(FCurve *fcu, const short use_handle) @@ -838,41 +838,41 @@ void testhandles_fcurve(FCurve *fcu, const short use_handle) return; /* loop over beztriples */ - for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) { - short flag= 0; + for (a = 0, bezt = fcu->bezt; a < fcu->totvert; a++, bezt++) { + short flag = 0; /* flag is initialized as selection status * of beztriple control-points (labelled 0,1,2) */ - if (bezt->f2 & SELECT) flag |= (1<<1); // == 2 + if (bezt->f2 & SELECT) flag |= (1 << 1); // == 2 if (use_handle == FALSE) { if (flag & 2) { - flag |= (1<<0) | (1<<2); + flag |= (1 << 0) | (1 << 2); } } else { - if (bezt->f1 & SELECT) flag |= (1<<0); // == 1 - if (bezt->f3 & SELECT) flag |= (1<<2); // == 4 + if (bezt->f1 & SELECT) flag |= (1 << 0); // == 1 + if (bezt->f3 & SELECT) flag |= (1 << 2); // == 4 } /* one or two handles selected only */ - if (ELEM(flag, 0, 7)==0) { + if (ELEM(flag, 0, 7) == 0) { /* auto handles become aligned */ if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM)) - bezt->h1= HD_ALIGN; + bezt->h1 = HD_ALIGN; if (ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) - bezt->h2= HD_ALIGN; + bezt->h2 = HD_ALIGN; /* vector handles become 'free' when only one half selected */ - if (bezt->h1==HD_VECT) { + if (bezt->h1 == HD_VECT) { /* only left half (1 or 2 or 1+2) */ if (flag < 4) - bezt->h1= 0; + bezt->h1 = 0; } - if (bezt->h2==HD_VECT) { + if (bezt->h2 == HD_VECT) { /* only right half (4 or 2+4) */ if (flag > 3) - bezt->h2= 0; + bezt->h2 = 0; } } } @@ -886,11 +886,11 @@ void testhandles_fcurve(FCurve *fcu, const short use_handle) */ void sort_time_fcurve(FCurve *fcu) { - short ok= 1; + short ok = 1; /* keep adjusting order of beztriples until nothing moves (bubble-sort) */ while (ok) { - ok= 0; + ok = 0; /* currently, will only be needed when there are beztriples */ if (fcu->bezt) { @@ -898,13 +898,13 @@ void sort_time_fcurve(FCurve *fcu) unsigned int a; /* loop over ALL points to adjust position in array and recalculate handles */ - for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) { + for (a = 0, bezt = fcu->bezt; a < fcu->totvert; a++, bezt++) { /* check if thee's a next beztriple which we could try to swap with current */ - if (a < (fcu->totvert-1)) { + if (a < (fcu->totvert - 1)) { /* swap if one is after the other (and indicate that order has changed) */ - if (bezt->vec[1][0] > (bezt+1)->vec[1][0]) { - SWAP(BezTriple, *bezt, *(bezt+1)); - ok= 1; + if (bezt->vec[1][0] > (bezt + 1)->vec[1][0]) { + SWAP(BezTriple, *bezt, *(bezt + 1)); + ok = 1; } /* if either one of both of the points exceeds crosses over the keyframe time... */ @@ -916,9 +916,9 @@ void sort_time_fcurve(FCurve *fcu) else { /* clamp handles */ if (bezt->vec[0][0] > bezt->vec[1][0]) - bezt->vec[0][0]= bezt->vec[1][0]; + bezt->vec[0][0] = bezt->vec[1][0]; if (bezt->vec[2][0] < bezt->vec[1][0]) - bezt->vec[2][0]= bezt->vec[1][0]; + bezt->vec[2][0] = bezt->vec[1][0]; } } } @@ -940,8 +940,8 @@ short test_time_fcurve(FCurve *fcu) BezTriple *bezt; /* loop through all BezTriples, stopping when one exceeds the one after it */ - for (a=0, bezt= fcu->bezt; a < (fcu->totvert - 1); a++, bezt++) { - if (bezt->vec[1][0] > (bezt+1)->vec[1][0]) + for (a = 0, bezt = fcu->bezt; a < (fcu->totvert - 1); a++, bezt++) { + if (bezt->vec[1][0] > (bezt + 1)->vec[1][0]) return 1; } } @@ -949,8 +949,8 @@ short test_time_fcurve(FCurve *fcu) FPoint *fpt; /* loop through all FPoints, stopping when one exceeds the one after it */ - for (a=0, fpt= fcu->fpt; a < (fcu->totvert - 1); a++, fpt++) { - if (fpt->vec[0] > (fpt+1)->vec[0]) + for (a = 0, fpt = fcu->fpt; a < (fcu->totvert - 1); a++, fpt++) { + if (fpt->vec[0] > (fpt + 1)->vec[0]) return 1; } } @@ -969,9 +969,9 @@ typedef struct DriverVarTypeInfo { float (*get_value)(ChannelDriver *driver, DriverVar *dvar); /* allocation of target slots */ - int num_targets; /* number of target slots required */ - const char *target_names[MAX_DRIVER_TARGETS]; /* UI names that should be given to the slots */ - int target_flags[MAX_DRIVER_TARGETS]; /* flags defining the requirements for each slot */ + int num_targets; /* number of target slots required */ + const char *target_names[MAX_DRIVER_TARGETS]; /* UI names that should be given to the slots */ + int target_flags[MAX_DRIVER_TARGETS]; /* flags defining the requirements for each slot */ } DriverVarTypeInfo; /* Macro to begin definitions */ @@ -986,25 +986,25 @@ typedef struct DriverVarTypeInfo { static ID *dtar_id_ensure_proxy_from(ID *id) { - if (id && GS(id->name)==ID_OB && ((Object *)id)->proxy_from) + if (id && GS(id->name) == ID_OB && ((Object *)id)->proxy_from) return (ID *)(((Object *)id)->proxy_from); return id; } /* Helper function to obtain a value using RNA from the specified source (for evaluating drivers) */ -static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar) +static float dtar_get_prop_val(ChannelDriver *driver, DriverTarget *dtar) { PointerRNA id_ptr, ptr; PropertyRNA *prop; ID *id; int index; - float value= 0.0f; + float value = 0.0f; /* sanity check */ if (ELEM(NULL, driver, dtar)) return 0.0f; - id= dtar_id_ensure_proxy_from(dtar->id); + id = dtar_id_ensure_proxy_from(dtar->id); /* error check for missing pointer... */ // TODO: tag the specific target too as having issues @@ -1024,37 +1024,37 @@ static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar) /* array */ if (index < RNA_property_array_length(&ptr, prop)) { switch (RNA_property_type(prop)) { + case PROP_BOOLEAN: + value = (float)RNA_property_boolean_get_index(&ptr, prop, index); + break; + case PROP_INT: + value = (float)RNA_property_int_get_index(&ptr, prop, index); + break; + case PROP_FLOAT: + value = RNA_property_float_get_index(&ptr, prop, index); + break; + default: + break; + } + } + } + else { + /* not an array */ + switch (RNA_property_type(prop)) { case PROP_BOOLEAN: - value= (float)RNA_property_boolean_get_index(&ptr, prop, index); + value = (float)RNA_property_boolean_get(&ptr, prop); break; case PROP_INT: - value= (float)RNA_property_int_get_index(&ptr, prop, index); + value = (float)RNA_property_int_get(&ptr, prop); break; case PROP_FLOAT: - value= RNA_property_float_get_index(&ptr, prop, index); + value = RNA_property_float_get(&ptr, prop); + break; + case PROP_ENUM: + value = (float)RNA_property_enum_get(&ptr, prop); break; default: break; - } - } - } - else { - /* not an array */ - switch (RNA_property_type(prop)) { - case PROP_BOOLEAN: - value= (float)RNA_property_boolean_get(&ptr, prop); - break; - case PROP_INT: - value= (float)RNA_property_int_get(&ptr, prop); - break; - case PROP_FLOAT: - value= RNA_property_float_get(&ptr, prop); - break; - case PROP_ENUM: - value= (float)RNA_property_enum_get(&ptr, prop); - break; - default: - break; } } @@ -1071,18 +1071,18 @@ static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar) } /* Helper function to obtain a pointer to a Pose Channel (for evaluating drivers) */ -static bPoseChannel *dtar_get_pchan_ptr (ChannelDriver *driver, DriverTarget *dtar) +static bPoseChannel *dtar_get_pchan_ptr(ChannelDriver *driver, DriverTarget *dtar) { ID *id; /* sanity check */ if (ELEM(NULL, driver, dtar)) return NULL; - id= dtar_id_ensure_proxy_from(dtar->id); + id = dtar_id_ensure_proxy_from(dtar->id); /* check if the ID here is a valid object */ if (id && GS(id->name)) { - Object *ob= (Object *)id; + Object *ob = (Object *)id; /* get pose, and subsequently, posechannel */ return BKE_pose_channel_find_name(ob->pose, dtar->pchan_name); @@ -1096,21 +1096,21 @@ static bPoseChannel *dtar_get_pchan_ptr (ChannelDriver *driver, DriverTarget *dt /* ......... */ /* evaluate 'single prop' driver variable */ -static float dvar_eval_singleProp (ChannelDriver *driver, DriverVar *dvar) +static float dvar_eval_singleProp(ChannelDriver *driver, DriverVar *dvar) { /* just evaluate the first target slot */ return dtar_get_prop_val(driver, &dvar->targets[0]); } /* evaluate 'rotation difference' driver variable */ -static float dvar_eval_rotDiff (ChannelDriver *driver, DriverVar *dvar) +static float dvar_eval_rotDiff(ChannelDriver *driver, DriverVar *dvar) { bPoseChannel *pchan, *pchan2; float q1[4], q2[4], quat[4], angle; /* get pose channels, and check if we've got two */ - pchan= dtar_get_pchan_ptr(driver, &dvar->targets[0]); - pchan2= dtar_get_pchan_ptr(driver, &dvar->targets[1]); + pchan = dtar_get_pchan_ptr(driver, &dvar->targets[0]); + pchan2 = dtar_get_pchan_ptr(driver, &dvar->targets[1]); if (ELEM(NULL, pchan, pchan2)) { /* disable this driver, since it doesn't work correctly... */ @@ -1135,14 +1135,14 @@ static float dvar_eval_rotDiff (ChannelDriver *driver, DriverVar *dvar) invert_qt(q1); mul_qt_qtqt(quat, q1, q2); angle = 2.0f * (saacos(quat[0])); - angle= ABS(angle); + angle = ABS(angle); return (angle > (float)M_PI) ? (float)((2.0f * (float)M_PI) - angle) : (float)(angle); } /* evaluate 'location difference' driver variable */ // TODO: this needs to take into account space conversions... -static float dvar_eval_locDiff (ChannelDriver *driver, DriverVar *dvar) +static float dvar_eval_locDiff(ChannelDriver *driver, DriverVar *dvar) { float loc1[3] = {0.0f, 0.0f, 0.0f}; float loc2[3] = {0.0f, 0.0f, 0.0f}; @@ -1152,7 +1152,7 @@ static float dvar_eval_locDiff (ChannelDriver *driver, DriverVar *dvar) DRIVER_TARGETS_USED_LOOPER(dvar) { /* get pointer to loc values to store in */ - Object *ob= (Object *)dtar_id_ensure_proxy_from(dtar->id); + Object *ob = (Object *)dtar_id_ensure_proxy_from(dtar->id); bPoseChannel *pchan; float tmp_loc[3]; @@ -1164,7 +1164,7 @@ static float dvar_eval_locDiff (ChannelDriver *driver, DriverVar *dvar) } /* try to get posechannel */ - pchan= BKE_pose_channel_find_name(ob->pose, dtar->pchan_name); + pchan = BKE_pose_channel_find_name(ob->pose, dtar->pchan_name); /* check if object or bone */ if (pchan) { @@ -1234,14 +1234,14 @@ static float dvar_eval_locDiff (ChannelDriver *driver, DriverVar *dvar) } /* evaluate 'transform channel' driver variable */ -static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar) +static float dvar_eval_transChan(ChannelDriver *driver, DriverVar *dvar) { - DriverTarget *dtar= &dvar->targets[0]; - Object *ob= (Object *)dtar_id_ensure_proxy_from(dtar->id); + DriverTarget *dtar = &dvar->targets[0]; + Object *ob = (Object *)dtar_id_ensure_proxy_from(dtar->id); bPoseChannel *pchan; float mat[4][4]; float oldEul[3] = {0.0f, 0.0f, 0.0f}; - short useEulers=0, rotOrder=ROT_MODE_EUL; + short useEulers = 0, rotOrder = ROT_MODE_EUL; /* check if this target has valid data */ if ((ob == NULL) || (GS(ob->id.name) != ID_OB)) { @@ -1251,7 +1251,7 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar) } /* try to get posechannel */ - pchan= BKE_pose_channel_find_name(ob->pose, dtar->pchan_name); + pchan = BKE_pose_channel_find_name(ob->pose, dtar->pchan_name); /* check if object or bone, and get transform matrix accordingly * - "useEulers" code is used to prevent the problems associated with non-uniqueness @@ -1263,7 +1263,7 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar) /* bone */ if (pchan->rotmode > 0) { copy_v3_v3(oldEul, pchan->eul); - rotOrder= pchan->rotmode; + rotOrder = pchan->rotmode; useEulers = 1; } @@ -1290,7 +1290,7 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar) /* object */ if (ob->rotmode > 0) { copy_v3_v3(oldEul, ob->rot); - rotOrder= ob->rotmode; + rotOrder = ob->rotmode; useEulers = 1; } @@ -1353,36 +1353,36 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar) /* Table of Driver Varaiable Type Info Data */ static DriverVarTypeInfo dvar_types[MAX_DVAR_TYPES] = { BEGIN_DVAR_TYPEDEF(DVAR_TYPE_SINGLE_PROP) - dvar_eval_singleProp, /* eval callback */ - 1, /* number of targets used */ - {"Property"}, /* UI names for targets */ - {0} /* flags */ + dvar_eval_singleProp, /* eval callback */ + 1, /* number of targets used */ + {"Property"}, /* UI names for targets */ + {0} /* flags */ END_DVAR_TYPEDEF, BEGIN_DVAR_TYPEDEF(DVAR_TYPE_ROT_DIFF) - dvar_eval_rotDiff, /* eval callback */ - 2, /* number of targets used */ - {"Bone 1", "Bone 2"}, /* UI names for targets */ - {DTAR_FLAG_STRUCT_REF|DTAR_FLAG_ID_OB_ONLY, DTAR_FLAG_STRUCT_REF|DTAR_FLAG_ID_OB_ONLY} /* flags */ + dvar_eval_rotDiff, /* eval callback */ + 2, /* number of targets used */ + {"Bone 1", "Bone 2"}, /* UI names for targets */ + {DTAR_FLAG_STRUCT_REF | DTAR_FLAG_ID_OB_ONLY, DTAR_FLAG_STRUCT_REF | DTAR_FLAG_ID_OB_ONLY} /* flags */ END_DVAR_TYPEDEF, BEGIN_DVAR_TYPEDEF(DVAR_TYPE_LOC_DIFF) - dvar_eval_locDiff, /* eval callback */ - 2, /* number of targets used */ - {"Object/Bone 1", "Object/Bone 2"}, /* UI names for targets */ - {DTAR_FLAG_STRUCT_REF|DTAR_FLAG_ID_OB_ONLY, DTAR_FLAG_STRUCT_REF|DTAR_FLAG_ID_OB_ONLY} /* flags */ + dvar_eval_locDiff, /* eval callback */ + 2, /* number of targets used */ + {"Object/Bone 1", "Object/Bone 2"}, /* UI names for targets */ + {DTAR_FLAG_STRUCT_REF | DTAR_FLAG_ID_OB_ONLY, DTAR_FLAG_STRUCT_REF | DTAR_FLAG_ID_OB_ONLY} /* flags */ END_DVAR_TYPEDEF, BEGIN_DVAR_TYPEDEF(DVAR_TYPE_TRANSFORM_CHAN) - dvar_eval_transChan, /* eval callback */ - 1, /* number of targets used */ - {"Object/Bone"}, /* UI names for targets */ - {DTAR_FLAG_STRUCT_REF|DTAR_FLAG_ID_OB_ONLY} /* flags */ + dvar_eval_transChan, /* eval callback */ + 1, /* number of targets used */ + {"Object/Bone"}, /* UI names for targets */ + {DTAR_FLAG_STRUCT_REF | DTAR_FLAG_ID_OB_ONLY} /* flags */ END_DVAR_TYPEDEF, }; /* Get driver variable typeinfo */ -static DriverVarTypeInfo *get_dvar_typeinfo (int type) +static DriverVarTypeInfo *get_dvar_typeinfo(int type) { /* check if valid type */ if ((type >= 0) && (type < MAX_DVAR_TYPES)) @@ -1403,7 +1403,7 @@ void driver_free_variable(ChannelDriver *driver, DriverVar *dvar) /* free target vars * - need to go over all of them, not just up to the ones that are used * currently, since there may be some lingering RNA paths from - * previous users needing freeing + * previous users needing freeing */ DRIVER_TARGETS_LOOPER(dvar) { @@ -1418,7 +1418,7 @@ void driver_free_variable(ChannelDriver *driver, DriverVar *dvar) #ifdef WITH_PYTHON /* since driver variables are cached, the expression needs re-compiling too */ - if (driver->type==DRIVER_TYPE_PYTHON) + if (driver->type == DRIVER_TYPE_PYTHON) driver->flag |= DRIVER_FLAG_RENAMEVAR; #endif } @@ -1426,15 +1426,15 @@ void driver_free_variable(ChannelDriver *driver, DriverVar *dvar) /* Change the type of driver variable */ void driver_change_variable_type(DriverVar *dvar, int type) { - DriverVarTypeInfo *dvti= get_dvar_typeinfo(type); + DriverVarTypeInfo *dvti = get_dvar_typeinfo(type); /* sanity check */ if (ELEM(NULL, dvar, dvti)) return; /* set the new settings */ - dvar->type= type; - dvar->num_targets= dvti->num_targets; + dvar->type = type; + dvar->num_targets = dvti->num_targets; /* make changes to the targets based on the defines for these types * NOTE: only need to make sure the ones we're using here are valid... @@ -1448,13 +1448,13 @@ void driver_change_variable_type(DriverVar *dvar, int type) /* object ID types only, or idtype not yet initialized*/ if ((flags & DTAR_FLAG_ID_OB_ONLY) || (dtar->idtype == 0)) - dtar->idtype= ID_OB; + dtar->idtype = ID_OB; } DRIVER_TARGETS_LOOPER_END } /* Add a new driver variable */ -DriverVar *driver_add_new_variable (ChannelDriver *driver) +DriverVar *driver_add_new_variable(ChannelDriver *driver) { DriverVar *dvar; @@ -1463,7 +1463,7 @@ DriverVar *driver_add_new_variable (ChannelDriver *driver) return NULL; /* make a new variable */ - dvar= MEM_callocN(sizeof(DriverVar), "DriverVar"); + dvar = MEM_callocN(sizeof(DriverVar), "DriverVar"); BLI_addtail(&driver->variables, dvar); /* give the variable a 'unique' name */ @@ -1475,7 +1475,7 @@ DriverVar *driver_add_new_variable (ChannelDriver *driver) #ifdef WITH_PYTHON /* since driver variables are cached, the expression needs re-compiling too */ - if (driver->type==DRIVER_TYPE_PYTHON) + if (driver->type == DRIVER_TYPE_PYTHON) driver->flag |= DRIVER_FLAG_RENAMEVAR; #endif @@ -1492,11 +1492,11 @@ void fcurve_free_driver(FCurve *fcu) /* sanity checks */ if (ELEM(NULL, fcu, fcu->driver)) return; - driver= fcu->driver; + driver = fcu->driver; /* free driver targets */ - for (dvar= driver->variables.first; dvar; dvar= dvarn) { - dvarn= dvar->next; + for (dvar = driver->variables.first; dvar; dvar = dvarn) { + dvarn = dvar->next; driver_free_variable(driver, dvar); } @@ -1508,11 +1508,11 @@ void fcurve_free_driver(FCurve *fcu) /* free driver itself, then set F-Curve's point to this to NULL (as the curve may still be used) */ MEM_freeN(driver); - fcu->driver= NULL; + fcu->driver = NULL; } /* This makes a copy of the given driver */ -ChannelDriver *fcurve_copy_driver (ChannelDriver *driver) +ChannelDriver *fcurve_copy_driver(ChannelDriver *driver) { ChannelDriver *ndriver; DriverVar *dvar; @@ -1522,14 +1522,14 @@ ChannelDriver *fcurve_copy_driver (ChannelDriver *driver) return NULL; /* copy all data */ - ndriver= MEM_dupallocN(driver); - ndriver->expr_comp= NULL; + ndriver = MEM_dupallocN(driver); + ndriver->expr_comp = NULL; /* copy variables */ - ndriver->variables.first= ndriver->variables.last= NULL; + ndriver->variables.first = ndriver->variables.last = NULL; BLI_duplicatelist(&ndriver->variables, &driver->variables); - for (dvar= ndriver->variables.first; dvar; dvar= dvar->next) { + for (dvar = ndriver->variables.first; dvar; dvar = dvar->next) { /* need to go over all targets so that we don't leave any dangling paths */ DRIVER_TARGETS_LOOPER(dvar) { @@ -1559,21 +1559,21 @@ float driver_get_variable_value(ChannelDriver *driver, DriverVar *dvar) * using the variable type info, storing the obtained value * in dvar->curval so that drivers can be debugged */ - dvti= get_dvar_typeinfo(dvar->type); + dvti = get_dvar_typeinfo(dvar->type); if (dvti && dvti->get_value) - dvar->curval= dvti->get_value(driver, dvar); + dvar->curval = dvti->get_value(driver, dvar); else - dvar->curval= 0.0f; + dvar->curval = 0.0f; return dvar->curval; } /* Evaluate an Channel-Driver to get a 'time' value to use instead of "evaltime" * - "evaltime" is the frame at which F-Curve is being evaluated - * - has to return a float value + * - has to return a float value */ -static float evaluate_driver (ChannelDriver *driver, const float evaltime) +static float evaluate_driver(ChannelDriver *driver, const float evaltime) { DriverVar *dvar; @@ -1588,8 +1588,8 @@ static float evaluate_driver (ChannelDriver *driver, const float evaltime) /* check how many variables there are first (i.e. just one?) */ if (driver->variables.first == driver->variables.last) { /* just one target, so just use that */ - dvar= driver->variables.first; - driver->curval= driver_get_variable_value(driver, dvar); + dvar = driver->variables.first; + driver->curval = driver_get_variable_value(driver, dvar); } else { /* more than one target, so average the values of the targets */ @@ -1597,19 +1597,19 @@ static float evaluate_driver (ChannelDriver *driver, const float evaltime) int tot = 0; /* loop through targets, adding (hopefully we don't get any overflow!) */ - for (dvar= driver->variables.first; dvar; dvar=dvar->next) { + for (dvar = driver->variables.first; dvar; dvar = dvar->next) { value += driver_get_variable_value(driver, dvar); tot++; } /* perform operations on the total if appropriate */ if (driver->type == DRIVER_TYPE_AVERAGE) - driver->curval= (value / (float)tot); + driver->curval = (value / (float)tot); else - driver->curval= value; + driver->curval = value; } } - break; + break; case DRIVER_TYPE_MIN: /* smallest value */ case DRIVER_TYPE_MAX: /* largest value */ @@ -1617,9 +1617,9 @@ static float evaluate_driver (ChannelDriver *driver, const float evaltime) float value = 0.0f; /* loop through the variables, getting the values and comparing them to existing ones */ - for (dvar= driver->variables.first; dvar; dvar= dvar->next) { + for (dvar = driver->variables.first; dvar; dvar = dvar->next) { /* get value */ - float tmp_val= driver_get_variable_value(driver, dvar); + float tmp_val = driver_get_variable_value(driver, dvar); /* store this value if appropriate */ if (dvar->prev) { @@ -1627,51 +1627,51 @@ static float evaluate_driver (ChannelDriver *driver, const float evaltime) if (driver->type == DRIVER_TYPE_MAX) { /* max? */ if (tmp_val > value) - value= tmp_val; + value = tmp_val; } else { /* min? */ if (tmp_val < value) - value= tmp_val; + value = tmp_val; } } else { /* first item - make this the baseline for comparisons */ - value= tmp_val; + value = tmp_val; } } /* store value in driver */ - driver->curval= value; + driver->curval = value; } - break; + break; case DRIVER_TYPE_PYTHON: /* expression */ { #ifdef WITH_PYTHON /* check for empty or invalid expression */ if ( (driver->expression[0] == '\0') || - (driver->flag & DRIVER_FLAG_INVALID) ) + (driver->flag & DRIVER_FLAG_INVALID) ) { - driver->curval= 0.0f; + driver->curval = 0.0f; } else { /* this evaluates the expression using Python, and returns its result: - * - on errors it reports, then returns 0.0f + * - on errors it reports, then returns 0.0f */ - driver->curval= BPY_driver_exec(driver, evaltime); + driver->curval = BPY_driver_exec(driver, evaltime); } #else /* WITH_PYTHON*/ - (void)evaltime; + (void)evaltime; #endif /* WITH_PYTHON*/ } - break; + break; default: { /* special 'hack' - just use stored value * This is currently used as the mechanism which allows animated settings to be able - * to be changed via the UI. + * to be changed via the UI. */ } } @@ -1691,127 +1691,127 @@ void correct_bezpart(float v1[2], float v2[2], float v3[2], float v4[2]) float h1[2], h2[2], len1, len2, len, fac; /* calculate handle deltas */ - h1[0]= v1[0] - v2[0]; - h1[1]= v1[1] - v2[1]; + h1[0] = v1[0] - v2[0]; + h1[1] = v1[1] - v2[1]; - h2[0]= v4[0] - v3[0]; - h2[1]= v4[1] - v3[1]; + h2[0] = v4[0] - v3[0]; + h2[1] = v4[1] - v3[1]; /* calculate distances: - * - len = span of time between keyframes + * - len = span of time between keyframes * - len1 = length of handle of start key - * - len2 = length of handle of end key + * - len2 = length of handle of end key */ - len= v4[0]- v1[0]; - len1= fabsf(h1[0]); - len2= fabsf(h2[0]); + len = v4[0] - v1[0]; + len1 = fabsf(h1[0]); + len2 = fabsf(h2[0]); /* if the handles have no length, no need to do any corrections */ - if ((len1+len2) == 0.0f) + if ((len1 + len2) == 0.0f) return; /* the two handles cross over each other, so force them * apart using the proportion they overlap */ - if ((len1+len2) > len) { - fac= len / (len1+len2); + if ((len1 + len2) > len) { + fac = len / (len1 + len2); - v2[0]= (v1[0] - fac*h1[0]); - v2[1]= (v1[1] - fac*h1[1]); + v2[0] = (v1[0] - fac * h1[0]); + v2[1] = (v1[1] - fac * h1[1]); - v3[0]= (v4[0] - fac*h2[0]); - v3[1]= (v4[1] - fac*h2[1]); + v3[0] = (v4[0] - fac * h2[0]); + v3[1] = (v4[1] - fac * h2[1]); } } /* find root ('zero') */ -static int findzero (float x, float q0, float q1, float q2, float q3, float *o) +static int findzero(float x, float q0, float q1, float q2, float q3, float *o) { double c0, c1, c2, c3, a, b, c, p, q, d, t, phi; - int nr= 0; + int nr = 0; - c0= q0 - x; - c1= 3.0f * (q1 - q0); - c2= 3.0f * (q0 - 2.0f*q1 + q2); - c3= q3 - q0 + 3.0f * (q1 - q2); + c0 = q0 - x; + c1 = 3.0f * (q1 - q0); + c2 = 3.0f * (q0 - 2.0f * q1 + q2); + c3 = q3 - q0 + 3.0f * (q1 - q2); if (c3 != 0.0) { - a= c2/c3; - b= c1/c3; - c= c0/c3; - a= a/3; - - p= b/3 - a*a; - q= (2*a*a*a - a*b + c) / 2; - d= q*q + p*p*p; + a = c2 / c3; + b = c1 / c3; + c = c0 / c3; + a = a / 3; + + p = b / 3 - a * a; + q = (2 * a * a * a - a * b + c) / 2; + d = q * q + p * p * p; if (d > 0.0) { - t= sqrt(d); - o[0]= (float)(sqrt3d(-q+t) + sqrt3d(-q-t) - a); + t = sqrt(d); + o[0] = (float)(sqrt3d(-q + t) + sqrt3d(-q - t) - a); if ((o[0] >= (float)SMALL) && (o[0] <= 1.000001f)) return 1; else return 0; } else if (d == 0.0) { - t= sqrt3d(-q); - o[0]= (float)(2*t - a); + t = sqrt3d(-q); + o[0] = (float)(2 * t - a); if ((o[0] >= (float)SMALL) && (o[0] <= 1.000001f)) nr++; - o[nr]= (float)(-t-a); + o[nr] = (float)(-t - a); - if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) return nr+1; + if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) return nr + 1; else return nr; } else { - phi= acos(-q / sqrt(-(p*p*p))); - t= sqrt(-p); - p= cos(phi/3); - q= sqrt(3 - 3*p*p); - o[0]= (float)(2*t*p - a); + phi = acos(-q / sqrt(-(p * p * p))); + t = sqrt(-p); + p = cos(phi / 3); + q = sqrt(3 - 3 * p * p); + o[0] = (float)(2 * t * p - a); if ((o[0] >= (float)SMALL) && (o[0] <= 1.000001f)) nr++; - o[nr]= (float)(-t * (p + q) - a); + o[nr] = (float)(-t * (p + q) - a); if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) nr++; - o[nr]= (float)(-t * (p - q) - a); + o[nr] = (float)(-t * (p - q) - a); - if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) return nr+1; + if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) return nr + 1; else return nr; } } else { - a=c2; - b=c1; - c=c0; + a = c2; + b = c1; + c = c0; if (a != 0.0) { // discriminant - p= b*b - 4*a*c; + p = b * b - 4 * a * c; if (p > 0) { - p= sqrt(p); - o[0]= (float)((-b-p) / (2 * a)); + p = sqrt(p); + o[0] = (float)((-b - p) / (2 * a)); if ((o[0] >= (float)SMALL) && (o[0] <= 1.000001f)) nr++; - o[nr]= (float)((-b+p)/(2*a)); + o[nr] = (float)((-b + p) / (2 * a)); - if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) return nr+1; + if ((o[nr] >= (float)SMALL) && (o[nr] <= 1.000001f)) return nr + 1; else return nr; } else if (p == 0) { - o[0]= (float)(-b / (2 * a)); + o[0] = (float)(-b / (2 * a)); if ((o[0] >= (float)SMALL) && (o[0] <= 1.000001f)) return 1; else return 0; } } else if (b != 0.0) { - o[0]= (float)(-c/b); + o[0] = (float)(-c / b); if ((o[0] >= (float)SMALL) && (o[0] <= 1.000001f)) return 1; else return 0; } else if (c == 0.0) { - o[0]= 0.0; + o[0] = 0.0; return 1; } @@ -1819,36 +1819,36 @@ static int findzero (float x, float q0, float q1, float q2, float q3, float *o) } } -static void berekeny (float f1, float f2, float f3, float f4, float *o, int b) +static void berekeny(float f1, float f2, float f3, float f4, float *o, int b) { float t, c0, c1, c2, c3; int a; - c0= f1; - c1= 3.0f * (f2 - f1); - c2= 3.0f * (f1 - 2.0f*f2 + f3); - c3= f4 - f1 + 3.0f * (f2 - f3); - - for (a=0; a < b; a++) { - t= o[a]; - o[a]= c0 + t*c1 + t*t*c2 + t*t*t*c3; + c0 = f1; + c1 = 3.0f * (f2 - f1); + c2 = 3.0f * (f1 - 2.0f * f2 + f3); + c3 = f4 - f1 + 3.0f * (f2 - f3); + + for (a = 0; a < b; a++) { + t = o[a]; + o[a] = c0 + t * c1 + t * t * c2 + t * t * t * c3; } } #if 0 -static void berekenx (float *f, float *o, int b) +static void berekenx(float *f, float *o, int b) { float t, c0, c1, c2, c3; int a; - c0= f[0]; - c1= 3.0f * (f[3] - f[0]); - c2= 3.0f * (f[0] - 2.0f*f[3] + f[6]); - c3= f[9] - f[0] + 3.0f * (f[3] - f[6]); - - for (a=0; a < b; a++) { - t= o[a]; - o[a]= c0 + t*c1 + t*t*c2 + t*t*t*c3; + c0 = f[0]; + c1 = 3.0f * (f[3] - f[0]); + c2 = 3.0f * (f[0] - 2.0f * f[3] + f[6]); + c3 = f[9] - f[0] + 3.0f * (f[3] - f[6]); + + for (a = 0; a < b; a++) { + t = o[a]; + o[a] = c0 + t * c1 + t * t * c2 + t * t * t * c3; } } #endif @@ -1857,7 +1857,7 @@ static void berekenx (float *f, float *o, int b) /* -------------------------- */ /* Calculate F-Curve value for 'evaltime' using BezTriple keyframes */ -static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltime) +static float fcurve_eval_keyframes(FCurve *fcu, BezTriple *bezts, float evaltime) { BezTriple *bezt, *prevbezt, *lastbezt; float v1[2], v2[2], v3[2], v4[2], opl[32], dx, fac; @@ -1866,37 +1866,37 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim float cvalue = 0.0f; /* get pointers */ - a= fcu->totvert-1; - prevbezt= bezts; - bezt= prevbezt+1; - lastbezt= prevbezt + a; + a = fcu->totvert - 1; + prevbezt = bezts; + bezt = prevbezt + 1; + lastbezt = prevbezt + a; /* evaluation time at or past endpoints? */ if (prevbezt->vec[1][0] >= evaltime) { /* before or on first keyframe */ if ( (fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (prevbezt->ipo != BEZT_IPO_CONST) && - !(fcu->flag & FCURVE_DISCRETE_VALUES) ) + !(fcu->flag & FCURVE_DISCRETE_VALUES) ) { /* linear or bezier interpolation */ - if (prevbezt->ipo==BEZT_IPO_LIN) { + if (prevbezt->ipo == BEZT_IPO_LIN) { /* Use the next center point instead of our own handle for * linear interpolated extrapolate */ if (fcu->totvert == 1) { - cvalue= prevbezt->vec[1][1]; + cvalue = prevbezt->vec[1][1]; } else { - bezt = prevbezt+1; - dx= prevbezt->vec[1][0] - evaltime; - fac= bezt->vec[1][0] - prevbezt->vec[1][0]; + bezt = prevbezt + 1; + dx = prevbezt->vec[1][0] - evaltime; + fac = bezt->vec[1][0] - prevbezt->vec[1][0]; /* prevent division by zero */ if (fac) { - fac= (bezt->vec[1][1] - prevbezt->vec[1][1]) / fac; - cvalue= prevbezt->vec[1][1] - (fac * dx); + fac = (bezt->vec[1][1] - prevbezt->vec[1][1]) / fac; + cvalue = prevbezt->vec[1][1] - (fac * dx); } else { - cvalue= prevbezt->vec[1][1]; + cvalue = prevbezt->vec[1][1]; } } } @@ -1904,16 +1904,16 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim /* Use the first handle (earlier) of first BezTriple to calculate the * gradient and thus the value of the curve at evaltime */ - dx= prevbezt->vec[1][0] - evaltime; - fac= prevbezt->vec[1][0] - prevbezt->vec[0][0]; + dx = prevbezt->vec[1][0] - evaltime; + fac = prevbezt->vec[1][0] - prevbezt->vec[0][0]; /* prevent division by zero */ if (fac) { - fac= (prevbezt->vec[1][1] - prevbezt->vec[0][1]) / fac; - cvalue= prevbezt->vec[1][1] - (fac * dx); + fac = (prevbezt->vec[1][1] - prevbezt->vec[0][1]) / fac; + cvalue = prevbezt->vec[1][1] - (fac * dx); } else { - cvalue= prevbezt->vec[1][1]; + cvalue = prevbezt->vec[1][1]; } } } @@ -1921,34 +1921,34 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, * so just extend first keyframe's value */ - cvalue= prevbezt->vec[1][1]; + cvalue = prevbezt->vec[1][1]; } } else if (lastbezt->vec[1][0] <= evaltime) { /* after or on last keyframe */ if ( (fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (lastbezt->ipo != BEZT_IPO_CONST) && - !(fcu->flag & FCURVE_DISCRETE_VALUES) ) + !(fcu->flag & FCURVE_DISCRETE_VALUES) ) { /* linear or bezier interpolation */ - if (lastbezt->ipo==BEZT_IPO_LIN) { + if (lastbezt->ipo == BEZT_IPO_LIN) { /* Use the next center point instead of our own handle for * linear interpolated extrapolate */ if (fcu->totvert == 1) { - cvalue= lastbezt->vec[1][1]; + cvalue = lastbezt->vec[1][1]; } else { prevbezt = lastbezt - 1; - dx= evaltime - lastbezt->vec[1][0]; - fac= lastbezt->vec[1][0] - prevbezt->vec[1][0]; + dx = evaltime - lastbezt->vec[1][0]; + fac = lastbezt->vec[1][0] - prevbezt->vec[1][0]; /* prevent division by zero */ if (fac) { - fac= (lastbezt->vec[1][1] - prevbezt->vec[1][1]) / fac; - cvalue= lastbezt->vec[1][1] + (fac * dx); + fac = (lastbezt->vec[1][1] - prevbezt->vec[1][1]) / fac; + cvalue = lastbezt->vec[1][1] + (fac * dx); } else { - cvalue= lastbezt->vec[1][1]; + cvalue = lastbezt->vec[1][1]; } } } @@ -1956,16 +1956,16 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim /* Use the gradient of the second handle (later) of last BezTriple to calculate the * gradient and thus the value of the curve at evaltime */ - dx= evaltime - lastbezt->vec[1][0]; - fac= lastbezt->vec[2][0] - lastbezt->vec[1][0]; + dx = evaltime - lastbezt->vec[1][0]; + fac = lastbezt->vec[2][0] - lastbezt->vec[1][0]; /* prevent division by zero */ if (fac) { - fac= (lastbezt->vec[2][1] - lastbezt->vec[1][1]) / fac; - cvalue= lastbezt->vec[1][1] + (fac * dx); + fac = (lastbezt->vec[2][1] - lastbezt->vec[1][1]) / fac; + cvalue = lastbezt->vec[1][1] + (fac * dx); } else { - cvalue= lastbezt->vec[1][1]; + cvalue = lastbezt->vec[1][1]; } } } @@ -1973,57 +1973,57 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, * so just extend last keyframe's value */ - cvalue= lastbezt->vec[1][1]; + cvalue = lastbezt->vec[1][1]; } } else { /* evaltime occurs somewhere in the middle of the curve */ - for (a=0; prevbezt && bezt && (a < fcu->totvert-1); a++, prevbezt=bezt, bezt++) { + for (a = 0; prevbezt && bezt && (a < fcu->totvert - 1); a++, prevbezt = bezt, bezt++) { /* use if the key is directly on the frame, rare cases this is needed else we get 0.0 instead. */ if (fabsf(bezt->vec[1][0] - evaltime) < SMALL_NUMBER) { - cvalue= bezt->vec[1][1]; + cvalue = bezt->vec[1][1]; } /* evaltime occurs within the interval defined by these two keyframes */ else if ((prevbezt->vec[1][0] <= evaltime) && (bezt->vec[1][0] >= evaltime)) { /* value depends on interpolation mode */ if ((prevbezt->ipo == BEZT_IPO_CONST) || (fcu->flag & FCURVE_DISCRETE_VALUES)) { /* constant (evaltime not relevant, so no interpolation needed) */ - cvalue= prevbezt->vec[1][1]; + cvalue = prevbezt->vec[1][1]; } else if (prevbezt->ipo == BEZT_IPO_LIN) { /* linear - interpolate between values of the two keyframes */ - fac= bezt->vec[1][0] - prevbezt->vec[1][0]; + fac = bezt->vec[1][0] - prevbezt->vec[1][0]; /* prevent division by zero */ if (fac) { - fac= (evaltime - prevbezt->vec[1][0]) / fac; - cvalue= prevbezt->vec[1][1] + (fac * (bezt->vec[1][1] - prevbezt->vec[1][1])); + fac = (evaltime - prevbezt->vec[1][0]) / fac; + cvalue = prevbezt->vec[1][1] + (fac * (bezt->vec[1][1] - prevbezt->vec[1][1])); } else { - cvalue= prevbezt->vec[1][1]; + cvalue = prevbezt->vec[1][1]; } } else { /* bezier interpolation */ - /* v1,v2 are the first keyframe and its 2nd handle */ - v1[0]= prevbezt->vec[1][0]; - v1[1]= prevbezt->vec[1][1]; - v2[0]= prevbezt->vec[2][0]; - v2[1]= prevbezt->vec[2][1]; - /* v3,v4 are the last keyframe's 1st handle + the last keyframe */ - v3[0]= bezt->vec[0][0]; - v3[1]= bezt->vec[0][1]; - v4[0]= bezt->vec[1][0]; - v4[1]= bezt->vec[1][1]; + /* v1,v2 are the first keyframe and its 2nd handle */ + v1[0] = prevbezt->vec[1][0]; + v1[1] = prevbezt->vec[1][1]; + v2[0] = prevbezt->vec[2][0]; + v2[1] = prevbezt->vec[2][1]; + /* v3,v4 are the last keyframe's 1st handle + the last keyframe */ + v3[0] = bezt->vec[0][0]; + v3[1] = bezt->vec[0][1]; + v4[0] = bezt->vec[1][0]; + v4[1] = bezt->vec[1][1]; /* adjust handles so that they don't overlap (forming a loop) */ correct_bezpart(v1, v2, v3, v4); /* try to get a value for this position - if failure, try another set of points */ - b= findzero(evaltime, v1[0], v2[0], v3[0], v4[0], opl); + b = findzero(evaltime, v1[0], v2[0], v3[0], v4[0], opl); if (b) { berekeny(v1[1], v2[1], v3[1], v4[1], opl, 1); - cvalue= opl[0]; + cvalue = opl[0]; break; } } @@ -2036,35 +2036,35 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim } /* Calculate F-Curve value for 'evaltime' using FPoint samples */ -static float fcurve_eval_samples (FCurve *fcu, FPoint *fpts, float evaltime) +static float fcurve_eval_samples(FCurve *fcu, FPoint *fpts, float evaltime) { FPoint *prevfpt, *lastfpt, *fpt; - float cvalue= 0.0f; + float cvalue = 0.0f; /* get pointers */ - prevfpt= fpts; - lastfpt= prevfpt + fcu->totvert-1; + prevfpt = fpts; + lastfpt = prevfpt + fcu->totvert - 1; /* evaluation time at or past endpoints? */ if (prevfpt->vec[0] >= evaltime) { /* before or on first sample, so just extend value */ - cvalue= prevfpt->vec[1]; + cvalue = prevfpt->vec[1]; } else if (lastfpt->vec[0] <= evaltime) { /* after or on last sample, so just extend value */ - cvalue= lastfpt->vec[1]; + cvalue = lastfpt->vec[1]; } else { - float t= (float)abs(evaltime - (int)evaltime); + float t = (float)abs(evaltime - (int)evaltime); /* find the one on the right frame (assume that these are spaced on 1-frame intervals) */ - fpt= prevfpt + (int)(evaltime - prevfpt->vec[0]); + fpt = prevfpt + (int)(evaltime - prevfpt->vec[0]); /* if not exactly on the frame, perform linear interpolation with the next one */ if (t != 0.0f) - cvalue= interpf(fpt->vec[1], (fpt+1)->vec[1], t); + cvalue = interpf(fpt->vec[1], (fpt + 1)->vec[1], t); else - cvalue= fpt->vec[1]; + cvalue = fpt->vec[1]; } /* return value */ @@ -2078,7 +2078,7 @@ static float fcurve_eval_samples (FCurve *fcu, FPoint *fpts, float evaltime) */ float evaluate_fcurve(FCurve *fcu, float evaltime) { - float cvalue= 0.0f; + float cvalue = 0.0f; float devaltime; /* if there is a driver (only if this F-Curve is acting as 'driver'), evaluate it to find value to use as "evaltime" @@ -2087,20 +2087,20 @@ float evaluate_fcurve(FCurve *fcu, float evaltime) */ if (fcu->driver) { /* evaltime now serves as input for the curve */ - evaltime= cvalue= evaluate_driver(fcu->driver, evaltime); + evaltime = cvalue = evaluate_driver(fcu->driver, evaltime); } /* evaluate modifiers which modify time to evaluate the base curve at */ - devaltime= evaluate_time_fmodifiers(&fcu->modifiers, fcu, cvalue, evaltime); + devaltime = evaluate_time_fmodifiers(&fcu->modifiers, fcu, cvalue, evaltime); /* evaluate curve-data * - 'devaltime' instead of 'evaltime', as this is the time that the last time-modifying * F-Curve modifier on the stack requested the curve to be evaluated at */ if (fcu->bezt) - cvalue= fcurve_eval_keyframes(fcu, fcu->bezt, devaltime); + cvalue = fcurve_eval_keyframes(fcu, fcu->bezt, devaltime); else if (fcu->fpt) - cvalue= fcurve_eval_samples(fcu, fcu->fpt, devaltime); + cvalue = fcurve_eval_samples(fcu, fcu->fpt, devaltime); /* evaluate modifiers */ evaluate_value_fmodifiers(&fcu->modifiers, fcu, &cvalue, evaltime); @@ -2109,7 +2109,7 @@ float evaluate_fcurve(FCurve *fcu, float evaltime) * here so that the curve can be sampled correctly */ if (fcu->flag & FCURVE_INT_VALUES) - cvalue= floorf(cvalue + 0.5f); + cvalue = floorf(cvalue + 0.5f); /* return evaluated value */ return cvalue; @@ -2125,7 +2125,7 @@ void calculate_fcurve(FCurve *fcu, float ctime) list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE)) { /* calculate and set curval (evaluates driver too if necessary) */ - fcu->curval= evaluate_fcurve(fcu, ctime); + fcu->curval = evaluate_fcurve(fcu, ctime); } } diff --git a/source/blender/blenkernel/intern/fmodifier.c b/source/blender/blenkernel/intern/fmodifier.c index 92c73b23239..59c8a529d85 100644 --- a/source/blender/blenkernel/intern/fmodifier.c +++ b/source/blender/blenkernel/intern/fmodifier.c @@ -68,14 +68,14 @@ */ /* Template for type-info data: - * - make a copy of this when creating new modifiers, and just change the functions - * pointed to as necessary - * - although the naming of functions doesn't matter, it would help for code - * readability, to follow the same naming convention as is presented here - * - any functions that a constraint doesn't need to define, don't define - * for such cases, just use NULL - * - these should be defined after all the functions have been defined, so that - * forward-definitions/prototypes don't need to be used! + * - make a copy of this when creating new modifiers, and just change the functions + * pointed to as necessary + * - although the naming of functions doesn't matter, it would help for code + * readability, to follow the same naming convention as is presented here + * - any functions that a constraint doesn't need to define, don't define + * for such cases, just use NULL + * - these should be defined after all the functions have been defined, so that + * forward-definitions/prototypes don't need to be used! * - keep this copy #if-def'd so that future constraints can get based off this */ #if 0 @@ -99,74 +99,74 @@ static FModifierTypeInfo FMI_MODNAME = { /* Generator F-Curve Modifier --------------------------- */ /* Generators available: - * 1) simple polynomial generator: + * 1) simple polynomial generator: * - Exanded form - (y = C[0]*(x^(n)) + C[1]*(x^(n-1)) + ... + C[n]) * - Factorized form - (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1])) */ -static void fcm_generator_free (FModifier *fcm) +static void fcm_generator_free(FModifier *fcm) { - FMod_Generator *data= (FMod_Generator *)fcm->data; + FMod_Generator *data = (FMod_Generator *)fcm->data; /* free polynomial coefficients array */ if (data->coefficients) MEM_freeN(data->coefficients); } -static void fcm_generator_copy (FModifier *fcm, FModifier *src) +static void fcm_generator_copy(FModifier *fcm, FModifier *src) { - FMod_Generator *gen= (FMod_Generator *)fcm->data; - FMod_Generator *ogen= (FMod_Generator *)src->data; + FMod_Generator *gen = (FMod_Generator *)fcm->data; + FMod_Generator *ogen = (FMod_Generator *)src->data; /* copy coefficients array? */ if (ogen->coefficients) - gen->coefficients= MEM_dupallocN(ogen->coefficients); + gen->coefficients = MEM_dupallocN(ogen->coefficients); } -static void fcm_generator_new_data (void *mdata) +static void fcm_generator_new_data(void *mdata) { - FMod_Generator *data= (FMod_Generator *)mdata; + FMod_Generator *data = (FMod_Generator *)mdata; float *cp; /* set default generator to be linear 0-1 (gradient = 1, y-offset = 0) */ - data->poly_order= 1; - data->arraysize= 2; - cp= data->coefficients= MEM_callocN(sizeof(float)*2, "FMod_Generator_Coefs"); + data->poly_order = 1; + data->arraysize = 2; + cp = data->coefficients = MEM_callocN(sizeof(float) * 2, "FMod_Generator_Coefs"); cp[0] = 0; // y-offset cp[1] = 1; // gradient } -static void fcm_generator_verify (FModifier *fcm) +static void fcm_generator_verify(FModifier *fcm) { - FMod_Generator *data= (FMod_Generator *)fcm->data; + FMod_Generator *data = (FMod_Generator *)fcm->data; /* requirements depend on mode */ switch (data->mode) { case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */ { /* arraysize needs to be order+1, so resize if not */ - if (data->arraysize != (data->poly_order+1)) { + if (data->arraysize != (data->poly_order + 1)) { float *nc; /* make new coefficients array, and copy over as much data as can fit */ - nc= MEM_callocN(sizeof(float)*(data->poly_order+1), "FMod_Generator_Coefs"); + nc = MEM_callocN(sizeof(float) * (data->poly_order + 1), "FMod_Generator_Coefs"); if (data->coefficients) { - if ((int)data->arraysize > (data->poly_order+1)) - memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order+1)); + if ((int)data->arraysize > (data->poly_order + 1)) + memcpy(nc, data->coefficients, sizeof(float) * (data->poly_order + 1)); else - memcpy(nc, data->coefficients, sizeof(float)*data->arraysize); + memcpy(nc, data->coefficients, sizeof(float) * data->arraysize); /* free the old data */ MEM_freeN(data->coefficients); } /* set the new data */ - data->coefficients= nc; - data->arraysize= data->poly_order+1; + data->coefficients = nc; + data->arraysize = data->poly_order + 1; } } - break; + break; case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */ { @@ -175,30 +175,30 @@ static void fcm_generator_verify (FModifier *fcm) float *nc; /* make new coefficients array, and copy over as much data as can fit */ - nc= MEM_callocN(sizeof(float)*(data->poly_order*2), "FMod_Generator_Coefs"); + nc = MEM_callocN(sizeof(float) * (data->poly_order * 2), "FMod_Generator_Coefs"); if (data->coefficients) { if (data->arraysize > (unsigned int)(data->poly_order * 2)) - memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order * 2)); + memcpy(nc, data->coefficients, sizeof(float) * (data->poly_order * 2)); else - memcpy(nc, data->coefficients, sizeof(float)*data->arraysize); + memcpy(nc, data->coefficients, sizeof(float) * data->arraysize); /* free the old data */ MEM_freeN(data->coefficients); } /* set the new data */ - data->coefficients= nc; - data->arraysize= data->poly_order * 2; + data->coefficients = nc; + data->arraysize = data->poly_order * 2; } } - break; + break; } } -static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) +static void fcm_generator_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) { - FMod_Generator *data= (FMod_Generator *)fcm->data; + FMod_Generator *data = (FMod_Generator *)fcm->data; /* behavior depends on mode * NOTE: the data in its default state is fine too @@ -207,23 +207,23 @@ static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float * case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */ { /* we overwrite cvalue with the sum of the polynomial */ - float *powers = MEM_callocN(sizeof(float)*data->arraysize, "Poly Powers"); - float value= 0.0f; + float *powers = MEM_callocN(sizeof(float) * data->arraysize, "Poly Powers"); + float value = 0.0f; unsigned int i; /* for each x^n, precalculate value based on previous one first... this should be * faster that calling pow() for each entry */ - for (i=0; i < data->arraysize; i++) { + for (i = 0; i < data->arraysize; i++) { /* first entry is x^0 = 1, otherwise, calculate based on previous */ if (i) - powers[i]= powers[i-1] * evaltime; + powers[i] = powers[i - 1] * evaltime; else - powers[0]= 1; + powers[0] = 1; } /* for each coefficient, add to value, which we'll write to *cvalue in one go */ - for (i=0; i < data->arraysize; i++) + for (i = 0; i < data->arraysize; i++) value += data->coefficients[i] * powers[i]; /* only if something changed, write *cvalue in one go */ @@ -231,33 +231,33 @@ static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float * if (data->flag & FCM_GENERATOR_ADDITIVE) *cvalue += value; else - *cvalue= value; + *cvalue = value; } /* cleanup */ if (powers) MEM_freeN(powers); } - break; + break; case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* Factorized polynomial */ { - float value= 1.0f, *cp=NULL; + float value = 1.0f, *cp = NULL; unsigned int i; /* for each coefficient pair, solve for that bracket before accumulating in value by multiplying */ - for (cp=data->coefficients, i=0; (cp) && (i < (unsigned int)data->poly_order); cp+=2, i++) - value *= (cp[0]*evaltime + cp[1]); + for (cp = data->coefficients, i = 0; (cp) && (i < (unsigned int)data->poly_order); cp += 2, i++) + value *= (cp[0] * evaltime + cp[1]); /* only if something changed, write *cvalue in one go */ if (data->poly_order) { if (data->flag & FCM_GENERATOR_ADDITIVE) *cvalue += value; else - *cvalue= value; + *cvalue = value; } } - break; + break; } } @@ -279,7 +279,7 @@ static FModifierTypeInfo FMI_GENERATOR = { /* Built-In Function Generator F-Curve Modifier --------------------------- */ /* This uses the general equation for equations: - * y = amplitude * fn(phase_multiplier*x + phase_offset) + y_offset + * y = amplitude * fn(phase_multiplier*x + phase_offset) + y_offset * * where amplitude, phase_multiplier/offset, y_offset are user-defined coefficients, * x is the evaluation 'time', and 'y' is the resultant value @@ -288,20 +288,20 @@ static FModifierTypeInfo FMI_GENERATOR = { * sin, cos, tan, sinc (normalised sin), natural log, square root */ -static void fcm_fn_generator_new_data (void *mdata) +static void fcm_fn_generator_new_data(void *mdata) { - FMod_FunctionGenerator *data= (FMod_FunctionGenerator *)mdata; + FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)mdata; /* set amplitude and phase multiplier to 1.0f so that something is generated */ - data->amplitude= 1.0f; - data->phase_multiplier= 1.0f; + data->amplitude = 1.0f; + data->phase_multiplier = 1.0f; } /* Unary 'normalised sine' function - * y = sin(PI + x) / (PI * x), + * y = sin(PI + x) / (PI * x), * except for x = 0 when y = 1. */ -static double sinc (double x) +static double sinc(double x) { if (fabs(x) < 0.0001) return 1.0; @@ -309,10 +309,10 @@ static double sinc (double x) return sin(M_PI * x) / (M_PI * x); } -static void fcm_fn_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) +static void fcm_fn_generator_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) { - FMod_FunctionGenerator *data= (FMod_FunctionGenerator *)fcm->data; - double arg= data->phase_multiplier*evaltime + data->phase_offset; + FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)fcm->data; + double arg = data->phase_multiplier * evaltime + data->phase_offset; double (*fn)(double v) = NULL; /* get function pointer to the func to use: @@ -321,13 +321,13 @@ static void fcm_fn_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, floa switch (data->type) { /* simple ones */ case FCM_GENERATOR_FN_SIN: /* sine wave */ - fn= sin; + fn = sin; break; case FCM_GENERATOR_FN_COS: /* cosine wave */ - fn= cos; + fn = cos; break; case FCM_GENERATOR_FN_SINC: /* normalised sine wave */ - fn= sinc; + fn = sinc; break; /* validation required */ @@ -336,36 +336,36 @@ static void fcm_fn_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, floa /* check that argument is not on one of the discontinuities (i.e. 90deg, 270 deg, etc) */ if (IS_EQ(fmod((arg - M_PI_2), M_PI), 0.0)) { if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) - *cvalue = 0.0f; /* no value possible here */ + *cvalue = 0.0f; /* no value possible here */ } else - fn= tan; + fn = tan; } - break; + break; case FCM_GENERATOR_FN_LN: /* natural log */ { /* check that value is greater than 1? */ if (arg > 1.0) { - fn= log; + fn = log; } else { if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) - *cvalue = 0.0f; /* no value possible here */ + *cvalue = 0.0f; /* no value possible here */ } } - break; + break; case FCM_GENERATOR_FN_SQRT: /* square root */ { /* no negative numbers */ if (arg > 0.0) { - fn= sqrt; + fn = sqrt; } else { if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) - *cvalue = 0.0f; /* no value possible here */ + *cvalue = 0.0f; /* no value possible here */ } } - break; + break; default: printf("Invalid Function-Generator for F-Modifier - %d\n", data->type); @@ -373,12 +373,12 @@ static void fcm_fn_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, floa /* execute function callback to set value if appropriate */ if (fn) { - float value= (float)(data->amplitude*(float)fn(arg) + data->value_offset); + float value = (float)(data->amplitude * (float)fn(arg) + data->value_offset); if (data->flag & FCM_GENERATOR_ADDITIVE) *cvalue += value; else - *cvalue= value; + *cvalue = value; } } @@ -399,37 +399,37 @@ static FModifierTypeInfo FMI_FN_GENERATOR = { /* Envelope F-Curve Modifier --------------------------- */ -static void fcm_envelope_free (FModifier *fcm) +static void fcm_envelope_free(FModifier *fcm) { - FMod_Envelope *env= (FMod_Envelope *)fcm->data; + FMod_Envelope *env = (FMod_Envelope *)fcm->data; /* free envelope data array */ if (env->data) MEM_freeN(env->data); } -static void fcm_envelope_copy (FModifier *fcm, FModifier *src) +static void fcm_envelope_copy(FModifier *fcm, FModifier *src) { - FMod_Envelope *env= (FMod_Envelope *)fcm->data; - FMod_Envelope *oenv= (FMod_Envelope *)src->data; + FMod_Envelope *env = (FMod_Envelope *)fcm->data; + FMod_Envelope *oenv = (FMod_Envelope *)src->data; /* copy envelope data array */ if (oenv->data) - env->data= MEM_dupallocN(oenv->data); + env->data = MEM_dupallocN(oenv->data); } -static void fcm_envelope_new_data (void *mdata) +static void fcm_envelope_new_data(void *mdata) { - FMod_Envelope *env= (FMod_Envelope *)mdata; + FMod_Envelope *env = (FMod_Envelope *)mdata; /* set default min/max ranges */ - env->min= -1.0f; - env->max= 1.0f; + env->min = -1.0f; + env->max = 1.0f; } -static void fcm_envelope_verify (FModifier *fcm) +static void fcm_envelope_verify(FModifier *fcm) { - FMod_Envelope *env= (FMod_Envelope *)fcm->data; + FMod_Envelope *env = (FMod_Envelope *)fcm->data; /* if the are points, perform bubble-sort on them, as user may have changed the order */ if (env->data) { @@ -437,44 +437,44 @@ static void fcm_envelope_verify (FModifier *fcm) } } -static void fcm_envelope_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) +static void fcm_envelope_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) { - FMod_Envelope *env= (FMod_Envelope *)fcm->data; + FMod_Envelope *env = (FMod_Envelope *)fcm->data; FCM_EnvelopeData *fed, *prevfed, *lastfed; - float min=0.0f, max=0.0f, fac=0.0f; + float min = 0.0f, max = 0.0f, fac = 0.0f; int a; /* get pointers */ if (env->data == NULL) return; - prevfed= env->data; - fed= prevfed + 1; - lastfed= prevfed + (env->totvert-1); + prevfed = env->data; + fed = prevfed + 1; + lastfed = prevfed + (env->totvert - 1); /* get min/max values for envelope at evaluation time (relative to mid-value) */ if (prevfed->time >= evaltime) { /* before or on first sample, so just extend value */ - min= prevfed->min; - max= prevfed->max; + min = prevfed->min; + max = prevfed->max; } else if (lastfed->time <= evaltime) { /* after or on last sample, so just extend value */ - min= lastfed->min; - max= lastfed->max; + min = lastfed->min; + max = lastfed->max; } else { /* evaltime occurs somewhere between segments */ // TODO: implement binary search for this to make it faster? - for (a=0; prevfed && fed && (a < env->totvert-1); a++, prevfed=fed, fed++) { + for (a = 0; prevfed && fed && (a < env->totvert - 1); a++, prevfed = fed, fed++) { /* evaltime occurs within the interval defined by these two envelope points */ if ((prevfed->time <= evaltime) && (fed->time >= evaltime)) { float afac, bfac, diff; - diff= fed->time - prevfed->time; - afac= (evaltime - prevfed->time) / diff; - bfac= (fed->time - evaltime) / diff; + diff = fed->time - prevfed->time; + afac = (evaltime - prevfed->time) / diff; + bfac = (fed->time - evaltime) / diff; - min= bfac*prevfed->min + afac*fed->min; - max= bfac*prevfed->max + afac*fed->max; + min = bfac * prevfed->min + afac * fed->min; + max = bfac * prevfed->max + afac * fed->max; break; } @@ -485,8 +485,8 @@ static void fcm_envelope_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *c * - fac is the ratio of how the current y-value corresponds to the reference range * - thus, the new value is found by mapping the old range to the new! */ - fac= (*cvalue - (env->midval + env->min)) / (env->max - env->min); - *cvalue= min + fac*(max - min); + fac = (*cvalue - (env->midval + env->min)) / (env->max - env->min); + *cvalue = min + fac * (max - min); } static FModifierTypeInfo FMI_ENVELOPE = { @@ -520,23 +520,23 @@ static FModifierTypeInfo FMI_ENVELOPE = { /* temp data used during evaluation */ typedef struct tFCMED_Cycles { - float cycyofs; /* y-offset to apply */ + float cycyofs; /* y-offset to apply */ } tFCMED_Cycles; -static void fcm_cycles_new_data (void *mdata) +static void fcm_cycles_new_data(void *mdata) { - FMod_Cycles *data= (FMod_Cycles *)mdata; + FMod_Cycles *data = (FMod_Cycles *)mdata; /* turn on cycles by default */ - data->before_mode= data->after_mode= FCM_EXTRAPOLATE_CYCLIC; + data->before_mode = data->after_mode = FCM_EXTRAPOLATE_CYCLIC; } -static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), float evaltime) +static float fcm_cycles_time(FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), float evaltime) { - FMod_Cycles *data= (FMod_Cycles *)fcm->data; - float prevkey[2], lastkey[2], cycyofs=0.0f; - short side=0, mode=0; - int cycles=0, ofs=0; + FMod_Cycles *data = (FMod_Cycles *)fcm->data; + float prevkey[2], lastkey[2], cycyofs = 0.0f; + short side = 0, mode = 0; + int cycles = 0, ofs = 0; /* check if modifier is first in stack, otherwise disable ourself... */ // FIXME... @@ -547,24 +547,24 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), /* calculate new evaltime due to cyclic interpolation */ if (fcu && fcu->bezt) { - BezTriple *prevbezt= fcu->bezt; - BezTriple *lastbezt= prevbezt + fcu->totvert-1; + BezTriple *prevbezt = fcu->bezt; + BezTriple *lastbezt = prevbezt + fcu->totvert - 1; - prevkey[0]= prevbezt->vec[1][0]; - prevkey[1]= prevbezt->vec[1][1]; + prevkey[0] = prevbezt->vec[1][0]; + prevkey[1] = prevbezt->vec[1][1]; - lastkey[0]= lastbezt->vec[1][0]; - lastkey[1]= lastbezt->vec[1][1]; + lastkey[0] = lastbezt->vec[1][0]; + lastkey[1] = lastbezt->vec[1][1]; } else if (fcu && fcu->fpt) { - FPoint *prevfpt= fcu->fpt; - FPoint *lastfpt= prevfpt + fcu->totvert-1; + FPoint *prevfpt = fcu->fpt; + FPoint *lastfpt = prevfpt + fcu->totvert - 1; - prevkey[0]= prevfpt->vec[0]; - prevkey[1]= prevfpt->vec[1]; + prevkey[0] = prevfpt->vec[0]; + prevkey[1] = prevfpt->vec[1]; - lastkey[0]= lastfpt->vec[0]; - lastkey[1]= lastfpt->vec[1]; + lastkey[0] = lastfpt->vec[0]; + lastkey[1] = lastfpt->vec[1]; } else return evaltime; @@ -575,18 +575,18 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), */ if (evaltime < prevkey[0]) { if (data->before_mode) { - side= -1; - mode= data->before_mode; - cycles= data->before_cycles; - ofs= prevkey[0]; + side = -1; + mode = data->before_mode; + cycles = data->before_cycles; + ofs = prevkey[0]; } } else if (evaltime > lastkey[0]) { if (data->after_mode) { - side= 1; - mode= data->after_mode; - cycles= data->after_cycles; - ofs= lastkey[0]; + side = 1; + mode = data->after_mode; + cycles = data->after_cycles; + ofs = lastkey[0]; } } if ((ELEM(0, side, mode))) @@ -594,22 +594,22 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), /* find relative place within a cycle */ { - float cycdx=0, cycdy=0; - float cycle= 0, cyct=0; + float cycdx = 0, cycdy = 0; + float cycle = 0, cyct = 0; /* calculate period and amplitude (total height) of a cycle */ - cycdx= lastkey[0] - prevkey[0]; - cycdy= lastkey[1] - prevkey[1]; + cycdx = lastkey[0] - prevkey[0]; + cycdy = lastkey[1] - prevkey[1]; /* check if cycle is infinitely small, to be point of being impossible to use */ if (cycdx == 0) return evaltime; /* calculate the 'number' of the cycle */ - cycle= ((float)side * (evaltime - ofs) / cycdx); + cycle = ((float)side * (evaltime - ofs) / cycdx); /* calculate the time inside the cycle */ - cyct= fmod(evaltime - ofs, cycdx); + cyct = fmod(evaltime - ofs, cycdx); /* check that cyclic is still enabled for the specified time */ if (cycles == 0) { @@ -641,19 +641,19 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), evaltime = (side == 1 ? prevkey[0] : lastkey[0]); } /* calculate where in the cycle we are (overwrite evaltime to reflect this) */ - else if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)(cycle+1) % 2)) { + else if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)(cycle + 1) % 2)) { /* when 'mirror' option is used and cycle number is odd, this cycle is played in reverse * - for 'before' extrapolation, we need to flip in a different way, otherwise values past * then end of the curve get referenced (result of fmod will be negative, and with different phase) */ if (side < 0) - evaltime= prevkey[0] - cyct; + evaltime = prevkey[0] - cyct; else - evaltime= lastkey[0] - cyct; + evaltime = lastkey[0] - cyct; } else { /* the cycle is played normally... */ - evaltime= prevkey[0] + cyct; + evaltime = prevkey[0] + cyct; } if (evaltime < prevkey[0]) evaltime += cycdx; } @@ -663,17 +663,17 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), tFCMED_Cycles *edata; /* for now, this is just a float, but we could get more stuff... */ - fcm->edata= edata= MEM_callocN(sizeof(tFCMED_Cycles), "tFCMED_Cycles"); - edata->cycyofs= cycyofs; + fcm->edata = edata = MEM_callocN(sizeof(tFCMED_Cycles), "tFCMED_Cycles"); + edata->cycyofs = cycyofs; } /* return the new frame to evaluate */ return evaltime; } -static void fcm_cycles_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime)) +static void fcm_cycles_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime)) { - tFCMED_Cycles *edata= (tFCMED_Cycles *)fcm->edata; + tFCMED_Cycles *edata = (tFCMED_Cycles *)fcm->edata; /* use temp data */ if (edata) { @@ -682,7 +682,7 @@ static void fcm_cycles_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cva /* free temp data */ MEM_freeN(edata); - fcm->edata= NULL; + fcm->edata = NULL; } } @@ -703,21 +703,21 @@ static FModifierTypeInfo FMI_CYCLES = { /* Noise F-Curve Modifier --------------------------- */ -static void fcm_noise_new_data (void *mdata) +static void fcm_noise_new_data(void *mdata) { - FMod_Noise *data= (FMod_Noise *)mdata; + FMod_Noise *data = (FMod_Noise *)mdata; /* defaults */ - data->size= 1.0f; - data->strength= 1.0f; - data->phase= 1.0f; + data->size = 1.0f; + data->strength = 1.0f; + data->phase = 1.0f; data->depth = 0; data->modification = FCM_NOISE_MODIF_REPLACE; } -static void fcm_noise_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) +static void fcm_noise_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime) { - FMod_Noise *data= (FMod_Noise *)fcm->data; + FMod_Noise *data = (FMod_Noise *)fcm->data; float noise; /* generate noise using good ol' Blender Noise @@ -729,17 +729,17 @@ static void fcm_noise_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cval /* combine the noise with existing motion data */ switch (data->modification) { case FCM_NOISE_MODIF_ADD: - *cvalue= *cvalue + noise * data->strength; + *cvalue = *cvalue + noise * data->strength; break; case FCM_NOISE_MODIF_SUBTRACT: - *cvalue= *cvalue - noise * data->strength; + *cvalue = *cvalue - noise * data->strength; break; case FCM_NOISE_MODIF_MULTIPLY: - *cvalue= *cvalue * noise * data->strength; + *cvalue = *cvalue * noise * data->strength; break; case FCM_NOISE_MODIF_REPLACE: default: - *cvalue= *cvalue + (noise - 0.5f) * data->strength; + *cvalue = *cvalue + (noise - 0.5f) * data->strength; break; } } @@ -781,25 +781,25 @@ static FModifierTypeInfo FMI_FILTER = { /* Python F-Curve Modifier --------------------------- */ -static void fcm_python_free (FModifier *fcm) +static void fcm_python_free(FModifier *fcm) { - FMod_Python *data= (FMod_Python *)fcm->data; + FMod_Python *data = (FMod_Python *)fcm->data; /* id-properties */ IDP_FreeProperty(data->prop); MEM_freeN(data->prop); } -static void fcm_python_new_data (void *mdata) +static void fcm_python_new_data(void *mdata) { - FMod_Python *data= (FMod_Python *)mdata; + FMod_Python *data = (FMod_Python *)mdata; /* everything should be set correctly by calloc, except for the prop->type constant.*/ data->prop = MEM_callocN(sizeof(IDProperty), "PyFModifierProps"); data->prop->type = IDP_GROUP; } -static void fcm_python_copy (FModifier *fcm, FModifier *src) +static void fcm_python_copy(FModifier *fcm, FModifier *src) { FMod_Python *pymod = (FMod_Python *)fcm->data; FMod_Python *opymod = (FMod_Python *)src->data; @@ -807,7 +807,7 @@ static void fcm_python_copy (FModifier *fcm, FModifier *src) pymod->prop = IDP_CopyProperty(opymod->prop); } -static void fcm_python_evaluate (FCurve *UNUSED(fcu), FModifier *UNUSED(fcm), float *UNUSED(cvalue), float UNUSED(evaltime)) +static void fcm_python_evaluate(FCurve *UNUSED(fcu), FModifier *UNUSED(fcm), float *UNUSED(cvalue), float UNUSED(evaltime)) { #ifdef WITH_PYTHON //FMod_Python *data= (FMod_Python *)fcm->data; @@ -836,9 +836,9 @@ static FModifierTypeInfo FMI_PYTHON = { /* Limits F-Curve Modifier --------------------------- */ -static float fcm_limits_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime) +static float fcm_limits_time(FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime) { - FMod_Limits *data= (FMod_Limits *)fcm->data; + FMod_Limits *data = (FMod_Limits *)fcm->data; /* check for the time limits */ if ((data->flag & FCM_LIMIT_XMIN) && (evaltime < data->rect.xmin)) @@ -850,15 +850,15 @@ static float fcm_limits_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED( return evaltime; } -static void fcm_limits_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime)) +static void fcm_limits_evaluate(FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime)) { - FMod_Limits *data= (FMod_Limits *)fcm->data; + FMod_Limits *data = (FMod_Limits *)fcm->data; /* value limits now */ if ((data->flag & FCM_LIMIT_YMIN) && (*cvalue < data->rect.ymin)) - *cvalue= data->rect.ymin; + *cvalue = data->rect.ymin; if ((data->flag & FCM_LIMIT_YMAX) && (*cvalue > data->rect.ymax)) - *cvalue= data->rect.ymax; + *cvalue = data->rect.ymax; } static FModifierTypeInfo FMI_LIMITS = { @@ -878,18 +878,18 @@ static FModifierTypeInfo FMI_LIMITS = { /* Stepped F-Curve Modifier --------------------------- */ -static void fcm_stepped_new_data (void *mdata) +static void fcm_stepped_new_data(void *mdata) { - FMod_Stepped *data= (FMod_Stepped *)mdata; + FMod_Stepped *data = (FMod_Stepped *)mdata; /* just need to set the step-size to 2-frames by default */ // XXX: or would 5 be more normal? data->step_size = 2.0f; } -static float fcm_stepped_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime) +static float fcm_stepped_time(FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime) { - FMod_Stepped *data= (FMod_Stepped *)fcm->data; + FMod_Stepped *data = (FMod_Stepped *)fcm->data; int snapblock; /* check range clamping to see if we should alter the timing to achieve the desired results */ @@ -936,27 +936,27 @@ static FModifierTypeInfo FMI_STEPPED = { /* These globals only ever get directly accessed in this file */ static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES]; -static short FMI_INIT= 1; /* when non-zero, the list needs to be updated */ +static short FMI_INIT = 1; /* when non-zero, the list needs to be updated */ /* This function only gets called when FMI_INIT is non-zero */ -static void fmods_init_typeinfo (void) +static void fmods_init_typeinfo(void) { - fmodifiersTypeInfo[0]= NULL; /* 'Null' F-Curve Modifier */ - fmodifiersTypeInfo[1]= &FMI_GENERATOR; /* Generator F-Curve Modifier */ - fmodifiersTypeInfo[2]= &FMI_FN_GENERATOR; /* Built-In Function Generator F-Curve Modifier */ - fmodifiersTypeInfo[3]= &FMI_ENVELOPE; /* Envelope F-Curve Modifier */ - fmodifiersTypeInfo[4]= &FMI_CYCLES; /* Cycles F-Curve Modifier */ - fmodifiersTypeInfo[5]= &FMI_NOISE; /* Apply-Noise F-Curve Modifier */ - fmodifiersTypeInfo[6]= NULL/*&FMI_FILTER*/; /* Filter F-Curve Modifier */ // XXX unimplemented - fmodifiersTypeInfo[7]= &FMI_PYTHON; /* Custom Python F-Curve Modifier */ - fmodifiersTypeInfo[8]= &FMI_LIMITS; /* Limits F-Curve Modifier */ - fmodifiersTypeInfo[9]= &FMI_STEPPED; /* Stepped F-Curve Modifier */ + fmodifiersTypeInfo[0] = NULL; /* 'Null' F-Curve Modifier */ + fmodifiersTypeInfo[1] = &FMI_GENERATOR; /* Generator F-Curve Modifier */ + fmodifiersTypeInfo[2] = &FMI_FN_GENERATOR; /* Built-In Function Generator F-Curve Modifier */ + fmodifiersTypeInfo[3] = &FMI_ENVELOPE; /* Envelope F-Curve Modifier */ + fmodifiersTypeInfo[4] = &FMI_CYCLES; /* Cycles F-Curve Modifier */ + fmodifiersTypeInfo[5] = &FMI_NOISE; /* Apply-Noise F-Curve Modifier */ + fmodifiersTypeInfo[6] = NULL /*&FMI_FILTER*/; /* Filter F-Curve Modifier */ // XXX unimplemented + fmodifiersTypeInfo[7] = &FMI_PYTHON; /* Custom Python F-Curve Modifier */ + fmodifiersTypeInfo[8] = &FMI_LIMITS; /* Limits F-Curve Modifier */ + fmodifiersTypeInfo[9] = &FMI_STEPPED; /* Stepped F-Curve Modifier */ } /* This function should be used for getting the appropriate type-info when only * a F-Curve modifier type is known */ -FModifierTypeInfo *get_fmodifier_typeinfo (int type) +FModifierTypeInfo *get_fmodifier_typeinfo(int type) { /* initialize the type-info list? */ if (FMI_INIT) { @@ -966,7 +966,7 @@ FModifierTypeInfo *get_fmodifier_typeinfo (int type) /* only return for valid types */ if ( (type >= FMODIFIER_TYPE_NULL) && - (type <= FMODIFIER_NUM_TYPES ) ) + (type <= FMODIFIER_NUM_TYPES) ) { /* there shouldn't be any segfaults here... */ return fmodifiersTypeInfo[type]; @@ -981,7 +981,7 @@ FModifierTypeInfo *get_fmodifier_typeinfo (int type) /* This function should always be used to get the appropriate type-info, as it * has checks which prevent segfaults in some weird cases. */ -FModifierTypeInfo *fmodifier_get_typeinfo (FModifier *fcm) +FModifierTypeInfo *fmodifier_get_typeinfo(FModifier *fcm) { /* only return typeinfo for valid modifiers */ if (fcm) @@ -993,9 +993,9 @@ FModifierTypeInfo *fmodifier_get_typeinfo (FModifier *fcm) /* API --------------------------- */ /* Add a new F-Curve Modifier to the given F-Curve of a certain type */ -FModifier *add_fmodifier (ListBase *modifiers, int type) +FModifier *add_fmodifier(ListBase *modifiers, int type) { - FModifierTypeInfo *fmi= get_fmodifier_typeinfo(type); + FModifierTypeInfo *fmi = get_fmodifier_typeinfo(type); FModifier *fcm; /* sanity checks */ @@ -1011,7 +1011,7 @@ FModifier *add_fmodifier (ListBase *modifiers, int type) } /* add modifier itself */ - fcm= MEM_callocN(sizeof(FModifier), "F-Curve Modifier"); + fcm = MEM_callocN(sizeof(FModifier), "F-Curve Modifier"); fcm->type = type; fcm->flag = FMODIFIER_FLAG_EXPANDED; fcm->influence = 1.0f; @@ -1022,7 +1022,7 @@ FModifier *add_fmodifier (ListBase *modifiers, int type) fcm->flag |= FMODIFIER_FLAG_ACTIVE; /* add modifier's data */ - fcm->data= MEM_callocN(fmi->size, fmi->structName); + fcm->data = MEM_callocN(fmi->size, fmi->structName); /* init custom settings if necessary */ if (fmi->new_data) @@ -1033,9 +1033,9 @@ FModifier *add_fmodifier (ListBase *modifiers, int type) } /* Make a copy of the specified F-Modifier */ -FModifier *copy_fmodifier (FModifier *src) +FModifier *copy_fmodifier(FModifier *src) { - FModifierTypeInfo *fmi= fmodifier_get_typeinfo(src); + FModifierTypeInfo *fmi = fmodifier_get_typeinfo(src); FModifier *dst; /* sanity check */ @@ -1065,11 +1065,11 @@ void copy_fmodifiers(ListBase *dst, ListBase *src) if (ELEM(NULL, dst, src)) return; - dst->first= dst->last= NULL; + dst->first = dst->last = NULL; BLI_duplicatelist(dst, src); - for (fcm=dst->first, srcfcm=src->first; fcm && srcfcm; srcfcm=srcfcm->next, fcm=fcm->next) { - FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm); + for (fcm = dst->first, srcfcm = src->first; fcm && srcfcm; srcfcm = srcfcm->next, fcm = fcm->next) { + FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm); /* make a new copy of the F-Modifier's data */ fcm->data = MEM_dupallocN(fcm->data); @@ -1083,7 +1083,7 @@ void copy_fmodifiers(ListBase *dst, ListBase *src) /* Remove and free the given F-Modifier from the given stack */ int remove_fmodifier(ListBase *modifiers, FModifier *fcm) { - FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm); + FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm); /* sanity check */ if (fcm == NULL) @@ -1121,14 +1121,14 @@ void free_fmodifiers(ListBase *modifiers) return; /* free each modifier in order - modifier is unlinked from list and freed */ - for (fcm= modifiers->first; fcm; fcm= fmn) { - fmn= fcm->next; + for (fcm = modifiers->first; fcm; fcm = fmn) { + fmn = fcm->next; remove_fmodifier(modifiers, fcm); } } /* Find the active F-Modifier */ -FModifier *find_active_fmodifier (ListBase *modifiers) +FModifier *find_active_fmodifier(ListBase *modifiers) { FModifier *fcm; @@ -1137,7 +1137,7 @@ FModifier *find_active_fmodifier (ListBase *modifiers) return NULL; /* loop over modifiers until 'active' one is found */ - for (fcm= modifiers->first; fcm; fcm= fcm->next) { + for (fcm = modifiers->first; fcm; fcm = fcm->next) { if (fcm->flag & FMODIFIER_FLAG_ACTIVE) return fcm; } @@ -1156,7 +1156,7 @@ void set_active_fmodifier(ListBase *modifiers, FModifier *fcm) return; /* deactivate all, and set current one active */ - for (fm= modifiers->first; fm; fm= fm->next) + for (fm = modifiers->first; fm; fm = fm->next) fm->flag &= ~FMODIFIER_FLAG_ACTIVE; /* make given modifier active */ @@ -1181,15 +1181,15 @@ short list_has_suitable_fmodifier(ListBase *modifiers, int mtype, short acttype) return 0; /* find the first mdifier fitting these criteria */ - for (fcm= modifiers->first; fcm; fcm= fcm->next) { - FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm); - short mOk=1, aOk=1; /* by default 1, so that when only one test, won't fail */ + for (fcm = modifiers->first; fcm; fcm = fcm->next) { + FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm); + short mOk = 1, aOk = 1; /* by default 1, so that when only one test, won't fail */ /* check if applicable ones are fullfilled */ if (mtype) - mOk= (fcm->type == mtype); + mOk = (fcm->type == mtype); if (acttype > -1) - aOk= (fmi->acttype == acttype); + aOk = (fmi->acttype == acttype); /* if both are ok, we've found a hit */ if (mOk && aOk) @@ -1203,7 +1203,7 @@ short list_has_suitable_fmodifier(ListBase *modifiers, int mtype, short acttype) /* Evaluation API --------------------------- */ /* helper function - calculate influence of FModifier */ -static float eval_fmodifier_influence (FModifier *fcm, float evaltime) +static float eval_fmodifier_influence(FModifier *fcm, float evaltime) { float influence; @@ -1270,8 +1270,8 @@ float evaluate_time_fmodifiers(ListBase *modifiers, FCurve *fcu, float cvalue, f * effect, which should get us the desired effects when using layered time manipulations * (such as multiple 'stepped' modifiers in sequence, causing different stepping rates) */ - for (fcm= modifiers->last; fcm; fcm= fcm->prev) { - FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm); + for (fcm = modifiers->last; fcm; fcm = fcm->prev) { + FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm); if (fmi == NULL) continue; @@ -1279,12 +1279,12 @@ float evaluate_time_fmodifiers(ListBase *modifiers, FCurve *fcu, float cvalue, f /* if modifier cannot be applied on this frame (whatever scale it is on, it won't affect the results) * hence we shouldn't bother seeing what it would do given the chance */ - if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)==0 || - ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) ) + if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) == 0 || + ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) ) { /* only evaluate if there's a callback for this */ if (fmi->evaluate_modifier_time) { - if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0) { + if ((fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) == 0) { float influence = eval_fmodifier_influence(fcm, evaltime); float nval = fmi->evaluate_modifier_time(fcu, fcm, cvalue, evaltime); @@ -1310,18 +1310,18 @@ void evaluate_value_fmodifiers(ListBase *modifiers, FCurve *fcu, float *cvalue, return; /* evaluate modifiers */ - for (fcm= modifiers->first; fcm; fcm= fcm->next) { - FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm); + for (fcm = modifiers->first; fcm; fcm = fcm->next) { + FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm); if (fmi == NULL) continue; /* only evaluate if there's a callback for this, and if F-Modifier can be evaluated on this frame */ - if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)==0 || - ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) ) + if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) == 0 || + ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) ) { if (fmi->evaluate_modifier) { - if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0) { + if ((fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) == 0) { float influence = eval_fmodifier_influence(fcm, evaltime); float nval = *cvalue; @@ -1350,8 +1350,8 @@ void fcurve_bake_modifiers(FCurve *fcu, int start, int end) } /* temporarily, disable driver while we sample, so that they don't influence the outcome */ - driver= fcu->driver; - fcu->driver= NULL; + driver = fcu->driver; + fcu->driver = NULL; /* bake the modifiers, by sampling the curve at each frame */ fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve); @@ -1360,5 +1360,5 @@ void fcurve_bake_modifiers(FCurve *fcu, int start, int end) free_fmodifiers(&fcu->modifiers); /* restore driver */ - fcu->driver= driver; + fcu->driver = driver; } diff --git a/source/blender/blenkernel/intern/idprop.c b/source/blender/blenkernel/intern/idprop.c index dfe73ae20db..e3735cfd374 100644 --- a/source/blender/blenkernel/intern/idprop.c +++ b/source/blender/blenkernel/intern/idprop.c @@ -47,16 +47,16 @@ static char idp_size_table[] = { 1, /*strings*/ sizeof(int), sizeof(float), - sizeof(float)*3, /*Vector type, deprecated*/ - sizeof(float)*16, /*Matrix type, deprecated*/ + sizeof(float) * 3, /*Vector type, deprecated*/ + sizeof(float) * 16, /*Matrix type, deprecated*/ 0, /*arrays don't have a fixed size*/ sizeof(ListBase), /*Group type*/ - sizeof(void*), + sizeof(void *), sizeof(double) }; /* ------------Property Array Type ----------- */ -#define GETPROP(prop, i) (((IDProperty*)(prop)->data.pointer)+(i)) +#define GETPROP(prop, i) (((IDProperty *)(prop)->data.pointer) + (i)) /* --------- property array type -------------*/ @@ -78,10 +78,10 @@ IDProperty *IDP_CopyIDPArray(IDProperty *array) IDProperty *narray = MEM_mallocN(sizeof(IDProperty), "IDP_CopyIDPArray"), *tmp; int i; - *narray= *array; + *narray = *array; narray->data.pointer = MEM_dupallocN(array->data.pointer); - for (i=0; ilen; i++) { + for (i = 0; i < narray->len; i++) { /* ok, the copy functions always allocate a new structure, * which doesn't work here. instead, simply copy the * contents of the new structure into the array cell, @@ -100,7 +100,7 @@ void IDP_FreeIDPArray(IDProperty *prop) { int i; - for (i=0; ilen; i++) + for (i = 0; i < prop->len; i++) IDP_FreeProperty(GETPROP(prop, i)); if (prop->data.pointer) @@ -124,22 +124,22 @@ IDProperty *IDP_GetIndexArray(IDProperty *prop, int index) IDProperty *IDP_AppendArray(IDProperty *prop, IDProperty *item) { - IDP_ResizeIDPArray(prop, prop->len+1); - IDP_SetIndexArray(prop, prop->len-1, item); + IDP_ResizeIDPArray(prop, prop->len + 1); + IDP_SetIndexArray(prop, prop->len - 1, item); return item; } void IDP_ResizeIDPArray(IDProperty *prop, int newlen) { void *newarr; - int newsize=newlen; + int newsize = newlen; /*first check if the array buffer size has room*/ /*if newlen is 200 chars less then totallen, reallocate anyway*/ if (newlen <= prop->totallen && prop->totallen - newlen < 200) { int i; - for (i=newlen; ilen; i++) + for (i = newlen; i < prop->len; i++) IDP_FreeProperty(GETPROP(prop, i)); prop->len = newlen; @@ -156,18 +156,18 @@ void IDP_ResizeIDPArray(IDProperty *prop, int newlen) */ newsize = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize; - newarr = MEM_callocN(sizeof(IDProperty)*newsize, "idproperty array resized"); + newarr = MEM_callocN(sizeof(IDProperty) * newsize, "idproperty array resized"); if (newlen >= prop->len) { /* newlen is bigger*/ - memcpy(newarr, prop->data.pointer, prop->len*sizeof(IDProperty)); + memcpy(newarr, prop->data.pointer, prop->len * sizeof(IDProperty)); } else { int i; /* newlen is smaller*/ - for (i=newlen; ilen; i++) { + for (i = newlen; i < prop->len; i++) { IDP_FreeProperty(GETPROP(prop, i)); } - memcpy(newarr, prop->data.pointer, newlen*sizeof(IDProperty)); + memcpy(newarr, prop->data.pointer, newlen * sizeof(IDProperty)); } if (prop->data.pointer) @@ -185,21 +185,21 @@ static void idp_resize_group_array(IDProperty *prop, int newlen, void *newarr) if (newlen >= prop->len) { /* bigger */ - IDProperty **array= newarr; + IDProperty **array = newarr; IDPropertyTemplate val; int a; - for (a=prop->len; alen; a < newlen; a++) { val.i = 0; /* silence MSVC warning about uninitialized var when debugging */ - array[a]= IDP_New(IDP_GROUP, &val, "IDP_ResizeArray group"); + array[a] = IDP_New(IDP_GROUP, &val, "IDP_ResizeArray group"); } } else { /* smaller */ - IDProperty **array= prop->data.pointer; + IDProperty **array = prop->data.pointer; int a; - for (a=newlen; alen; a++) { + for (a = newlen; a < prop->len; a++) { IDP_FreeProperty(array[a]); MEM_freeN(array[a]); } @@ -210,7 +210,7 @@ static void idp_resize_group_array(IDProperty *prop, int newlen, void *newarr) void IDP_ResizeArray(IDProperty *prop, int newlen) { void *newarr; - int newsize=newlen; + int newsize = newlen; /*first check if the array buffer size has room*/ /*if newlen is 200 chars less then totallen, reallocate anyway*/ @@ -230,16 +230,16 @@ void IDP_ResizeArray(IDProperty *prop, int newlen) */ newsize = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize; - newarr = MEM_callocN(idp_size_table[(int)prop->subtype]*newsize, "idproperty array resized"); + newarr = MEM_callocN(idp_size_table[(int)prop->subtype] * newsize, "idproperty array resized"); if (newlen >= prop->len) { /* newlen is bigger*/ - memcpy(newarr, prop->data.pointer, prop->len*idp_size_table[(int)prop->subtype]); + memcpy(newarr, prop->data.pointer, prop->len * idp_size_table[(int)prop->subtype]); idp_resize_group_array(prop, newlen, newarr); } else { /* newlen is smaller*/ idp_resize_group_array(prop, newlen, newarr); - memcpy(newarr, prop->data.pointer, newlen*idp_size_table[(int)prop->subtype]); + memcpy(newarr, prop->data.pointer, newlen * idp_size_table[(int)prop->subtype]); } MEM_freeN(prop->data.pointer); @@ -257,8 +257,8 @@ void IDP_FreeArray(IDProperty *prop) } - static IDProperty *idp_generic_copy(IDProperty *prop) - { +static IDProperty *idp_generic_copy(IDProperty *prop) +{ IDProperty *newp = MEM_callocN(sizeof(IDProperty), "IDProperty array dup"); BLI_strncpy(newp->name, prop->name, MAX_IDPROP_NAME); @@ -268,7 +268,7 @@ void IDP_FreeArray(IDProperty *prop) newp->data.val2 = prop->data.val2; return newp; - } +} static IDProperty *IDP_CopyArray(IDProperty *prop) { @@ -278,11 +278,11 @@ static IDProperty *IDP_CopyArray(IDProperty *prop) newp->data.pointer = MEM_dupallocN(prop->data.pointer); if (prop->type == IDP_GROUP) { - IDProperty **array= newp->data.pointer; + IDProperty **array = newp->data.pointer; int a; - for (a=0; alen; a++) - array[a]= IDP_CopyProperty(array[a]); + for (a = 0; a < prop->len; a++) + array[a] = IDP_CopyProperty(array[a]); } } newp->len = prop->len; @@ -294,12 +294,12 @@ static IDProperty *IDP_CopyArray(IDProperty *prop) /*taken from readfile.c*/ #define SWITCH_LONGINT(a) { \ - char s_i, *p_i; \ - p_i= (char *)&(a); \ - s_i=p_i[0]; p_i[0]=p_i[7]; p_i[7]=s_i; \ - s_i=p_i[1]; p_i[1]=p_i[6]; p_i[6]=s_i; \ - s_i=p_i[2]; p_i[2]=p_i[5]; p_i[5]=s_i; \ - s_i=p_i[3]; p_i[3]=p_i[4]; p_i[4]=s_i; } + char s_i, *p_i; \ + p_i = (char *)& (a); \ + s_i = p_i[0]; p_i[0] = p_i[7]; p_i[7] = s_i; \ + s_i = p_i[1]; p_i[1] = p_i[6]; p_i[6] = s_i; \ + s_i = p_i[2]; p_i[2] = p_i[5]; p_i[5] = s_i; \ + s_i = p_i[3]; p_i[3] = p_i[4]; p_i[4] = s_i; } @@ -350,7 +350,7 @@ void IDP_AssignString(IDProperty *prop, const char *st, int maxlen) int stlen = strlen(st); if (maxlen > 0 && maxlen < stlen) - stlen= maxlen; + stlen = maxlen; if (prop->subtype == IDP_STRING_SUB_BYTE) { IDP_ResizeArray(prop, stlen); @@ -396,14 +396,14 @@ void IDP_FreeString(IDProperty *prop) void IDP_LinkID(IDProperty *prop, ID *id) { - if (prop->data.pointer) ((ID*)prop->data.pointer)->us--; + if (prop->data.pointer) ((ID *)prop->data.pointer)->us--; prop->data.pointer = id; id_us_plus(id); } void IDP_UnlinkID(IDProperty *prop) { - ((ID*)prop->data.pointer)->us--; + ((ID *)prop->data.pointer)->us--; } /*-------- Group Functions -------*/ @@ -414,7 +414,7 @@ static IDProperty *IDP_CopyGroup(IDProperty *prop) IDProperty *newp = idp_generic_copy(prop), *link; newp->len = prop->len; - for (link=prop->data.group.first; link; link=link->next) { + for (link = prop->data.group.first; link; link = link->next) { BLI_addtail(&newp->data.group, IDP_CopyProperty(link)); } @@ -426,22 +426,22 @@ static IDProperty *IDP_CopyGroup(IDProperty *prop) void IDP_SyncGroupValues(IDProperty *dest, IDProperty *src) { IDProperty *other, *prop; - for (prop=src->data.group.first; prop; prop=prop->next) { - other= BLI_findstring(&dest->data.group, prop->name, offsetof(IDProperty, name)); - if (other && prop->type==other->type) { + for (prop = src->data.group.first; prop; prop = prop->next) { + other = BLI_findstring(&dest->data.group, prop->name, offsetof(IDProperty, name)); + if (other && prop->type == other->type) { switch (prop->type) { case IDP_INT: case IDP_FLOAT: case IDP_DOUBLE: - other->data= prop->data; + other->data = prop->data; break; case IDP_GROUP: IDP_SyncGroupValues(other, prop); break; default: { - IDProperty *tmp= other; - IDProperty *copy= IDP_CopyProperty(prop); + IDProperty *tmp = other; + IDProperty *copy = IDP_CopyProperty(prop); BLI_insertlinkafter(&dest->data.group, other, copy); BLI_remlink(&dest->data.group, tmp); @@ -460,8 +460,8 @@ void IDP_SyncGroupValues(IDProperty *dest, IDProperty *src) void IDP_ReplaceGroupInGroup(IDProperty *dest, IDProperty *src) { IDProperty *loop, *prop; - for (prop=src->data.group.first; prop; prop=prop->next) { - for (loop=dest->data.group.first; loop; loop=loop->next) { + for (prop = src->data.group.first; prop; prop = prop->next) { + for (loop = dest->data.group.first; loop; loop = loop->next) { if (strcmp(loop->name, prop->name) == 0) { IDProperty *copy = IDP_CopyProperty(prop); @@ -489,7 +489,7 @@ void IDP_ReplaceGroupInGroup(IDProperty *dest, IDProperty *src) void IDP_ReplaceInGroup(IDProperty *group, IDProperty *prop) { IDProperty *loop; - if ((loop= IDP_GetPropertyFromGroup(group, prop->name))) { + if ((loop = IDP_GetPropertyFromGroup(group, prop->name))) { BLI_insertlink(&group->data.group, loop, prop); BLI_remlink(&group->data.group, loop); @@ -539,7 +539,7 @@ IDProperty *IDP_GetPropertyFromGroup(IDProperty *prop, const char *name) IDProperty *IDP_GetPropertyTypeFromGroup(IDProperty *prop, const char *name, const char type) { - IDProperty *idprop= IDP_GetPropertyFromGroup(prop, name); + IDProperty *idprop = IDP_GetPropertyFromGroup(prop, name); return (idprop && idprop->type == type) ? idprop : NULL; } @@ -553,20 +553,20 @@ void *IDP_GetGroupIterator(IDProperty *prop) IDPIter *iter = MEM_callocN(sizeof(IDPIter), "IDPIter"); iter->next = prop->data.group.first; iter->parent = prop; - return (void*) iter; + return (void *) iter; } IDProperty *IDP_GroupIterNext(void *vself) { - IDPIter *self = (IDPIter*) vself; - Link *next = (Link*) self->next; + IDPIter *self = (IDPIter *) vself; + Link *next = (Link *) self->next; if (self->next == NULL) { MEM_freeN(self); return NULL; } self->next = next->next; - return (void*) next; + return (void *) next; } void IDP_FreeIterBeforeEnd(void *vself) @@ -581,7 +581,7 @@ void IDP_FreeIterBeforeEnd(void *vself) static void IDP_FreeGroup(IDProperty *prop) { IDProperty *loop; - for (loop=prop->data.group.first; loop; loop=loop->next) { + for (loop = prop->data.group.first; loop; loop = loop->next) { IDP_FreeProperty(loop); } BLI_freelistN(&prop->data.group); @@ -635,7 +635,7 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2) return ((prop1->len == prop2->len) && strncmp(IDP_String(prop1), IDP_String(prop2), prop1->len) == 0); else if (prop1->type == IDP_ARRAY) { if (prop1->len == prop2->len && prop1->subtype == prop2->subtype) - return memcmp(IDP_Array(prop1), IDP_Array(prop2), idp_size_table[(int)prop1->subtype]*prop1->len); + return memcmp(IDP_Array(prop1), IDP_Array(prop2), idp_size_table[(int)prop1->subtype] * prop1->len); else return 0; } @@ -645,8 +645,8 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2) if (BLI_countlist(&prop1->data.group) != BLI_countlist(&prop2->data.group)) return 0; - for (link1=prop1->data.group.first; link1; link1=link1->next) { - link2= IDP_GetPropertyFromGroup(prop2, link1->name); + for (link1 = prop1->data.group.first; link1; link1 = link1->next) { + link2 = IDP_GetPropertyFromGroup(prop2, link1->name); if (!IDP_EqualsProperties(link1, link2)) return 0; @@ -655,14 +655,14 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2) return 1; } else if (prop1->type == IDP_IDPARRAY) { - IDProperty *array1= IDP_IDPArray(prop1); - IDProperty *array2= IDP_IDPArray(prop2); + IDProperty *array1 = IDP_IDPArray(prop1); + IDProperty *array2 = IDP_IDPArray(prop2); int i; if (prop1->len != prop2->len) return 0; - for (i=0; ilen; i++) + for (i = 0; i < prop1->len; i++) if (!IDP_EqualsProperties(&array1[i], &array2[i])) return 0; } @@ -673,7 +673,7 @@ int IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2) /* 'val' is never NULL, don't check */ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *name) { - IDProperty *prop=NULL; + IDProperty *prop = NULL; switch (type) { case IDP_INT: @@ -682,11 +682,11 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n break; case IDP_FLOAT: prop = MEM_callocN(sizeof(IDProperty), "IDProperty float"); - *(float*)&prop->data.val = val->f; + *(float *)&prop->data.val = val->f; break; case IDP_DOUBLE: prop = MEM_callocN(sizeof(IDProperty), "IDProperty float"); - *(double*)&prop->data.val = val->d; + *(double *)&prop->data.val = val->d; break; case IDP_ARRAY: { @@ -699,7 +699,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n prop = MEM_callocN(sizeof(IDProperty), "IDProperty array"); prop->subtype = val->array.type; if (val->array.len) - prop->data.pointer = MEM_callocN(idp_size_table[val->array.type]*val->array.len, "id property array"); + prop->data.pointer = MEM_callocN(idp_size_table[val->array.type] * val->array.len, "id property array"); prop->len = prop->totallen = val->array.len; break; } @@ -724,7 +724,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n prop->len = prop->totallen = val->string.len; memcpy(prop->data.pointer, st, val->string.len); } - prop->subtype= IDP_STRING_SUB_BYTE; + prop->subtype = IDP_STRING_SUB_BYTE; } else { if (st == NULL) { @@ -738,7 +738,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n prop->len = prop->totallen = stlen; memcpy(prop->data.pointer, st, stlen); } - prop->subtype= IDP_STRING_SUB_UTF8; + prop->subtype = IDP_STRING_SUB_UTF8; } break; } diff --git a/source/blender/blenkernel/intern/image_gen.c b/source/blender/blenkernel/intern/image_gen.c index 1441bd7b12b..4579e6f92aa 100644 --- a/source/blender/blenkernel/intern/image_gen.c +++ b/source/blender/blenkernel/intern/image_gen.c @@ -39,10 +39,10 @@ void BKE_image_buf_fill_color(unsigned char *rect, float *rect_float, int width, /* blank image */ if (rect_float) { - for (y= 0; y 0) { - rect_float[0]= rect_float[1]= rect_float[2]= 0.25f; - rect_float[3]= 1.0f; + rect_float[0] = rect_float[1] = rect_float[2] = 0.25f; + rect_float[3] = 1.0f; } else { - rect_float[0]= rect_float[1]= rect_float[2]= 0.58f; - rect_float[3]= 1.0f; + rect_float[0] = rect_float[1] = rect_float[2] = 0.58f; + rect_float[3] = 1.0f; } - rect_float+= 4; + rect_float += 4; } else { if (dark > 0) { - rect[0]= rect[1]= rect[2]= 64; - rect[3]= 255; + rect[0] = rect[1] = rect[2] = 64; + rect[3] = 255; } else { - rect[0]= rect[1]= rect[2]= 150; - rect[3]= 255; + rect[0] = rect[1] = rect[2] = 150; + rect[3] = 255; } - rect+= 4; + rect += 4; } } } - rect= rect_orig; - rect_float= rect_float_orig; + rect = rect_orig; + rect_float = rect_float_orig; /* 2nd pass, colored + */ - for (y= 0; yname, lib->filepath}; + char *bpath_user_data[2] = {bmain->name, lib->filepath}; BLI_bpath_traverse_id(bmain, id, - BLI_bpath_relocate_visitor, - BLI_BPATH_TRAVERSE_SKIP_MULTIFILE, - bpath_user_data); + BLI_bpath_relocate_visitor, + BLI_BPATH_TRAVERSE_SKIP_MULTIFILE, + bpath_user_data); } void id_lib_extern(ID *id) @@ -166,7 +166,7 @@ void id_us_min(ID *id) { if (id) { if (id->us < 2 && (id->flag & LIB_FAKEUSER)) { - id->us= 1; + id->us = 1; } else if (id->us <= 0) { printf("ID user decrement error: %s\n", id->name); @@ -274,7 +274,7 @@ int id_make_local(ID *id, int test) int id_copy(ID *id, ID **newid, int test) { - if (!test) *newid= NULL; + if (!test) *newid = NULL; /* conventions: * - make shallow copy, only this ID block @@ -285,74 +285,74 @@ int id_copy(ID *id, ID **newid, int test) case ID_LI: return 0; /* can't be copied from here */ case ID_OB: - if (!test) *newid = (ID *)BKE_object_copy((Object*)id); + if (!test) *newid = (ID *)BKE_object_copy((Object *)id); return 1; case ID_ME: - if (!test) *newid = (ID *)BKE_mesh_copy((Mesh*)id); + if (!test) *newid = (ID *)BKE_mesh_copy((Mesh *)id); return 1; case ID_CU: - if (!test) *newid = (ID *)BKE_curve_copy((Curve*)id); + if (!test) *newid = (ID *)BKE_curve_copy((Curve *)id); return 1; case ID_MB: - if (!test) *newid = (ID *)BKE_metaball_copy((MetaBall*)id); + if (!test) *newid = (ID *)BKE_metaball_copy((MetaBall *)id); return 1; case ID_MA: - if (!test) *newid = (ID *)BKE_material_copy((Material*)id); + if (!test) *newid = (ID *)BKE_material_copy((Material *)id); return 1; case ID_TE: - if (!test) *newid = (ID *)BKE_texture_copy((Tex*)id); + if (!test) *newid = (ID *)BKE_texture_copy((Tex *)id); return 1; case ID_IM: - if (!test) *newid = (ID *)BKE_image_copy((Image*)id); + if (!test) *newid = (ID *)BKE_image_copy((Image *)id); return 1; case ID_LT: - if (!test) *newid = (ID *)BKE_lattice_copy((Lattice*)id); + if (!test) *newid = (ID *)BKE_lattice_copy((Lattice *)id); return 1; case ID_LA: - if (!test) *newid = (ID *)BKE_lamp_copy((Lamp*)id); + if (!test) *newid = (ID *)BKE_lamp_copy((Lamp *)id); return 1; case ID_SPK: - if (!test) *newid = (ID *)BKE_speaker_copy((Speaker*)id); + if (!test) *newid = (ID *)BKE_speaker_copy((Speaker *)id); return 1; case ID_CA: - if (!test) *newid = (ID *)BKE_camera_copy((Camera*)id); + if (!test) *newid = (ID *)BKE_camera_copy((Camera *)id); return 1; case ID_IP: return 0; /* deprecated */ case ID_KE: - if (!test) *newid = (ID *)BKE_key_copy((Key*)id); + if (!test) *newid = (ID *)BKE_key_copy((Key *)id); return 1; case ID_WO: - if (!test) *newid = (ID *)BKE_world_copy((World*)id); + if (!test) *newid = (ID *)BKE_world_copy((World *)id); return 1; case ID_SCR: return 0; /* can't be copied from here */ case ID_VF: return 0; /* not implemented */ case ID_TXT: - if (!test) *newid = (ID *)BKE_text_copy((Text*)id); + if (!test) *newid = (ID *)BKE_text_copy((Text *)id); return 1; case ID_SCRIPT: return 0; /* deprecated */ case ID_SO: return 0; /* not implemented */ case ID_GR: - if (!test) *newid = (ID *)BKE_group_copy((Group*)id); + if (!test) *newid = (ID *)BKE_group_copy((Group *)id); return 1; case ID_AR: - if (!test) *newid = (ID *)BKE_armature_copy((bArmature*)id); + if (!test) *newid = (ID *)BKE_armature_copy((bArmature *)id); return 1; case ID_AC: - if (!test) *newid = (ID *)BKE_action_copy((bAction*)id); + if (!test) *newid = (ID *)BKE_action_copy((bAction *)id); return 1; case ID_NT: - if (!test) *newid = (ID *)ntreeCopyTree((bNodeTree*)id); + if (!test) *newid = (ID *)ntreeCopyTree((bNodeTree *)id); return 1; case ID_BR: - if (!test) *newid = (ID *)BKE_brush_copy((Brush*)id); + if (!test) *newid = (ID *)BKE_brush_copy((Brush *)id); return 1; case ID_PA: - if (!test) *newid = (ID *)BKE_particlesettings_copy((ParticleSettings*)id); + if (!test) *newid = (ID *)BKE_particlesettings_copy((ParticleSettings *)id); return 1; case ID_WM: return 0; /* can't be copied from here */ @@ -365,7 +365,7 @@ int id_copy(ID *id, ID **newid, int test) int id_unlink(ID *id, int test) { - Main *mainlib= G.main; + Main *mainlib = G.main; ListBase *lb; switch (GS(id->name)) { @@ -386,7 +386,7 @@ int id_unlink(ID *id, int test) if (id->us == 0) { if (test) return 1; - lb= which_libbase(mainlib, GS(id->name)); + lb = which_libbase(mainlib, GS(id->name)); BKE_libblock_free(lb, id); return 1; @@ -425,7 +425,7 @@ int id_single_user(bContext *C, ID *id, PointerRNA *ptr, PropertyRNA *prop) ListBase *which_libbase(Main *mainlib, short type) { - switch ( type ) { + switch (type) { case ID_SCE: return &(mainlib->scene); case ID_LI: @@ -495,11 +495,11 @@ void flag_listbase_ids(ListBase *lb, short flag, short value) { ID *id; if (value) { - for (id= lb->first; id; id= id->next) id->flag |= flag; + for (id = lb->first; id; id = id->next) id->flag |= flag; } else { flag = ~flag; - for (id= lb->first; id; id= id->next) id->flag &= flag; + for (id = lb->first; id; id = id->next) id->flag &= flag; } } @@ -508,8 +508,8 @@ void flag_all_listbases_ids(short flag, short value) { ListBase *lbarray[MAX_LIBARRAY]; int a; - a= set_listbasepointers(G.main, lbarray); - while (a--) flag_listbase_ids(lbarray[a], flag, value); + a = set_listbasepointers(G.main, lbarray); + while (a--) flag_listbase_ids(lbarray[a], flag, value); } void recalc_all_library_objects(Main *main) @@ -517,9 +517,9 @@ void recalc_all_library_objects(Main *main) Object *ob; /* flag for full recalc */ - for (ob=main->object.first; ob; ob=ob->id.next) + for (ob = main->object.first; ob; ob = ob->id.next) if (ob->id.lib) - ob->recalc |= OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME; + ob->recalc |= OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME; } /* note: MAX_LIBARRAY define should match this code */ @@ -530,47 +530,47 @@ int set_listbasepointers(Main *main, ListBase **lb) /* BACKWARDS! also watch order of free-ing! (mesh<->mat), first items freed last. * This is important because freeing data decreases usercounts of other datablocks, * if this data is its self freed it can crash. */ - lb[a++]= &(main->ipo); - lb[a++]= &(main->action); // xxx moved here to avoid problems when freeing with animato (aligorith) - lb[a++]= &(main->key); - lb[a++]= &(main->gpencil); /* referenced by nodes, objects, view, scene etc, before to free after. */ - lb[a++]= &(main->nodetree); - lb[a++]= &(main->image); - lb[a++]= &(main->tex); - lb[a++]= &(main->mat); - lb[a++]= &(main->vfont); + lb[a++] = &(main->ipo); + lb[a++] = &(main->action); // xxx moved here to avoid problems when freeing with animato (aligorith) + lb[a++] = &(main->key); + lb[a++] = &(main->gpencil); /* referenced by nodes, objects, view, scene etc, before to free after. */ + lb[a++] = &(main->nodetree); + lb[a++] = &(main->image); + lb[a++] = &(main->tex); + lb[a++] = &(main->mat); + lb[a++] = &(main->vfont); /* Important!: When adding a new object type, * the specific data should be inserted here */ - lb[a++]= &(main->armature); - - lb[a++]= &(main->mesh); - lb[a++]= &(main->curve); - lb[a++]= &(main->mball); - - lb[a++]= &(main->latt); - lb[a++]= &(main->lamp); - lb[a++]= &(main->camera); - - lb[a++]= &(main->text); - lb[a++]= &(main->sound); - lb[a++]= &(main->group); - lb[a++]= &(main->brush); - lb[a++]= &(main->script); - lb[a++]= &(main->particle); - lb[a++]= &(main->speaker); - - lb[a++]= &(main->world); - lb[a++]= &(main->screen); - lb[a++]= &(main->object); - lb[a++]= &(main->scene); - lb[a++]= &(main->library); - lb[a++]= &(main->wm); - lb[a++]= &(main->movieclip); + lb[a++] = &(main->armature); + + lb[a++] = &(main->mesh); + lb[a++] = &(main->curve); + lb[a++] = &(main->mball); + + lb[a++] = &(main->latt); + lb[a++] = &(main->lamp); + lb[a++] = &(main->camera); + + lb[a++] = &(main->text); + lb[a++] = &(main->sound); + lb[a++] = &(main->group); + lb[a++] = &(main->brush); + lb[a++] = &(main->script); + lb[a++] = &(main->particle); + lb[a++] = &(main->speaker); + + lb[a++] = &(main->world); + lb[a++] = &(main->screen); + lb[a++] = &(main->object); + lb[a++] = &(main->scene); + lb[a++] = &(main->library); + lb[a++] = &(main->wm); + lb[a++] = &(main->movieclip); - lb[a]= NULL; + lb[a] = NULL; return a; } @@ -587,74 +587,74 @@ int set_listbasepointers(Main *main, ListBase **lb) static ID *alloc_libblock_notest(short type) { - ID *id= NULL; + ID *id = NULL; - switch ( type ) { + switch (type) { case ID_SCE: - id= MEM_callocN(sizeof(Scene), "scene"); + id = MEM_callocN(sizeof(Scene), "scene"); break; case ID_LI: - id= MEM_callocN(sizeof(Library), "library"); + id = MEM_callocN(sizeof(Library), "library"); break; case ID_OB: - id= MEM_callocN(sizeof(Object), "object"); + id = MEM_callocN(sizeof(Object), "object"); break; case ID_ME: - id= MEM_callocN(sizeof(Mesh), "mesh"); + id = MEM_callocN(sizeof(Mesh), "mesh"); break; case ID_CU: - id= MEM_callocN(sizeof(Curve), "curve"); + id = MEM_callocN(sizeof(Curve), "curve"); break; case ID_MB: - id= MEM_callocN(sizeof(MetaBall), "mball"); + id = MEM_callocN(sizeof(MetaBall), "mball"); break; case ID_MA: - id= MEM_callocN(sizeof(Material), "mat"); + id = MEM_callocN(sizeof(Material), "mat"); break; case ID_TE: - id= MEM_callocN(sizeof(Tex), "tex"); + id = MEM_callocN(sizeof(Tex), "tex"); break; case ID_IM: - id= MEM_callocN(sizeof(Image), "image"); + id = MEM_callocN(sizeof(Image), "image"); break; case ID_LT: - id= MEM_callocN(sizeof(Lattice), "latt"); + id = MEM_callocN(sizeof(Lattice), "latt"); break; case ID_LA: - id= MEM_callocN(sizeof(Lamp), "lamp"); + id = MEM_callocN(sizeof(Lamp), "lamp"); break; case ID_CA: - id= MEM_callocN(sizeof(Camera), "camera"); + id = MEM_callocN(sizeof(Camera), "camera"); break; case ID_IP: - id= MEM_callocN(sizeof(Ipo), "ipo"); + id = MEM_callocN(sizeof(Ipo), "ipo"); break; case ID_KE: - id= MEM_callocN(sizeof(Key), "key"); + id = MEM_callocN(sizeof(Key), "key"); break; case ID_WO: - id= MEM_callocN(sizeof(World), "world"); + id = MEM_callocN(sizeof(World), "world"); break; case ID_SCR: - id= MEM_callocN(sizeof(bScreen), "screen"); + id = MEM_callocN(sizeof(bScreen), "screen"); break; case ID_VF: - id= MEM_callocN(sizeof(VFont), "vfont"); + id = MEM_callocN(sizeof(VFont), "vfont"); break; case ID_TXT: - id= MEM_callocN(sizeof(Text), "text"); + id = MEM_callocN(sizeof(Text), "text"); break; case ID_SCRIPT: //XXX id= MEM_callocN(sizeof(Script), "script"); break; case ID_SPK: - id= MEM_callocN(sizeof(Speaker), "speaker"); + id = MEM_callocN(sizeof(Speaker), "speaker"); break; case ID_SO: - id= MEM_callocN(sizeof(bSound), "sound"); + id = MEM_callocN(sizeof(bSound), "sound"); break; case ID_GR: - id= MEM_callocN(sizeof(Group), "group"); + id = MEM_callocN(sizeof(Group), "group"); break; case ID_AR: id = MEM_callocN(sizeof(bArmature), "armature"); @@ -687,14 +687,14 @@ static ID *alloc_libblock_notest(short type) /* used everywhere in blenkernel and text.c */ void *BKE_libblock_alloc(ListBase *lb, short type, const char *name) { - ID *id= NULL; + ID *id = NULL; - id= alloc_libblock_notest(type); + id = alloc_libblock_notest(type); if (id) { BLI_addtail(lb, id); - id->us= 1; + id->us = 1; id->icon_id = 0; - *( (short *)id->name )= type; + *( (short *)id->name) = type; new_id(lb, id, name); /* alphabetic insterion: is in new_id */ } @@ -705,11 +705,11 @@ void *BKE_libblock_alloc(ListBase *lb, short type, const char *name) /* and, trust that BKE_animdata_from_id() will only find AnimData for valid ID-types */ static void id_copy_animdata(ID *id, const short do_action) { - AnimData *adt= BKE_animdata_from_id(id); + AnimData *adt = BKE_animdata_from_id(id); if (adt) { IdAdtTemplate *iat = (IdAdtTemplate *)id; - iat->adt= BKE_copy_animdata(iat->adt, do_action); /* could be set to FALSE, need to investigate */ + iat->adt = BKE_copy_animdata(iat->adt, do_action); /* could be set to FALSE, need to investigate */ } } @@ -730,20 +730,20 @@ void *BKE_libblock_copy(ID *id) ListBase *lb; size_t idn_len; - lb= which_libbase(G.main, GS(id->name)); - idn= BKE_libblock_alloc(lb, GS(id->name), id->name+2); + lb = which_libbase(G.main, GS(id->name)); + idn = BKE_libblock_alloc(lb, GS(id->name), id->name + 2); assert(idn != NULL); - idn_len= MEM_allocN_len(idn); + idn_len = MEM_allocN_len(idn); if ((int)idn_len - (int)sizeof(ID) > 0) { /* signed to allow neg result */ - const char *cp= (const char *)id; - char *cpn= (char *)idn; + const char *cp = (const char *)id; + char *cpn = (char *)idn; - memcpy(cpn+sizeof(ID), cp+sizeof(ID), idn_len - sizeof(ID)); + memcpy(cpn + sizeof(ID), cp + sizeof(ID), idn_len - sizeof(ID)); } - id->newid= idn; + id->newid = idn; idn->flag |= LIB_NEW; BKE_libblock_copy_data(idn, id, FALSE); @@ -756,11 +756,11 @@ static void BKE_library_free(Library *UNUSED(lib)) /* no freeing needed for libraries yet */ } -static void (*free_windowmanager_cb)(bContext *, wmWindowManager *)= NULL; +static void (*free_windowmanager_cb)(bContext *, wmWindowManager *) = NULL; void set_free_windowmanager_cb(void (*func)(bContext *C, wmWindowManager *) ) { - free_windowmanager_cb= func; + free_windowmanager_cb = func; } static void animdata_dtar_clear_cb(ID *UNUSED(id), AnimData *adt, void *userdata) @@ -769,16 +769,16 @@ static void animdata_dtar_clear_cb(ID *UNUSED(id), AnimData *adt, void *userdata FCurve *fcu; /* find the driver this belongs to and update it */ - for (fcu=adt->drivers.first; fcu; fcu=fcu->next) { - driver= fcu->driver; + for (fcu = adt->drivers.first; fcu; fcu = fcu->next) { + driver = fcu->driver; if (driver) { DriverVar *dvar; - for (dvar= driver->variables.first; dvar; dvar= dvar->next) { + for (dvar = driver->variables.first; dvar; dvar = dvar->next) { DRIVER_TARGETS_USED_LOOPER(dvar) { if (dtar->id == userdata) - dtar->id= NULL; + dtar->id = NULL; } DRIVER_TARGETS_LOOPER_END } @@ -790,13 +790,13 @@ static void animdata_dtar_clear_cb(ID *UNUSED(id), AnimData *adt, void *userdata /* used in headerbuttons.c image.c mesh.c screen.c sound.c and library.c */ void BKE_libblock_free(ListBase *lb, void *idv) { - ID *id= idv; + ID *id = idv; #ifdef WITH_PYTHON BPY_id_release(id); #endif - switch ( GS(id->name) ) { /* GetShort from util.h */ + switch (GS(id->name) ) { /* GetShort from util.h */ case ID_SCE: BKE_scene_free((Scene *)id); break; @@ -903,18 +903,18 @@ void BKE_libblock_free(ListBase *lb, void *idv) MEM_freeN(id); } -void BKE_libblock_free_us(ListBase *lb, void *idv) /* test users */ +void BKE_libblock_free_us(ListBase *lb, void *idv) /* test users */ { - ID *id= idv; + ID *id = idv; id->us--; - if (id->us<0) { + if (id->us < 0) { if (id->lib) printf("ERROR block %s %s users %d\n", id->lib->name, id->name, id->us); else printf("ERROR block %s users %d\n", id->name, id->us); } - if (id->us==0) { - if ( GS(id->name)==ID_OB ) BKE_object_unlink((Object *)id); + if (id->us == 0) { + if (GS(id->name) == ID_OB) BKE_object_unlink((Object *)id); BKE_libblock_free(lb, id); } @@ -927,12 +927,12 @@ void free_main(Main *mainvar) ListBase *lbarray[MAX_LIBARRAY]; int a; - a= set_listbasepointers(mainvar, lbarray); + a = set_listbasepointers(mainvar, lbarray); while (a--) { - ListBase *lb= lbarray[a]; + ListBase *lb = lbarray[a]; ID *id; - while ( (id= lb->first) ) { + while ( (id = lb->first) ) { BKE_libblock_free(lb, id); } } @@ -943,7 +943,7 @@ void free_main(Main *mainvar) /* ***************** ID ************************ */ -ID *BKE_libblock_find_name(const short type, const char *name) /* type: "OB" or "MA" etc */ +ID *BKE_libblock_find_name(const short type, const char *name) /* type: "OB" or "MA" etc */ { ListBase *lb = which_libbase(G.main, type); BLI_assert(lb != NULL); @@ -952,76 +952,76 @@ ID *BKE_libblock_find_name(const short type, const char *name) /* type: "OB" or static void get_flags_for_id(ID *id, char *buf) { - int isfake= id->flag & LIB_FAKEUSER; - int isnode=0; - /* Writeout the flags for the entry, note there - * is a small hack that writes 5 spaces instead - * of 4 if no flags are displayed... this makes - * things usually line up ok - better would be - * to have that explicit, oh well - zr - */ + int isfake = id->flag & LIB_FAKEUSER; + int isnode = 0; + /* Writeout the flags for the entry, note there + * is a small hack that writes 5 spaces instead + * of 4 if no flags are displayed... this makes + * things usually line up ok - better would be + * to have that explicit, oh well - zr + */ - if (GS(id->name)==ID_MA) - isnode= ((Material *)id)->use_nodes; - if (GS(id->name)==ID_TE) - isnode= ((Tex *)id)->use_nodes; + if (GS(id->name) == ID_MA) + isnode = ((Material *)id)->use_nodes; + if (GS(id->name) == ID_TE) + isnode = ((Tex *)id)->use_nodes; - if (id->us<0) + if (id->us < 0) strcpy(buf, "-1W "); else if (!id->lib && !isfake && id->us && !isnode) strcpy(buf, " "); else if (isnode) - sprintf(buf, "%c%cN%c ", id->lib?'L':' ', isfake?'F':' ', (id->us==0)?'O':' '); + sprintf(buf, "%c%cN%c ", id->lib ? 'L' : ' ', isfake ? 'F' : ' ', (id->us == 0) ? 'O' : ' '); else - sprintf(buf, "%c%c%c ", id->lib?'L':' ', isfake?'F':' ', (id->us==0)?'O':' '); + sprintf(buf, "%c%c%c ", id->lib ? 'L' : ' ', isfake ? 'F' : ' ', (id->us == 0) ? 'O' : ' '); } #define IDPUP_NO_VIEWER 1 static void IDnames_to_dyn_pupstring(DynStr *pupds, ListBase *lb, ID *link, short *nr, int hideflag) { - int i, nids= BLI_countlist(lb); + int i, nids = BLI_countlist(lb); - if (nr) *nr= -1; + if (nr) *nr = -1; - if (nr && nids>MAX_IDPUP) { + if (nr && nids > MAX_IDPUP) { BLI_dynstr_append(pupds, "DataBrowse %x-2"); - *nr= -2; + *nr = -2; } else { ID *id; - for (i=0, id= lb->first; id; id= id->next, i++) { + for (i = 0, id = lb->first; id; id = id->next, i++) { char numstr[32]; - if (nr && id==link) *nr= i+1; + if (nr && id == link) *nr = i + 1; - if (U.uiflag & USER_HIDE_DOT && id->name[2]=='.') + if (U.uiflag & USER_HIDE_DOT && id->name[2] == '.') continue; if (hideflag & IDPUP_NO_VIEWER) - if (GS(id->name)==ID_IM) - if ( ((Image *)id)->source==IMA_SRC_VIEWER ) + if (GS(id->name) == ID_IM) + if ( ((Image *)id)->source == IMA_SRC_VIEWER) continue; get_flags_for_id(id, numstr); BLI_dynstr_append(pupds, numstr); - BLI_dynstr_append(pupds, id->name+2); - BLI_snprintf(numstr, sizeof(numstr), "%%x%d", i+1); + BLI_dynstr_append(pupds, id->name + 2); + BLI_snprintf(numstr, sizeof(numstr), "%%x%d", i + 1); BLI_dynstr_append(pupds, numstr); /* icon */ switch (GS(id->name)) { - case ID_MA: /* fall through */ - case ID_TE: /* fall through */ - case ID_IM: /* fall through */ - case ID_WO: /* fall through */ - case ID_LA: /* fall through */ - BLI_snprintf(numstr, sizeof(numstr), "%%i%d", BKE_icon_getid(id)); - BLI_dynstr_append(pupds, numstr); - break; - default: - break; + case ID_MA: /* fall through */ + case ID_TE: /* fall through */ + case ID_IM: /* fall through */ + case ID_WO: /* fall through */ + case ID_LA: /* fall through */ + BLI_snprintf(numstr, sizeof(numstr), "%%i%d", BKE_icon_getid(id)); + BLI_dynstr_append(pupds, numstr); + break; + default: + break; } if (id->next) @@ -1035,7 +1035,7 @@ static void IDnames_to_dyn_pupstring(DynStr *pupds, ListBase *lb, ID *link, shor /* if nr==NULL no MAX_IDPUP, this for non-header browsing */ void IDnames_to_pupstring(const char **str, const char *title, const char *extraops, ListBase *lb, ID *link, short *nr) { - DynStr *pupds= BLI_dynstr_new(); + DynStr *pupds = BLI_dynstr_new(); if (title) { BLI_dynstr_append(pupds, title); @@ -1050,7 +1050,7 @@ void IDnames_to_pupstring(const char **str, const char *title, const char *extra IDnames_to_dyn_pupstring(pupds, lb, link, nr, 0); - *str= BLI_dynstr_get_cstring(pupds); + *str = BLI_dynstr_get_cstring(pupds); BLI_dynstr_free(pupds); } @@ -1058,7 +1058,7 @@ void IDnames_to_pupstring(const char **str, const char *title, const char *extra #if 0 /* unused */ void IMAnames_to_pupstring(const char **str, const char *title, const char *extraops, ListBase *lb, ID *link, short *nr) { - DynStr *pupds= BLI_dynstr_new(); + DynStr *pupds = BLI_dynstr_new(); if (title) { BLI_dynstr_append(pupds, title); @@ -1073,7 +1073,7 @@ void IMAnames_to_pupstring(const char **str, const char *title, const char *extr IDnames_to_dyn_pupstring(pupds, lb, link, nr, IDPUP_NO_VIEWER); - *str= BLI_dynstr_get_cstring(pupds); + *str = BLI_dynstr_get_cstring(pupds); BLI_dynstr_free(pupds); } #endif @@ -1083,19 +1083,19 @@ void id_sort_by_name(ListBase *lb, ID *id) ID *idtest; /* insert alphabetically */ - if (lb->first!=lb->last) { + if (lb->first != lb->last) { BLI_remlink(lb, id); - idtest= lb->first; + idtest = lb->first; while (idtest) { - if (BLI_strcasecmp(idtest->name, id->name)>0 || (idtest->lib && !id->lib)) { + if (BLI_strcasecmp(idtest->name, id->name) > 0 || (idtest->lib && !id->lib)) { BLI_insertlinkbefore(lb, idtest, id); break; } - idtest= idtest->next; + idtest = idtest->next; } /* as last */ - if (idtest==NULL) { + if (idtest == NULL) { BLI_addtail(lb, id); } } @@ -1108,15 +1108,15 @@ void id_sort_by_name(ListBase *lb, ID *id) */ static ID *is_dupid(ListBase *lb, ID *id, const char *name) { - ID *idtest=NULL; + ID *idtest = NULL; - for ( idtest = lb->first; idtest; idtest = idtest->next ) { + for (idtest = lb->first; idtest; idtest = idtest->next) { /* if idtest is not a lib */ - if ( id != idtest && idtest->lib == NULL ) { + if (id != idtest && idtest->lib == NULL) { /* do not test alphabetic! */ /* optimized */ - if ( idtest->name[2] == name[0] ) { - if (strcmp(name, idtest->name+2)==0) break; + if (idtest->name[2] == name[0]) { + if (strcmp(name, idtest->name + 2) == 0) break; } } } @@ -1137,7 +1137,7 @@ static ID *is_dupid(ListBase *lb, ID *id, const char *name) static int check_for_dupid(ListBase *lb, ID *id, char *name) { ID *idtest; - int nr= 0, nrtest, a, left_len; + int nr = 0, nrtest, a, left_len; char in_use[64]; /* use as a boolean array, unrelated to name length */ char left[MAX_ID_NAME + 8], leftest[MAX_ID_NAME + 8]; @@ -1152,43 +1152,44 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name) idtest = is_dupid(lb, id, name); /* if there is no double, done */ - if ( idtest == NULL ) return 0; + if (idtest == NULL) return 0; /* we have a dup; need to make a new name */ /* quick check so we can reuse one of first 64 ids if vacant */ memset(in_use, 0, sizeof(in_use)); /* get name portion, number portion ("name.number") */ - left_len= BLI_split_name_num(left, &nr, name, '.'); + left_len = BLI_split_name_num(left, &nr, name, '.'); /* if new name will be too long, truncate it */ if (nr > 999 && left_len > (MAX_ID_NAME - 8)) { - left[MAX_ID_NAME - 8]= 0; - left_len= MAX_ID_NAME - 8; + left[MAX_ID_NAME - 8] = 0; + left_len = MAX_ID_NAME - 8; } else if (left_len > (MAX_ID_NAME - 7)) { - left[MAX_ID_NAME - 7]= 0; - left_len= MAX_ID_NAME - 7; + left[MAX_ID_NAME - 7] = 0; + left_len = MAX_ID_NAME - 7; } - for (idtest= lb->first; idtest; idtest= idtest->next) { - if ( (id != idtest) && - (idtest->lib == NULL) && - (*name == *(idtest->name+2)) && - (strncmp(name, idtest->name+2, left_len)==0) && - (BLI_split_name_num(leftest, &nrtest, idtest->name+2, '.') == left_len) - ) { + for (idtest = lb->first; idtest; idtest = idtest->next) { + if ( (id != idtest) && + (idtest->lib == NULL) && + (*name == *(idtest->name + 2)) && + (strncmp(name, idtest->name + 2, left_len) == 0) && + (BLI_split_name_num(leftest, &nrtest, idtest->name + 2, '.') == left_len) + ) + { if (nrtest < sizeof(in_use)) - in_use[nrtest]= 1; /* mark as used */ + in_use[nrtest] = 1; /* mark as used */ if (nr <= nrtest) - nr= nrtest+1; /* track largest unused */ + nr = nrtest + 1; /* track largest unused */ } } /* decide which value of nr to use */ - for (a=0; a < sizeof(in_use); a++) { - if (a>=nr) break; /* stop when we've check up to biggest */ - if ( in_use[a]==0 ) { /* found an unused value */ + for (a = 0; a < sizeof(in_use); a++) { + if (a >= nr) break; /* stop when we've check up to biggest */ + if (in_use[a] == 0) { /* found an unused value */ nr = a; break; } @@ -1198,13 +1199,13 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name) * rather than just chopping and adding numbers, * shave off the end chars until we have a unique name. * Check the null terminators match as well so we don't get Cube.000 -> Cube.00 */ - if (nr==0 && name[left_len]== '\0') { - int len = left_len-1; - idtest= is_dupid(lb, id, name); + if (nr == 0 && name[left_len] == '\0') { + int len = left_len - 1; + idtest = is_dupid(lb, id, name); - while (idtest && len> 1) { + while (idtest && len > 1) { name[len--] = '\0'; - idtest= is_dupid(lb, id, name); + idtest = is_dupid(lb, id, name); } if (idtest == NULL) return 1; /* otherwise just continue and use a number suffix */ @@ -1234,24 +1235,24 @@ static int check_for_dupid(ListBase *lb, ID *id, char *name) int new_id(ListBase *lb, ID *id, const char *tname) { int result; - char name[MAX_ID_NAME-2]; + char name[MAX_ID_NAME - 2]; /* if library, don't rename */ if (id->lib) return 0; /* if no libdata given, look up based on ID */ - if (lb==NULL) lb= which_libbase(G.main, GS(id->name)); + if (lb == NULL) lb = which_libbase(G.main, GS(id->name)); /* if no name given, use name of current ID * else make a copy (tname args can be const) */ - if (tname==NULL) - tname= id->name+2; + if (tname == NULL) + tname = id->name + 2; - strncpy(name, tname, sizeof(name)-1); + strncpy(name, tname, sizeof(name) - 1); /* if result > MAX_ID_NAME-3, strncpy don't put the final '\0' to name. * easier to assign each time then to check if its needed */ - name[sizeof(name)-1]= 0; + name[sizeof(name) - 1] = 0; if (name[0] == '\0') { /* disallow empty names */ @@ -1264,14 +1265,14 @@ int new_id(ListBase *lb, ID *id, const char *tname) } result = check_for_dupid(lb, id, name); - strcpy(id->name+2, name); + strcpy(id->name + 2, name); /* This was in 2.43 and previous releases * however all data in blender should be sorted, not just duplicate names * sorting should not hurt, but noting just incause it alters the way other * functions work, so sort every time */ #if 0 - if ( result ) + if (result) id_sort_by_name(lb, id); #endif @@ -1286,8 +1287,8 @@ void id_clear_lib_data(Main *bmain, ID *id) { BKE_id_lib_local_paths(bmain, id->lib, id); - id->lib= NULL; - id->flag= LIB_LOCAL; + id->lib = NULL; + id->flag = LIB_LOCAL; new_id(which_libbase(bmain, GS(id->name)), id, NULL); } @@ -1298,18 +1299,18 @@ void clear_id_newpoins(void) ID *id; int a; - a= set_listbasepointers(G.main, lbarray); + a = set_listbasepointers(G.main, lbarray); while (a--) { - id= lbarray[a]->first; + id = lbarray[a]->first; while (id) { - id->newid= NULL; + id->newid = NULL; id->flag &= ~LIB_NEW; - id= id->next; + id = id->next; } } } -#define LIBTAG(a) if (a && a->id.lib) {a->id.flag &=~LIB_INDIRECT; a->id.flag |= LIB_EXTERN;} +#define LIBTAG(a) if (a && a->id.lib) {a->id.flag &= ~LIB_INDIRECT; a->id.flag |= LIB_EXTERN; } static void lib_indirect_test_id(ID *id, Library *lib) { @@ -1323,17 +1324,17 @@ static void lib_indirect_test_id(ID *id, Library *lib) return; } - if (GS(id->name)==ID_OB) { - Object *ob= (Object *)id; + if (GS(id->name) == ID_OB) { + Object *ob = (Object *)id; Mesh *me; int a; -#if 0 /* XXX OLD ANIMSYS, NLASTRIPS ARE NO LONGER USED */ +#if 0 /* XXX OLD ANIMSYS, NLASTRIPS ARE NO LONGER USED */ // XXX old animation system! -------------------------------------- { bActionStrip *strip; - for (strip=ob->nlastrips.first; strip; strip=strip->next) { + for (strip = ob->nlastrips.first; strip; strip = strip->next) { LIBTAG(strip->object); LIBTAG(strip->act); LIBTAG(strip->ipo); @@ -1342,14 +1343,14 @@ static void lib_indirect_test_id(ID *id, Library *lib) // XXX: new animation system needs something like this? #endif - for (a=0; atotcol; a++) { + for (a = 0; a < ob->totcol; a++) { LIBTAG(ob->mat[a]); } LIBTAG(ob->dup_group); LIBTAG(ob->proxy); - me= ob->data; + me = ob->data; LIBTAG(me); } } @@ -1358,12 +1359,12 @@ void tag_main_lb(ListBase *lb, const short tag) { ID *id; if (tag) { - for (id= lb->first; id; id= id->next) { + for (id = lb->first; id; id = id->next) { id->flag |= LIB_DOIT; } } else { - for (id= lb->first; id; id= id->next) { + for (id = lb->first; id; id = id->next) { id->flag &= ~LIB_DOIT; } } @@ -1371,7 +1372,7 @@ void tag_main_lb(ListBase *lb, const short tag) void tag_main_idcode(struct Main *mainvar, const short type, const short tag) { - ListBase *lb= which_libbase(mainvar, type); + ListBase *lb = which_libbase(mainvar, type); tag_main_lb(lb, tag); } @@ -1381,7 +1382,7 @@ void tag_main(struct Main *mainvar, const short tag) ListBase *lbarray[MAX_LIBARRAY]; int a; - a= set_listbasepointers(mainvar, lbarray); + a = set_listbasepointers(mainvar, lbarray); while (a--) { tag_main_lb(lbarray[a], tag); } @@ -1391,27 +1392,27 @@ void tag_main(struct Main *mainvar, const short tag) * bmain is almost certainly G.main */ void BKE_library_make_local(Main *bmain, Library *lib, int untagged_only) { - ListBase *lbarray[MAX_LIBARRAY], tempbase={NULL, NULL}; + ListBase *lbarray[MAX_LIBARRAY], tempbase = {NULL, NULL}; ID *id, *idn; int a; - a= set_listbasepointers(bmain, lbarray); + a = set_listbasepointers(bmain, lbarray); while (a--) { - id= lbarray[a]->first; + id = lbarray[a]->first; while (id) { - id->newid= NULL; - idn= id->next; /* id is possibly being inserted again */ + id->newid = NULL; + idn = id->next; /* id is possibly being inserted again */ /* The check on the second line (LIB_PRE_EXISTING) is done so its * possible to tag data you don't want to be made local, used for * appending data, so any libdata already linked wont become local * (very nasty to discover all your links are lost after appending) * */ - if (id->flag & (LIB_EXTERN|LIB_INDIRECT|LIB_NEW) && - (untagged_only==0 || !(id->flag & LIB_PRE_EXISTING))) + if (id->flag & (LIB_EXTERN | LIB_INDIRECT | LIB_NEW) && + (untagged_only == 0 || !(id->flag & LIB_PRE_EXISTING))) { - if (lib==NULL || id->lib==lib) { + if (lib == NULL || id->lib == lib) { if (id->lib) { id_clear_lib_data(bmain, id); /* sets 'id->flag' */ @@ -1420,15 +1421,15 @@ void BKE_library_make_local(Main *bmain, Library *lib, int untagged_only) id_sort_by_name(lbarray[a], id); } else { - id->flag &= ~(LIB_EXTERN|LIB_INDIRECT|LIB_NEW); + id->flag &= ~(LIB_EXTERN | LIB_INDIRECT | LIB_NEW); } } } - id= idn; + id = idn; } /* patch2: make it aphabetically */ - while ( (id=tempbase.first) ) { + while ( (id = tempbase.first) ) { BLI_remlink(&tempbase, id); BLI_addtail(lbarray[a], id); new_id(lbarray[a], id, NULL); @@ -1436,9 +1437,9 @@ void BKE_library_make_local(Main *bmain, Library *lib, int untagged_only) } /* patch 3: make sure library data isn't indirect falsely... */ - a= set_listbasepointers(bmain, lbarray); + a = set_listbasepointers(bmain, lbarray); while (a--) { - for (id= lbarray[a]->first; id; id=id->next) + for (id = lbarray[a]->first; id; id = id->next) lib_indirect_test_id(id, lib); } } @@ -1451,34 +1452,34 @@ void test_idbutton(char *name) ID *idtest; - lb= which_libbase(G.main, GS(name-2) ); - if (lb==NULL) return; + lb = which_libbase(G.main, GS(name - 2) ); + if (lb == NULL) return; /* search for id */ - idtest= BLI_findstring(lb, name, offsetof(ID, name) + 2); + idtest = BLI_findstring(lb, name, offsetof(ID, name) + 2); - if (idtest) if ( new_id(lb, idtest, name)==0 ) id_sort_by_name(lb, idtest); + if (idtest) if (new_id(lb, idtest, name) == 0) id_sort_by_name(lb, idtest); } void text_idbutton(struct ID *id, char *text) { if (id) { - if (GS(id->name)==ID_SCE) + if (GS(id->name) == ID_SCE) strcpy(text, "SCE: "); - else if (GS(id->name)==ID_SCR) + else if (GS(id->name) == ID_SCR) strcpy(text, "SCR: "); - else if (GS(id->name)==ID_MA && ((Material*)id)->use_nodes) + else if (GS(id->name) == ID_MA && ((Material *)id)->use_nodes) strcpy(text, "NT: "); else { - text[0]= id->name[0]; - text[1]= id->name[1]; - text[2]= ':'; - text[3]= ' '; - text[4]= 0; + text[0] = id->name[0]; + text[1] = id->name[1]; + text[2] = ':'; + text[3] = ' '; + text[4] = 0; } } else { - text[0]= '\0'; + text[0] = '\0'; } } @@ -1486,19 +1487,19 @@ void rename_id(ID *id, const char *name) { ListBase *lb; - BLI_strncpy(id->name+2, name, sizeof(id->name)-2); - lb= which_libbase(G.main, GS(id->name) ); + BLI_strncpy(id->name + 2, name, sizeof(id->name) - 2); + lb = which_libbase(G.main, GS(id->name) ); new_id(lb, id, name); } void name_uiprefix_id(char *name, ID *id) { - name[0] = id->lib ? 'L':' '; - name[1] = id->flag & LIB_FAKEUSER ? 'F': (id->us==0)?'0':' '; + name[0] = id->lib ? 'L' : ' '; + name[1] = id->flag & LIB_FAKEUSER ? 'F' : (id->us == 0) ? '0' : ' '; name[2] = ' '; - strcpy(name+3, id->name+2); + strcpy(name + 3, id->name + 2); } void BKE_library_filepath_set(Library *lib, const char *filepath) @@ -1519,7 +1520,7 @@ void BKE_library_filepath_set(Library *lib, const char *filepath) * outliner, and its not really supported but allow from here for now * since making local could cause this to be directly linked - campbell */ - const char *basepath= lib->parent ? lib->parent->filepath : G.main->name; + const char *basepath = lib->parent ? lib->parent->filepath : G.main->name; BLI_path_abs(lib->filepath, basepath); } } diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c index 5b824c04836..e212d45742a 100644 --- a/source/blender/blenkernel/intern/modifier.c +++ b/source/blender/blenkernel/intern/modifier.c @@ -68,12 +68,12 @@ ModifierTypeInfo *modifierType_getInfo(ModifierType type) { - static ModifierTypeInfo *types[NUM_MODIFIER_TYPES]= {NULL}; + static ModifierTypeInfo *types[NUM_MODIFIER_TYPES] = {NULL}; static int types_init = 1; if (types_init) { modifier_type_init(types); /* MOD_utils.c */ - types_init= 0; + types_init = 0; } /* type unsigned, no need to check < 0 */ @@ -97,7 +97,7 @@ ModifierData *modifier_new(int type) md->type = type; md->mode = eModifierMode_Realtime - | eModifierMode_Render | eModifierMode_Expanded; + | eModifierMode_Render | eModifierMode_Expanded; if (mti->flags & eModifierTypeFlag_EnableInEditmode) md->mode |= eModifierMode_Editmode; @@ -137,8 +137,8 @@ int modifier_supportsMapping(ModifierData *md) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - return (mti->type==eModifierTypeType_OnlyDeform || - (mti->flags & eModifierTypeFlag_SupportsMapping)); + return (mti->type == eModifierTypeType_OnlyDeform || + (mti->flags & eModifierTypeFlag_SupportsMapping)); } int modifier_isPreview(ModifierData *md) @@ -158,8 +158,8 @@ ModifierData *modifiers_findByType(Object *ob, ModifierType type) { ModifierData *md = ob->modifiers.first; - for (; md; md=md->next) - if (md->type==type) + for (; md; md = md->next) + if (md->type == type) break; return md; @@ -175,7 +175,7 @@ void modifiers_clearErrors(Object *ob) ModifierData *md = ob->modifiers.first; /* int qRedraw = 0; */ - for (; md; md=md->next) { + for (; md; md = md->next) { if (md->error) { MEM_freeN(md->error); md->error = NULL; @@ -186,11 +186,11 @@ void modifiers_clearErrors(Object *ob) } void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk, - void *userData) + void *userData) { ModifierData *md = ob->modifiers.first; - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); if (mti->foreachObjectLink) @@ -202,7 +202,7 @@ void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData) { ModifierData *md = ob->modifiers.first; - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData); @@ -218,7 +218,7 @@ void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData) { ModifierData *md = ob->modifiers.first; - for (; md; md=md->next) { + for (; md; md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); if (mti->foreachTexLink) @@ -240,12 +240,12 @@ int modifier_couldBeCage(struct Scene *scene, ModifierData *md) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - md->scene= scene; + md->scene = scene; - return ( (md->mode & eModifierMode_Realtime) && - (md->mode & eModifierMode_Editmode) && - (!mti->isDisabled || !mti->isDisabled(md, 0)) && - modifier_supportsMapping(md)); + return ((md->mode & eModifierMode_Realtime) && + (md->mode & eModifierMode_Editmode) && + (!mti->isDisabled || !mti->isDisabled(md, 0)) && + modifier_supportsMapping(md)); } int modifier_sameTopology(ModifierData *md) @@ -269,7 +269,7 @@ void modifier_setError(ModifierData *md, const char *format, ...) va_start(ap, format); vsnprintf(buffer, sizeof(buffer), format, ap); va_end(ap); - buffer[sizeof(buffer) - 1]= '\0'; + buffer[sizeof(buffer) - 1] = '\0'; if (md->error) MEM_freeN(md->error); @@ -287,19 +287,19 @@ void modifier_setError(ModifierData *md, const char *format, ...) */ int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_) { - ModifierData *md = (virtual_)? modifiers_getVirtualModifierList(ob): ob->modifiers.first; + ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob) : ob->modifiers.first; int i, cageIndex = -1; if (lastPossibleCageIndex_r) { /* ensure the value is initialized */ - *lastPossibleCageIndex_r= -1; + *lastPossibleCageIndex_r = -1; } /* Find the last modifier acting on the cage. */ - for (i=0; md; i++, md=md->next) { + for (i = 0; md; i++, md = md->next) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - md->scene= scene; + md->scene = scene; if (!(md->mode & eModifierMode_Realtime)) continue; if (!(md->mode & eModifierMode_Editmode)) continue; @@ -344,7 +344,7 @@ int modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); - md->scene= scene; + md->scene = scene; if ((md->mode & required_mode) != required_mode) return 0; if (mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return 0; @@ -396,7 +396,7 @@ CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierDat } /* reverse the list so it's in the correct order */ - BLI_linklist_reverse((LinkNode**)&dataMasks); + BLI_linklist_reverse((LinkNode **)&dataMasks); return dataMasks; } @@ -431,19 +431,19 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob) if (init) { md = modifier_new(eModifierType_Armature); - amd = *((ArmatureModifierData*) md); + amd = *((ArmatureModifierData *) md); modifier_free(md); md = modifier_new(eModifierType_Curve); - cmd = *((CurveModifierData*) md); + cmd = *((CurveModifierData *) md); modifier_free(md); md = modifier_new(eModifierType_Lattice); - lmd = *((LatticeModifierData*) md); + lmd = *((LatticeModifierData *) md); modifier_free(md); md = modifier_new(eModifierType_ShapeKey); - smd = *((ShapeKeyModifierData*) md); + smd = *((ShapeKeyModifierData *) md); modifier_free(md); amd.modifier.mode |= eModifierMode_Virtual; @@ -457,19 +457,19 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob) md = ob->modifiers.first; if (ob->parent) { - if (ob->parent->type==OB_ARMATURE && ob->partype==PARSKEL) { + if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) { amd.object = ob->parent; amd.modifier.next = md; - amd.deformflag= ((bArmature *)(ob->parent->data))->deformflag; + amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag; md = &amd.modifier; } - else if (ob->parent->type==OB_CURVE && ob->partype==PARSKEL) { + else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) { cmd.object = ob->parent; cmd.defaxis = ob->trackflag + 1; cmd.modifier.next = md; md = &cmd.modifier; } - else if (ob->parent->type==OB_LATTICE && ob->partype==PARSKEL) { + else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) { lmd.object = ob->parent; lmd.modifier.next = md; md = &lmd.modifier; @@ -479,9 +479,9 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob) /* shape key modifier, not yet for curves */ if (ELEM(ob->type, OB_MESH, OB_LATTICE) && ob_get_key(ob)) { if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE)) - smd.modifier.mode |= eModifierMode_Editmode|eModifierMode_OnCage; + smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage; else - smd.modifier.mode &= ~eModifierMode_Editmode|eModifierMode_OnCage; + smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage; smd.modifier.next = md; md = &smd.modifier; @@ -496,12 +496,12 @@ ModifierData *modifiers_getVirtualModifierList(Object *ob) Object *modifiers_isDeformedByArmature(Object *ob) { ModifierData *md = modifiers_getVirtualModifierList(ob); - ArmatureModifierData *amd= NULL; + ArmatureModifierData *amd = NULL; /* return the first selected armature, this lets us use multiple armatures */ - for (; md; md=md->next) { - if (md->type==eModifierType_Armature) { - amd = (ArmatureModifierData*) md; + for (; md; md = md->next) { + if (md->type == eModifierType_Armature) { + amd = (ArmatureModifierData *) md; if (amd->object && (amd->object->flag & SELECT)) return amd->object; } @@ -520,12 +520,12 @@ Object *modifiers_isDeformedByArmature(Object *ob) Object *modifiers_isDeformedByLattice(Object *ob) { ModifierData *md = modifiers_getVirtualModifierList(ob); - LatticeModifierData *lmd= NULL; + LatticeModifierData *lmd = NULL; /* return the first selected lattice, this lets us use multiple lattices */ - for (; md; md=md->next) { - if (md->type==eModifierType_Lattice) { - lmd = (LatticeModifierData*) md; + for (; md; md = md->next) { + if (md->type == eModifierType_Lattice) { + lmd = (LatticeModifierData *) md; if (lmd->object && (lmd->object->flag & SELECT)) return lmd->object; } @@ -543,10 +543,10 @@ int modifiers_usesArmature(Object *ob, bArmature *arm) { ModifierData *md = modifiers_getVirtualModifierList(ob); - for (; md; md=md->next) { - if (md->type==eModifierType_Armature) { - ArmatureModifierData *amd = (ArmatureModifierData*) md; - if (amd->object && amd->object->data==arm) + for (; md; md = md->next) { + if (md->type == eModifierType_Armature) { + ArmatureModifierData *amd = (ArmatureModifierData *) md; + if (amd->object && amd->object->data == arm) return 1; } } @@ -556,9 +556,9 @@ int modifiers_usesArmature(Object *ob, bArmature *arm) int modifier_isCorrectableDeformed(ModifierData *md) { - if (md->type==eModifierType_Armature) + if (md->type == eModifierType_Armature) return 1; - if (md->type==eModifierType_ShapeKey) + if (md->type == eModifierType_ShapeKey) return 1; return 0; @@ -568,11 +568,11 @@ int modifiers_isCorrectableDeformed(Object *ob) { ModifierData *md = modifiers_getVirtualModifierList(ob); - for (; md; md=md->next) { - if (ob->mode==OB_MODE_EDIT && (md->mode & eModifierMode_Editmode)==0); + for (; md; md = md->next) { + if (ob->mode == OB_MODE_EDIT && (md->mode & eModifierMode_Editmode) == 0) ; else - if (modifier_isCorrectableDeformed(md)) - return 1; + if (modifier_isCorrectableDeformed(md)) + return 1; } return 0; } @@ -593,22 +593,22 @@ int modifiers_isPreview(Object *ob) int modifiers_indexInObject(Object *ob, ModifierData *md_seek) { - int i= 0; + int i = 0; ModifierData *md; - for (md=ob->modifiers.first; (md && md_seek!=md); md=md->next, i++); - if (!md) return -1; /* modifier isn't in the object */ + for (md = ob->modifiers.first; (md && md_seek != md); md = md->next, i++) ; + if (!md) return -1; /* modifier isn't in the object */ return i; } void modifier_freeTemporaryData(ModifierData *md) { if (md->type == eModifierType_Armature) { - ArmatureModifierData *amd= (ArmatureModifierData*)md; + ArmatureModifierData *amd = (ArmatureModifierData *)md; if (amd->prevCos) { MEM_freeN(amd->prevCos); - amd->prevCos= NULL; + amd->prevCos = NULL; } } } @@ -625,7 +625,7 @@ void test_object_modifiers(Object *ob) for (md = ob->modifiers.first; md; md = md->next) { if (md->type == eModifierType_Multires) { - MultiresModifierData *mmd = (MultiresModifierData*)md; + MultiresModifierData *mmd = (MultiresModifierData *)md; multiresModifier_set_levels_from_disps(mmd, ob); } diff --git a/source/blender/blenkernel/intern/multires.c b/source/blender/blenkernel/intern/multires.c index 35ee0549554..6c3032cb279 100644 --- a/source/blender/blenkernel/intern/multires.c +++ b/source/blender/blenkernel/intern/multires.c @@ -82,30 +82,30 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm void multires_customdata_delete(Mesh *me) { if (me->edit_btmesh) { - BMEditMesh *em= me->edit_btmesh; + BMEditMesh *em = me->edit_btmesh; /* CustomData_external_remove is used here only to mark layer * as non-external for further free-ing, so zero element count * looks safer than em->totface */ CustomData_external_remove(&em->bm->ldata, &me->id, - CD_MDISPS, 0); + CD_MDISPS, 0); BM_data_layer_free(em->bm, &em->bm->ldata, CD_MDISPS); } else { CustomData_external_remove(&me->ldata, &me->id, - CD_MDISPS, me->totloop); + CD_MDISPS, me->totloop); CustomData_free_layer_active(&me->ldata, CD_MDISPS, - me->totloop); + me->totloop); } } /** Grid hiding **/ static BLI_bitmap multires_mdisps_upsample_hidden(BLI_bitmap lo_hidden, - int lo_level, - int hi_level, + int lo_level, + int hi_level, - /* assumed to be at hi_level (or - * null) */ - BLI_bitmap prev_hidden) + /* assumed to be at hi_level (or + * null) */ + BLI_bitmap prev_hidden) { BLI_bitmap subd; int hi_gridsize = ccg_gridsize(hi_level); @@ -163,8 +163,8 @@ static BLI_bitmap multires_mdisps_upsample_hidden(BLI_bitmap lo_hidden, } static BLI_bitmap multires_mdisps_downsample_hidden(BLI_bitmap old_hidden, - int old_level, - int new_level) + int old_level, + int new_level) { BLI_bitmap new_hidden; int new_gridsize = ccg_gridsize(new_level); @@ -174,16 +174,16 @@ static BLI_bitmap multires_mdisps_downsample_hidden(BLI_bitmap old_hidden, BLI_assert(new_level <= old_level); factor = ccg_factor(new_level, old_level); new_hidden = BLI_BITMAP_NEW(new_gridsize * new_gridsize, - "downsample hidden"); + "downsample hidden"); for (y = 0; y < new_gridsize; y++) { for (x = 0; x < new_gridsize; x++) { old_value = BLI_BITMAP_GET(old_hidden, - factor*y*old_gridsize + x*factor); + factor * y * old_gridsize + x * factor); - BLI_BITMAP_MODIFY(new_hidden, y*new_gridsize + x, old_value); + BLI_BITMAP_MODIFY(new_hidden, y * new_gridsize + x, old_value); } } @@ -191,7 +191,7 @@ static BLI_bitmap multires_mdisps_downsample_hidden(BLI_bitmap old_hidden, } static void multires_output_hidden_to_ccgdm(CCGDerivedMesh *ccgdm, - Mesh *me, int level) + Mesh *me, int level) { const MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); BLI_bitmap *grid_hidden = ccgdm->gridHidden; @@ -208,7 +208,7 @@ static void multires_output_hidden_to_ccgdm(CCGDerivedMesh *ccgdm, if (gh) { grid_hidden[g] = - multires_mdisps_downsample_hidden(gh, md->level, level); + multires_mdisps_downsample_hidden(gh, md->level, level); } } } @@ -227,9 +227,9 @@ static void multires_mdisps_subdivide_hidden(MDisps *md, int new_level) return; subd = multires_mdisps_upsample_hidden(md->hidden, - md->level, - new_level, - NULL); + md->level, + new_level, + NULL); /* swap in the subdivided data */ MEM_freeN(md->hidden); @@ -239,7 +239,7 @@ static void multires_mdisps_subdivide_hidden(MDisps *md, int new_level) static MDisps *multires_mdisps_initialize_hidden(Mesh *me, int level) { MDisps *mdisps = CustomData_add_layer(&me->ldata, CD_MDISPS, - CD_CALLOC, 0, me->totloop); + CD_CALLOC, 0, me->totloop); int gridsize = ccg_gridsize(level); int gridarea = gridsize * gridsize; int i, j, k; @@ -274,7 +274,7 @@ static MDisps *multires_mdisps_initialize_hidden(Mesh *me, int level) DerivedMesh *get_multires_dm(Scene *scene, MultiresModifierData *mmd, Object *ob) { - ModifierData *md= (ModifierData *)mmd; + ModifierData *md = (ModifierData *)mmd; ModifierTypeInfo *mti = modifierType_getInfo(md->type); DerivedMesh *tdm = mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH); DerivedMesh *dm; @@ -294,7 +294,7 @@ MultiresModifierData *find_multires_modifier_before(Scene *scene, ModifierData * for (md = lastmd; md; md = md->prev) { if (md->type == eModifierType_Multires) { if (modifier_isEnabled(scene, md, eModifierMode_Realtime)) - return (MultiresModifierData*)md; + return (MultiresModifierData *)md; } } @@ -307,16 +307,16 @@ MultiresModifierData *find_multires_modifier_before(Scene *scene, ModifierData * MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, int use_first) { ModifierData *md; - MultiresModifierData *mmd= NULL, *firstmmd= NULL; + MultiresModifierData *mmd = NULL, *firstmmd = NULL; /* find first active multires modifier */ for (md = ob->modifiers.first; md; md = md->next) { if (md->type == eModifierType_Multires) { if (!firstmmd) - firstmmd= (MultiresModifierData*)md; + firstmmd = (MultiresModifierData *)md; if (modifier_isEnabled(scene, md, eModifierMode_Realtime)) { - mmd= (MultiresModifierData*)md; + mmd = (MultiresModifierData *)md; break; } } @@ -334,11 +334,11 @@ MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, int use_fi static int multires_get_level(Object *ob, MultiresModifierData *mmd, int render) { if (render) - return (mmd->modifier.scene)? get_render_subsurf_level(&mmd->modifier.scene->r, mmd->renderlvl): mmd->renderlvl; + return (mmd->modifier.scene) ? get_render_subsurf_level(&mmd->modifier.scene->r, mmd->renderlvl) : mmd->renderlvl; else if (ob->mode == OB_MODE_SCULPT) return mmd->sculptlvl; else - return (mmd->modifier.scene)? get_render_subsurf_level(&mmd->modifier.scene->r, mmd->lvl): mmd->lvl; + return (mmd->modifier.scene) ? get_render_subsurf_level(&mmd->modifier.scene->r, mmd->lvl) : mmd->lvl; } static void multires_set_tot_level(Object *ob, MultiresModifierData *mmd, int lvl) @@ -354,7 +354,7 @@ static void multires_set_tot_level(Object *ob, MultiresModifierData *mmd, int lv static void multires_dm_mark_as_modified(DerivedMesh *dm, MultiresModifiedFlags flags) { - CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)dm; + CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm; ccgdm->multires.modified_flags |= flags; } @@ -368,13 +368,13 @@ void multires_force_update(Object *ob) { if (ob) { if (ob->derivedFinal) { - ob->derivedFinal->needsFree =1; + ob->derivedFinal->needsFree = 1; ob->derivedFinal->release(ob->derivedFinal); ob->derivedFinal = NULL; } if (ob->sculpt && ob->sculpt->pbvh) { BLI_pbvh_free(ob->sculpt->pbvh); - ob->sculpt->pbvh= NULL; + ob->sculpt->pbvh = NULL; } } } @@ -394,9 +394,9 @@ void multires_force_render_update(Object *ob) } int multiresModifier_reshapeFromDM(Scene *scene, MultiresModifierData *mmd, - Object *ob, DerivedMesh *srcdm) + Object *ob, DerivedMesh *srcdm) { - DerivedMesh *mrdm = get_multires_dm (scene, mmd, ob); + DerivedMesh *mrdm = get_multires_dm(scene, mmd, ob); if (mrdm && srcdm && mrdm->getNumVerts(mrdm) == srcdm->getNumVerts(srcdm)) { multires_mvert_to_ss(mrdm, srcdm->getVertArray(srcdm)); @@ -422,7 +422,7 @@ int multiresModifier_reshape(Scene *scene, MultiresModifierData *mmd, Object *ds } int multiresModifier_reshapeFromDeformMod(Scene *scene, MultiresModifierData *mmd, - Object *ob, ModifierData *md) + Object *ob, ModifierData *md) { ModifierTypeInfo *mti = modifierType_getInfo(md->type); DerivedMesh *dm, *ndm; @@ -434,20 +434,20 @@ int multiresModifier_reshapeFromDeformMod(Scene *scene, MultiresModifierData *mm /* Create DerivedMesh for deformation modifier */ dm = get_multires_dm(scene, mmd, ob); - numVerts= dm->getNumVerts(dm); - deformedVerts= MEM_callocN(sizeof(float)*numVerts*3, "multiresReshape_deformVerts"); + numVerts = dm->getNumVerts(dm); + deformedVerts = MEM_callocN(sizeof(float) * numVerts * 3, "multiresReshape_deformVerts"); dm->getVertCos(dm, deformedVerts); mti->deformVerts(md, ob, dm, deformedVerts, numVerts, 0, 0); - ndm= CDDM_copy(dm); + ndm = CDDM_copy(dm); CDDM_apply_vert_coords(ndm, deformedVerts); MEM_freeN(deformedVerts); dm->release(dm); /* Reshaping */ - result= multiresModifier_reshapeFromDM(scene, mmd, ob, ndm); + result = multiresModifier_reshapeFromDM(scene, mmd, ob, ndm); /* Cleanup */ ndm->release(ndm); @@ -460,19 +460,19 @@ static int get_levels_from_disps(Object *ob) { Mesh *me = ob->data; MDisps *mdisp, *md; - int i, j, totlvl= 0; + int i, j, totlvl = 0; mdisp = CustomData_get_layer(&me->ldata, CD_MDISPS); for (i = 0; i < me->totpoly; ++i) { md = mdisp + me->mpoly[i].loopstart; - for (j=0; jmpoly[i].totloop; j++, md++) { + for (j = 0; j < me->mpoly[i].totloop; j++, md++) { if (md->totdisp == 0) continue; while (1) { - int side = (1 << (totlvl-1)) + 1; - int lvl_totdisp = side*side; + int side = (1 << (totlvl - 1)) + 1; + int lvl_totdisp = side * side; if (md->totdisp == lvl_totdisp) break; else if (md->totdisp < lvl_totdisp) @@ -510,7 +510,7 @@ void multiresModifier_set_levels_from_disps(MultiresModifierData *mmd, Object *o static void multires_set_tot_mdisps(Mesh *me, int lvl) { - MDisps *mdisps= CustomData_get_layer(&me->ldata, CD_MDISPS); + MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); int i; if (mdisps) { @@ -554,18 +554,18 @@ static void multires_copy_grid(float (*gridA)[3], float (*gridB)[3], int sizeA, int x, y, j, skip; if (sizeA > sizeB) { - skip = (sizeA-1)/(sizeB-1); + skip = (sizeA - 1) / (sizeB - 1); for (j = 0, y = 0; y < sizeB; y++) for (x = 0; x < sizeB; x++, j++) - copy_v3_v3(gridA[y*skip*sizeA + x*skip], gridB[j]); + copy_v3_v3(gridA[y * skip * sizeA + x * skip], gridB[j]); } else { - skip = (sizeB-1)/(sizeA-1); + skip = (sizeB - 1) / (sizeA - 1); for (j = 0, y = 0; y < sizeA; y++) for (x = 0; x < sizeA; x++, j++) - copy_v3_v3(gridA[j], gridB[y*skip*sizeB + x*skip]); + copy_v3_v3(gridA[j], gridB[y * skip * sizeB + x * skip]); } } @@ -574,30 +574,30 @@ static void multires_copy_dm_grid(DMGridData *gridA, DMGridData *gridB, int size int x, y, j, skip; if (sizeA > sizeB) { - skip = (sizeA-1)/(sizeB-1); + skip = (sizeA - 1) / (sizeB - 1); for (j = 0, y = 0; y < sizeB; y++) for (x = 0; x < sizeB; x++, j++) - copy_v3_v3(gridA[y*skip*sizeA + x*skip].co, gridB[j].co); + copy_v3_v3(gridA[y * skip * sizeA + x * skip].co, gridB[j].co); } else { - skip = (sizeB-1)/(sizeA-1); + skip = (sizeB - 1) / (sizeA - 1); for (j = 0, y = 0; y < sizeA; y++) for (x = 0; x < sizeA; x++, j++) - copy_v3_v3(gridA[j].co, gridB[y*skip*sizeB + x*skip].co); + copy_v3_v3(gridA[j].co, gridB[y * skip * sizeB + x * skip].co); } } static void multires_del_higher(MultiresModifierData *mmd, Object *ob, int lvl) { - Mesh *me = (Mesh*)ob->data; + Mesh *me = (Mesh *)ob->data; int levels = mmd->totlvl - lvl; MDisps *mdisps; multires_set_tot_mdisps(me, mmd->totlvl); CustomData_external_read(&me->ldata, &me->id, CD_MASK_MDISPS, me->totloop); - mdisps= CustomData_get_layer(&me->ldata, CD_MDISPS); + mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); multires_force_update(ob); @@ -609,8 +609,8 @@ static void multires_del_higher(MultiresModifierData *mmd, Object *ob, int lvl) int i, j; for (i = 0; i < me->totpoly; ++i) { - for (j=0; jmpoly[i].totloop; j++) { - MDisps *mdisp= &mdisps[me->mpoly[i].loopstart+j]; + for (j = 0; j < me->mpoly[i].totloop; j++) { + MDisps *mdisp = &mdisps[me->mpoly[i].loopstart + j]; float (*disps)[3], (*ndisps)[3], (*hdisps)[3]; int totdisp = multires_grid_tot[lvl]; @@ -622,15 +622,15 @@ static void multires_del_higher(MultiresModifierData *mmd, Object *ob, int lvl) multires_copy_grid(ndisps, hdisps, nsize, hsize); if (mdisp->hidden) { BLI_bitmap gh = - multires_mdisps_downsample_hidden(mdisp->hidden, - mdisp->level, - lvl); + multires_mdisps_downsample_hidden(mdisp->hidden, + mdisp->level, + lvl); MEM_freeN(mdisp->hidden); mdisp->hidden = gh; } - ndisps += nsize*nsize; - hdisps += hsize*hsize; + ndisps += nsize * nsize; + hdisps += hsize * hsize; MEM_freeN(mdisp->disps); mdisp->disps = disps; @@ -657,7 +657,7 @@ void multiresModifier_del_levels(MultiresModifierData *mmd, Object *ob, int dire multires_set_tot_mdisps(me, mmd->totlvl); CustomData_external_read(&me->ldata, &me->id, CD_MASK_MDISPS, me->totloop); - mdisps= CustomData_get_layer(&me->ldata, CD_MDISPS); + mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); multires_force_update(ob); @@ -670,7 +670,7 @@ void multiresModifier_del_levels(MultiresModifierData *mmd, Object *ob, int dire static DerivedMesh *multires_dm_create_local(Object *ob, DerivedMesh *dm, int lvl, int totlvl, int simple) { - MultiresModifierData mmd= {{NULL}}; + MultiresModifierData mmd = {{NULL}}; mmd.lvl = lvl; mmd.sculptlvl = lvl; @@ -683,7 +683,7 @@ static DerivedMesh *multires_dm_create_local(Object *ob, DerivedMesh *dm, int lv static DerivedMesh *subsurf_dm_create_local(Object *ob, DerivedMesh *dm, int lvl, int simple, int optimal, int plain_uv) { - SubsurfModifierData smd= {{NULL}}; + SubsurfModifierData smd = {{NULL}}; smd.levels = smd.renderLevels = lvl; if (!plain_uv) @@ -742,8 +742,8 @@ void multiresModifier_base_apply(MultiresModifierData *mmd, Object *ob) cddm = CDDM_from_mesh(me, NULL); pmap = cddm->getPolyMap(ob, cddm); - origco = MEM_callocN(sizeof(float)*3*me->totvert, "multires apply base origco"); - for (i = 0; i < me->totvert ;++i) + origco = MEM_callocN(sizeof(float) * 3 * me->totvert, "multires apply base origco"); + for (i = 0; i < me->totvert; ++i) copy_v3_v3(origco[i], me->mvert[i].co); for (i = 0; i < me->totvert; ++i) { @@ -833,7 +833,7 @@ static void multires_subdivide(MultiresModifierData *mmd, Object *ob, int totlvl { Mesh *me = ob->data; MDisps *mdisps; - int lvl= mmd->totlvl; + int lvl = mmd->totlvl; if ((totlvl > multires_max_levels) || (me->totpoly == 0)) return; @@ -867,12 +867,12 @@ static void multires_subdivide(MultiresModifierData *mmd, Object *ob, int totlvl lowGridSize = lowdm->getGridSize(lowdm); lowGridData = lowdm->getGridData(lowdm); - subGridData = MEM_callocN(sizeof(float*)*numGrids, "subGridData*"); + subGridData = MEM_callocN(sizeof(float *) * numGrids, "subGridData*"); for (i = 0; i < numGrids; ++i) { /* backup subsurf grids */ - subGridData[i] = MEM_callocN(sizeof(DMGridData)*highGridSize*highGridSize, "subGridData"); - memcpy(subGridData[i], highGridData[i], sizeof(DMGridData)*highGridSize*highGridSize); + subGridData[i] = MEM_callocN(sizeof(DMGridData) * highGridSize * highGridSize, "subGridData"); + memcpy(subGridData[i], highGridData[i], sizeof(DMGridData) * highGridSize * highGridSize); /* overwrite with current displaced grids */ multires_copy_dm_grid(highGridData[i], lowGridData[i], highGridSize, lowGridSize); @@ -882,7 +882,7 @@ static void multires_subdivide(MultiresModifierData *mmd, Object *ob, int totlvl lowdm->release(lowdm); /* subsurf higher levels again with displaced data */ - ss= ((CCGDerivedMesh*)highdm)->ss; + ss = ((CCGDerivedMesh *)highdm)->ss; ccgSubSurf_updateFromFaces(ss, lvl, NULL, 0); ccgSubSurf_updateLevels(ss, lvl, NULL, 0); @@ -908,7 +908,7 @@ static void multires_subdivide(MultiresModifierData *mmd, Object *ob, int totlvl void multiresModifier_subdivide(MultiresModifierData *mmd, Object *ob, int updateblock, int simple) { - multires_subdivide(mmd, ob, mmd->totlvl+1, updateblock, simple); + multires_subdivide(mmd, ob, mmd->totlvl + 1, updateblock, simple); } void grid_tangent(int gridSize, int index, int x, int y, int axis, DMGridData **gridData, float t[3]) @@ -916,28 +916,28 @@ void grid_tangent(int gridSize, int index, int x, int y, int axis, DMGridData ** if (axis == 0) { if (x == gridSize - 1) { if (y == gridSize - 1) - sub_v3_v3v3(t, gridData[index][x + gridSize*(y - 1)].co, gridData[index][x - 1 + gridSize*(y - 1)].co); + sub_v3_v3v3(t, gridData[index][x + gridSize * (y - 1)].co, gridData[index][x - 1 + gridSize * (y - 1)].co); else - sub_v3_v3v3(t, gridData[index][x + gridSize*y].co, gridData[index][x - 1 + gridSize*y].co); + sub_v3_v3v3(t, gridData[index][x + gridSize * y].co, gridData[index][x - 1 + gridSize * y].co); } else - sub_v3_v3v3(t, gridData[index][x + 1 + gridSize*y].co, gridData[index][x + gridSize*y].co); + sub_v3_v3v3(t, gridData[index][x + 1 + gridSize * y].co, gridData[index][x + gridSize * y].co); } else if (axis == 1) { if (y == gridSize - 1) { if (x == gridSize - 1) - sub_v3_v3v3(t, gridData[index][x - 1 + gridSize*y].co, gridData[index][x - 1 + gridSize*(y - 1)].co); + sub_v3_v3v3(t, gridData[index][x - 1 + gridSize * y].co, gridData[index][x - 1 + gridSize * (y - 1)].co); else - sub_v3_v3v3(t, gridData[index][x + gridSize*y].co, gridData[index][x + gridSize*(y - 1)].co); + sub_v3_v3v3(t, gridData[index][x + gridSize * y].co, gridData[index][x + gridSize * (y - 1)].co); } else - sub_v3_v3v3(t, gridData[index][x + gridSize*(y + 1)].co, gridData[index][x + gridSize*y].co); + sub_v3_v3v3(t, gridData[index][x + gridSize * (y + 1)].co, gridData[index][x + gridSize * y].co); } } static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm2, DispOp op, DMGridData **oldGridData, int totlvl) { - CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)dm; + CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm; DMGridData **gridData, **subGridData; MPoly *mpoly = me->mpoly; MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); @@ -968,10 +968,10 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm gridSize = dm->getGridSize(dm); gridData = dm->getGridData(dm); gridOffset = dm->getGridOffset(dm); - subGridData = (oldGridData)? oldGridData: gridData; + subGridData = (oldGridData) ? oldGridData : gridData; dGridSize = multires_side_tot[totlvl]; - dSkip = (dGridSize-1)/(gridSize-1); + dSkip = (dGridSize - 1) / (gridSize - 1); k = 0; /*current loop/mdisp index within the mloop array*/ @@ -982,7 +982,7 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm int S, x, y, gIndex = gridOffset[i]; for (S = 0; S < numVerts; ++S, ++gIndex, ++k) { - MDisps *mdisp = &mdisps[mpoly[i].loopstart+S]; + MDisps *mdisp = &mdisps[mpoly[i].loopstart + S]; DMGridData *grid = gridData[gIndex]; DMGridData *subgrid = subGridData[gIndex]; float (*dispgrid)[3] = NULL; @@ -998,10 +998,10 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm for (y = 0; y < gridSize; y++) { for (x = 0; x < gridSize; x++) { - float *co = grid[x + y*gridSize].co; - float *sco = subgrid[x + y*gridSize].co; - float *no = subgrid[x + y*gridSize].no; - float *data = dispgrid[dGridSize*y*dSkip + x*dSkip]; + float *co = grid[x + y * gridSize].co; + float *sco = subgrid[x + y * gridSize].co; + float *no = subgrid[x + y * gridSize].no; + float *data = dispgrid[dGridSize * y * dSkip + x * dSkip]; float mat[3][3], tx[3], ty[3], disp[3], d[3]; /* construct tangent space matrix */ @@ -1018,26 +1018,26 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm column_vectors_to_mat3(mat, tx, ty, no); switch (op) { - case APPLY_DISPLACEMENTS: - /* Convert displacement to object space - * and add to grid points */ - mul_v3_m3v3(disp, mat, data); - add_v3_v3v3(co, sco, disp); - break; - case CALC_DISPLACEMENTS: - /* Calculate displacement between new and old - * grid points and convert to tangent space */ - sub_v3_v3v3(disp, co, sco); - invert_m3(mat); - mul_v3_m3v3(data, mat, disp); - break; - case ADD_DISPLACEMENTS: - /* Convert subdivided displacements to tangent - * space and add to the original displacements */ - invert_m3(mat); - mul_v3_m3v3(d, mat, co); - add_v3_v3(data, d); - break; + case APPLY_DISPLACEMENTS: + /* Convert displacement to object space + * and add to grid points */ + mul_v3_m3v3(disp, mat, data); + add_v3_v3v3(co, sco, disp); + break; + case CALC_DISPLACEMENTS: + /* Calculate displacement between new and old + * grid points and convert to tangent space */ + sub_v3_v3v3(disp, co, sco); + invert_m3(mat); + mul_v3_m3v3(data, mat, disp); + break; + case ADD_DISPLACEMENTS: + /* Convert subdivided displacements to tangent + * space and add to the original displacements */ + invert_m3(mat); + mul_v3_m3v3(d, mat, co); + add_v3_v3(data, d); + break; } } } @@ -1052,7 +1052,7 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm void multires_modifier_update_mdisps(struct DerivedMesh *dm) { - CCGDerivedMesh *ccgdm= (CCGDerivedMesh*)dm; + CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm; Object *ob; Mesh *me; MDisps *mdisps; @@ -1095,16 +1095,16 @@ void multires_modifier_update_mdisps(struct DerivedMesh *dm) lowGridData = lowdm->getGridData(lowdm); gridData = dm->getGridData(dm); - subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*"); - diffGrid = MEM_callocN(sizeof(DMGridData)*lowGridSize*lowGridSize, "diff"); + subGridData = MEM_callocN(sizeof(DMGridData *) * numGrids, "subGridData*"); + diffGrid = MEM_callocN(sizeof(DMGridData) * lowGridSize * lowGridSize, "diff"); for (i = 0; i < numGrids; ++i) { /* backup subsurf grids */ - subGridData[i] = MEM_callocN(sizeof(DMGridData)*highGridSize*highGridSize, "subGridData"); - memcpy(subGridData[i], highGridData[i], sizeof(DMGridData)*highGridSize*highGridSize); + subGridData[i] = MEM_callocN(sizeof(DMGridData) * highGridSize * highGridSize, "subGridData"); + memcpy(subGridData[i], highGridData[i], sizeof(DMGridData) * highGridSize * highGridSize); /* write difference of subsurf and displaced low level into high subsurf */ - for (j = 0; j < lowGridSize*lowGridSize; ++j) + for (j = 0; j < lowGridSize * lowGridSize; ++j) sub_v3_v3v3(diffGrid[j].co, gridData[i][j].co, lowGridData[i][j].co); multires_copy_dm_grid(highGridData[i], diffGrid, highGridSize, lowGridSize); @@ -1115,7 +1115,7 @@ void multires_modifier_update_mdisps(struct DerivedMesh *dm) lowdm->release(lowdm); /* subsurf higher levels again with difference of coordinates */ - ss= ((CCGDerivedMesh*)highdm)->ss; + ss = ((CCGDerivedMesh *)highdm)->ss; ccgSubSurf_updateFromFaces(ss, lvl, NULL, 0); ccgSubSurf_updateLevels(ss, lvl, NULL, 0); @@ -1147,8 +1147,8 @@ void multires_modifier_update_mdisps(struct DerivedMesh *dm) void multires_modifier_update_hidden(DerivedMesh *dm) { - CCGDerivedMesh *ccgdm= (CCGDerivedMesh*)dm; - BLI_bitmap *grid_hidden= ccgdm->gridHidden; + CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm; + BLI_bitmap *grid_hidden = ccgdm->gridHidden; Mesh *me = ccgdm->multires.ob->data; MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); int totlvl = ccgdm->multires.totlvl; @@ -1167,7 +1167,7 @@ void multires_modifier_update_hidden(DerivedMesh *dm) } else if (gh) { gh = multires_mdisps_upsample_hidden(gh, lvl, totlvl, - md->hidden); + md->hidden); if (md->hidden) MEM_freeN(md->hidden); @@ -1180,7 +1180,7 @@ void multires_modifier_update_hidden(DerivedMesh *dm) void multires_set_space(DerivedMesh *dm, Object *ob, int from, int to) { DerivedMesh *ccgdm = NULL, *subsurf = NULL; - DMGridData **gridData, **subGridData=NULL; + DMGridData **gridData, **subGridData = NULL; MPoly *mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY); MDisps *mdisps; MultiresModifierData *mmd = get_multires_modifier(NULL, ob, 1); @@ -1200,26 +1200,26 @@ void multires_set_space(DerivedMesh *dm, Object *ob, int from, int to) ccgdm = multires_dm_create_local(ob, dm, totlvl, totlvl, mmd->simple); subsurf = subsurf_dm_create_local(ob, dm, totlvl, - mmd->simple, mmd->flags & eMultiresModifierFlag_ControlEdges, mmd->flags & eMultiresModifierFlag_PlainUv); + mmd->simple, mmd->flags & eMultiresModifierFlag_ControlEdges, mmd->flags & eMultiresModifierFlag_PlainUv); numGrids = subsurf->getNumGrids(subsurf); gridSize = subsurf->getGridSize(subsurf); gridData = subsurf->getGridData(subsurf); - subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*"); + subGridData = MEM_callocN(sizeof(DMGridData *) * numGrids, "subGridData*"); for (i = 0; i < numGrids; i++) { - subGridData[i] = MEM_callocN(sizeof(DMGridData)*gridSize*gridSize, "subGridData"); - memcpy(subGridData[i], gridData[i], sizeof(DMGridData)*gridSize*gridSize); + subGridData[i] = MEM_callocN(sizeof(DMGridData) * gridSize * gridSize, "subGridData"); + memcpy(subGridData[i], gridData[i], sizeof(DMGridData) * gridSize * gridSize); } /*numGrids = ccgdm->dm->getNumGrids((DerivedMesh*)ccgdm);*/ /*UNUSED*/ - gridSize = ccgdm->getGridSize((DerivedMesh*)ccgdm); - gridData = ccgdm->getGridData((DerivedMesh*)ccgdm); - gridOffset = ccgdm->getGridOffset((DerivedMesh*)ccgdm); + gridSize = ccgdm->getGridSize((DerivedMesh *)ccgdm); + gridData = ccgdm->getGridData((DerivedMesh *)ccgdm); + gridOffset = ccgdm->getGridOffset((DerivedMesh *)ccgdm); dGridSize = multires_side_tot[totlvl]; - dSkip = (dGridSize-1)/(gridSize-1); + dSkip = (dGridSize - 1) / (gridSize - 1); k = 0; /*current loop/mdisp index within the mloop array*/ @@ -1230,25 +1230,25 @@ void multires_set_space(DerivedMesh *dm, Object *ob, int from, int to) int S, x, y, gIndex = gridOffset[i]; for (S = 0; S < numVerts; ++S, ++gIndex, ++k) { - MDisps *mdisp = &mdisps[mpoly[i].loopstart+S]; + MDisps *mdisp = &mdisps[mpoly[i].loopstart + S]; /* DMGridData *grid = gridData[gIndex]; */ /* UNUSED */ DMGridData *subgrid = subGridData[gIndex]; float (*dispgrid)[3] = NULL; /* when adding new faces in edit mode, need to allocate disps */ if (!mdisp->disps) { - mdisp->totdisp = gridSize*gridSize; + mdisp->totdisp = gridSize * gridSize; mdisp->level = totlvl; - mdisp->disps = MEM_callocN(sizeof(float)*3*mdisp->totdisp, "disp in multires_set_space"); + mdisp->disps = MEM_callocN(sizeof(float) * 3 * mdisp->totdisp, "disp in multires_set_space"); } dispgrid = mdisp->disps; for (y = 0; y < gridSize; y++) { for (x = 0; x < gridSize; x++) { - float *data = dispgrid[dGridSize*y*dSkip + x*dSkip]; - float *no = subgrid[x + y*gridSize].no; - float *co = subgrid[x + y*gridSize].co; + float *data = dispgrid[dGridSize * y * dSkip + x * dSkip]; + float *no = subgrid[x + y * gridSize].no; + float *co = subgrid[x + y * gridSize].co; float mat[3][3], tx[3], ty[3], dco[3]; /* construct tangent space matrix */ @@ -1308,12 +1308,12 @@ void multires_stitch_grids(Object *ob) { /* utility for smooth brush */ if (ob && ob->derivedFinal) { - CCGDerivedMesh *ccgdm = (CCGDerivedMesh*)ob->derivedFinal; + CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)ob->derivedFinal; CCGFace **faces; int totface; if (ccgdm->pbvh) { - BLI_pbvh_get_grid_updates(ccgdm->pbvh, 0, (void***)&faces, &totface); + BLI_pbvh_get_grid_updates(ccgdm->pbvh, 0, (void ***)&faces, &totface); if (totface) { ccgSubSurf_stitchFaces(ccgdm->ss, 0, faces, totface); @@ -1324,25 +1324,25 @@ void multires_stitch_grids(Object *ob) } DerivedMesh *multires_dm_create_from_derived(MultiresModifierData *mmd, - int local_mmd, DerivedMesh *dm, - Object *ob, int useRenderParams) + int local_mmd, DerivedMesh *dm, + Object *ob, int useRenderParams) { - Mesh *me= ob->data; + Mesh *me = ob->data; DerivedMesh *result; CCGDerivedMesh *ccgdm = NULL; DMGridData **gridData, **subGridData; - int lvl= multires_get_level(ob, mmd, useRenderParams); + int lvl = multires_get_level(ob, mmd, useRenderParams); int i, gridSize, numGrids; if (lvl == 0) return dm; result = subsurf_dm_create_local(ob, dm, lvl, - mmd->simple, mmd->flags & eMultiresModifierFlag_ControlEdges, - mmd->flags & eMultiresModifierFlag_PlainUv); + mmd->simple, mmd->flags & eMultiresModifierFlag_ControlEdges, + mmd->flags & eMultiresModifierFlag_PlainUv); if (!local_mmd) { - ccgdm = (CCGDerivedMesh*)result; + ccgdm = (CCGDerivedMesh *)result; ccgdm->multires.ob = ob; ccgdm->multires.mmd = mmd; @@ -1356,11 +1356,11 @@ DerivedMesh *multires_dm_create_from_derived(MultiresModifierData *mmd, gridSize = result->getGridSize(result); gridData = result->getGridData(result); - subGridData = MEM_callocN(sizeof(DMGridData*)*numGrids, "subGridData*"); + subGridData = MEM_callocN(sizeof(DMGridData *) * numGrids, "subGridData*"); for (i = 0; i < numGrids; i++) { - subGridData[i] = MEM_callocN(sizeof(DMGridData)*gridSize*gridSize, "subGridData"); - memcpy(subGridData[i], gridData[i], sizeof(DMGridData)*gridSize*gridSize); + subGridData[i] = MEM_callocN(sizeof(DMGridData) * gridSize * gridSize, "subGridData"); + memcpy(subGridData[i], gridData[i], sizeof(DMGridData) * gridSize * gridSize); } multires_set_tot_mdisps(me, mmd->totlvl); @@ -1430,22 +1430,22 @@ void old_mdisps_bilinear(float out[3], float (*disps)[3], const int st, float u, static void old_mdisps_rotate(int S, int UNUSED(newside), int oldside, int x, int y, float *u, float *v) { - float offset = oldside*0.5f - 0.5f; + float offset = oldside * 0.5f - 0.5f; - if (S == 1) { *u= offset + x; *v = offset - y; } - if (S == 2) { *u= offset + y; *v = offset + x; } - if (S == 3) { *u= offset - x; *v = offset + y; } - if (S == 0) { *u= offset - y; *v = offset - x; } + if (S == 1) { *u = offset + x; *v = offset - y; } + if (S == 2) { *u = offset + y; *v = offset + x; } + if (S == 3) { *u = offset - x; *v = offset + y; } + if (S == 0) { *u = offset - y; *v = offset - x; } } static void old_mdisps_convert(MFace *mface, MDisps *mdisp) { - int newlvl = log(sqrt(mdisp->totdisp)-1)/M_LN2; - int oldlvl = newlvl+1; + int newlvl = log(sqrt(mdisp->totdisp) - 1) / M_LN2; + int oldlvl = newlvl + 1; int oldside = multires_side_tot[oldlvl]; int newside = multires_side_tot[newlvl]; - int nvert = (mface->v4)? 4: 3; - int newtotdisp = multires_grid_tot[newlvl]*nvert; + int nvert = (mface->v4) ? 4 : 3; + int newtotdisp = multires_grid_tot[newlvl] * nvert; int x, y, S; float (*disps)[3], (*out)[3], u = 0.0f, v = 0.0f; /* Quite gcc barking. */ @@ -1458,19 +1458,19 @@ static void old_mdisps_convert(MFace *mface, MDisps *mdisp) old_mdisps_rotate(S, newside, oldside, x, y, &u, &v); old_mdisps_bilinear(*out, mdisp->disps, oldside, u, v); - if (S == 1) { (*out)[1]= -(*out)[1]; } + if (S == 1) { (*out)[1] = -(*out)[1]; } else if (S == 2) { SWAP(float, (*out)[0], (*out)[1]); } - else if (S == 3) { (*out)[0]= -(*out)[0]; } - else if (S == 0) { SWAP(float, (*out)[0], (*out)[1]); (*out)[0]= -(*out)[0]; (*out)[1]= -(*out)[1]; }; + else if (S == 3) { (*out)[0] = -(*out)[0]; } + else if (S == 0) { SWAP(float, (*out)[0], (*out)[1]); (*out)[0] = -(*out)[0]; (*out)[1] = -(*out)[1]; }; } } } MEM_freeN(mdisp->disps); - mdisp->totdisp= newtotdisp; - mdisp->level= newlvl; - mdisp->disps= disps; + mdisp->totdisp = newtotdisp; + mdisp->level = newlvl; + mdisp->disps = disps; } void multires_load_old_250(Mesh *me) @@ -1479,10 +1479,10 @@ void multires_load_old_250(Mesh *me) MFace *mf; int i, j, k; - mdisps= CustomData_get_layer(&me->fdata, CD_MDISPS); + mdisps = CustomData_get_layer(&me->fdata, CD_MDISPS); if (mdisps) { - for (i=0; itotface; i++) + for (i = 0; i < me->totface; i++) if (mdisps[i].totdisp) old_mdisps_convert(&me->mface[i], &mdisps[i]); @@ -1491,15 +1491,15 @@ void multires_load_old_250(Mesh *me) k = 0; mf = me->mface; - for (i=0; itotface; i++, mf++) { + for (i = 0; i < me->totface; i++, mf++) { int nvert = mf->v4 ? 4 : 3; int totdisp = mdisps[i].totdisp / nvert; - for (j=0; j < mf->v4 ? 4 : 3; j++, k++) { - mdisps2[k].disps = MEM_callocN(sizeof(float)*3*totdisp, "multires disp in conversion"); + for (j = 0; j < mf->v4 ? 4 : 3; j++, k++) { + mdisps2[k].disps = MEM_callocN(sizeof(float) * 3 * totdisp, "multires disp in conversion"); mdisps2[k].totdisp = totdisp; mdisps2[k].level = mdisps[i].level; - memcpy(mdisps2[k].disps, mdisps[i].disps + totdisp*j, totdisp); + memcpy(mdisps2[k].disps, mdisps[i].disps + totdisp * j, totdisp); } } @@ -1519,7 +1519,7 @@ static void multires_free_level(MultiresLevel *lvl) void multires_free(Multires *mr) { if (mr) { - MultiresLevel* lvl= mr->levels.first; + MultiresLevel *lvl = mr->levels.first; /* Free the first-level data */ if (lvl) { @@ -1533,7 +1533,7 @@ void multires_free(Multires *mr) while (lvl) { multires_free_level(lvl); - lvl= lvl->next; + lvl = lvl->next; } MEM_freeN(mr->verts); @@ -1551,12 +1551,12 @@ static void create_old_vert_face_map(ListBase **map, IndexNode **mem, const Mult IndexNode *node = NULL; (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert face map"); - (*mem) = MEM_callocN(sizeof(IndexNode) * totface*4, "vert face map mem"); + (*mem) = MEM_callocN(sizeof(IndexNode) * totface * 4, "vert face map mem"); node = *mem; /* Find the users */ for (i = 0; i < totface; ++i) { - for (j = 0; j < (mface[i].v[3]?4:3); ++j, ++node) { + for (j = 0; j < (mface[i].v[3] ? 4 : 3); ++j, ++node) { node->index = i; BLI_addtail(&(*map)[mface[i].v[j]], node); } @@ -1564,13 +1564,13 @@ static void create_old_vert_face_map(ListBase **map, IndexNode **mem, const Mult } static void create_old_vert_edge_map(ListBase **map, IndexNode **mem, const MultiresEdge *medge, - const int totvert, const int totedge) + const int totvert, const int totedge) { int i, j; IndexNode *node = NULL; (*map) = MEM_callocN(sizeof(ListBase) * totvert, "vert edge map"); - (*mem) = MEM_callocN(sizeof(IndexNode) * totedge*2, "vert edge map mem"); + (*mem) = MEM_callocN(sizeof(IndexNode) * totedge * 2, "vert edge map mem"); node = *mem; /* Find the users */ @@ -1587,10 +1587,10 @@ static MultiresFace *find_old_face(ListBase *map, MultiresFace *faces, int v1, i IndexNode *n1; int v[4], i, j; - v[0]= v1; - v[1]= v2; - v[2]= v3; - v[3]= v4; + v[0] = v1; + v[1] = v2; + v[2] = v3; + v[3] = v4; for (n1 = map[v1].first; n1; n1 = n1->next) { int fnd[4] = {0, 0, 0, 0}; @@ -1635,7 +1635,7 @@ static void multires_load_old_edges(ListBase **emap, MultiresLevel *lvl, int *vv } static void multires_load_old_faces(ListBase **fmap, ListBase **emap, MultiresLevel *lvl, int *vvmap, int dst, - int v1, int v2, int v3, int v4, int st2, int st3) + int v1, int v2, int v3, int v4, int st2, int st3) { int fmid; int emid13, emid14, emid23, emid24; @@ -1651,16 +1651,16 @@ static void multires_load_old_faces(ListBase **fmap, ListBase **emap, MultiresLe multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst + st2 * st3 + st3, - fmid, v2, emid23, emid24, st2, st3 / 2); + fmid, v2, emid23, emid24, st2, st3 / 2); multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst - st2 * st3 + st3, - emid14, emid24, fmid, v4, st2, st3 / 2); + emid14, emid24, fmid, v4, st2, st3 / 2); multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst + st2 * st3 - st3, - emid13, emid23, v3, fmid, st2, st3 / 2); + emid13, emid23, v3, fmid, st2, st3 / 2); multires_load_old_faces(fmap + 1, emap + 1, lvl->next, vvmap, dst - st2 * st3 - st3, - v1, fmid, emid13, emid14, st2, st3 / 2); + v1, fmid, emid13, emid14, st2, st3 / 2); if (lvl->next->next) { multires_load_old_edges(emap, lvl->next, vvmap, dst, emid24, fmid, st3); @@ -1673,7 +1673,7 @@ static void multires_load_old_faces(ListBase **fmap, ListBase **emap, MultiresLe static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert) { - CCGDerivedMesh *ccgdm = (CCGDerivedMesh*) dm; + CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm; CCGSubSurf *ss = ccgdm->ss; DMGridData *vd; int index; @@ -1687,13 +1687,13 @@ static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert) CCGFace *f = ccgdm->faceMap[index].face; int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f); - vd= ccgSubSurf_getFaceCenterData(f); + vd = ccgSubSurf_getFaceCenterData(f); copy_v3_v3(vd->co, mvert[i].co); i++; for (S = 0; S < numVerts; S++) { for (x = 1; x < gridSize - 1; x++, i++) { - vd= ccgSubSurf_getFaceGridEdgeData(ss, f, S, x); + vd = ccgSubSurf_getFaceGridEdgeData(ss, f, S, x); copy_v3_v3(vd->co, mvert[i].co); } } @@ -1701,7 +1701,7 @@ static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert) for (S = 0; S < numVerts; S++) { for (y = 1; y < gridSize - 1; y++) { for (x = 1; x < gridSize - 1; x++, i++) { - vd= ccgSubSurf_getFaceGridData(ss, f, S, x, y); + vd = ccgSubSurf_getFaceGridData(ss, f, S, x, y); copy_v3_v3(vd->co, mvert[i].co); } } @@ -1714,7 +1714,7 @@ static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert) int x; for (x = 1; x < edgeSize - 1; x++, i++) { - vd= ccgSubSurf_getEdgeData(ss, e, x); + vd = ccgSubSurf_getEdgeData(ss, e, x); copy_v3_v3(vd->co, mvert[i].co); } } @@ -1723,7 +1723,7 @@ static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert) for (index = 0; index < totvert; index++) { CCGVert *v = ccgdm->vertMap[index].vert; - vd= ccgSubSurf_getVertData(ss, v); + vd = ccgSubSurf_getVertData(ss, v); copy_v3_v3(vd->co, mvert[i].co); i++; } @@ -1735,7 +1735,7 @@ static void multires_mvert_to_ss(DerivedMesh *dm, MVert *mvert) static void multires_load_old_dm(DerivedMesh *dm, Mesh *me, int totlvl) { MultiresLevel *lvl, *lvl1; - Multires *mr= me->mr; + Multires *mr = me->mr; MVert *vsrc, *vdst; unsigned int src, dst; int st = multires_side_tot[totlvl - 1] - 1; @@ -1834,10 +1834,10 @@ static void multires_load_old_dm(DerivedMesh *dm, Mesh *me, int totlvl) } /* calculate vert to edge/face maps for each level (except the last) */ - fmap = MEM_callocN(sizeof(ListBase*) * (mr->level_count-1), "multires fmap"); - emap = MEM_callocN(sizeof(ListBase*) * (mr->level_count-1), "multires emap"); - fmem = MEM_callocN(sizeof(IndexNode*) * (mr->level_count-1), "multires fmem"); - emem = MEM_callocN(sizeof(IndexNode*) * (mr->level_count-1), "multires emem"); + fmap = MEM_callocN(sizeof(ListBase *) * (mr->level_count - 1), "multires fmap"); + emap = MEM_callocN(sizeof(ListBase *) * (mr->level_count - 1), "multires emap"); + fmem = MEM_callocN(sizeof(IndexNode *) * (mr->level_count - 1), "multires fmem"); + emem = MEM_callocN(sizeof(IndexNode *) * (mr->level_count - 1), "multires emem"); lvl = lvl1; for (i = 0; i < (unsigned int)mr->level_count - 1; ++i) { create_old_vert_face_map(fmap + i, fmem + i, lvl->faces, lvl->totvert, lvl->totface); @@ -1862,10 +1862,10 @@ static void multires_load_old_dm(DerivedMesh *dm, Mesh *me, int totlvl) int pv = lvl1->faces[j].v[s == 0 ? sides - 1 : s - 1]; multires_load_old_faces(fmap, emap, lvl1->next, vvmap, mid, - vvmap[dst], cv, - find_old_edge(emap[0], lvl1->edges, pv, cv)->mid, - find_old_edge(emap[0], lvl1->edges, cv, nv)->mid, - st2, st4); + vvmap[dst], cv, + find_old_edge(emap[0], lvl1->edges, pv, cv)->mid, + find_old_edge(emap[0], lvl1->edges, cv, nv)->mid, + st2, st4); ldst += (st - 1) * (st - 1); } @@ -1920,10 +1920,10 @@ static void multires_load_old_vcols(Mesh *me) for (i = 0; i < me->totface; ++i) { for (j = 0; j < 4; ++j) { - mcol[i*4 + j].a = colface[i].col[j].a; - mcol[i*4 + j].r = colface[i].col[j].r; - mcol[i*4 + j].g = colface[i].col[j].g; - mcol[i*4 + j].b = colface[i].col[j].b; + mcol[i * 4 + j].a = colface[i].col[j].a; + mcol[i * 4 + j].r = colface[i].col[j].r; + mcol[i * 4 + j].g = colface[i].col[j].g; + mcol[i * 4 + j].b = colface[i].col[j].b; } } } @@ -1982,7 +1982,7 @@ void multires_load_old(Object *ob, Mesh *me) md = ob->modifiers.first; while (md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform) md = md->next; - mmd = (MultiresModifierData*)modifier_new(eModifierType_Multires); + mmd = (MultiresModifierData *)modifier_new(eModifierType_Multires); BLI_insertlinkbefore(&ob->modifiers, md, mmd); for (i = 0; i < me->mr->level_count - 1; ++i) @@ -1992,7 +1992,7 @@ void multires_load_old(Object *ob, Mesh *me) orig = CDDM_from_mesh(me, NULL); dm = multires_dm_create_from_derived(mmd, 0, orig, ob, 0); - multires_load_old_dm(dm, me, mmd->totlvl+1); + multires_load_old_dm(dm, me, mmd->totlvl + 1); multires_dm_mark_as_modified(dm, MULTIRES_COORDS_MODIFIED); dm->release(dm); @@ -2011,13 +2011,13 @@ void multires_load_old(Object *ob, Mesh *me) /* Remove the old multires */ multires_free(me->mr); - me->mr= NULL; + me->mr = NULL; } static void multires_sync_levels(Scene *scene, Object *ob, Object *to_ob) { - MultiresModifierData *mmd= get_multires_modifier(scene, ob, 1); - MultiresModifierData *to_mmd= get_multires_modifier(scene, to_ob, 1); + MultiresModifierData *mmd = get_multires_modifier(scene, ob, 1); + MultiresModifierData *to_mmd = get_multires_modifier(scene, to_ob, 1); if (!mmd) { /* object could have MDISP even when there is no multires modifier @@ -2030,77 +2030,77 @@ static void multires_sync_levels(Scene *scene, Object *ob, Object *to_ob) if (!mmd || !to_mmd) return; - if (mmd->totlvl>to_mmd->totlvl) multires_del_higher(mmd, ob, to_mmd->totlvl); + if (mmd->totlvl > to_mmd->totlvl) multires_del_higher(mmd, ob, to_mmd->totlvl); else multires_subdivide(mmd, ob, to_mmd->totlvl, 0, mmd->simple); } static void multires_apply_smat(Scene *scene, Object *ob, float smat[3][3]) { - DerivedMesh *dm= NULL, *cddm= NULL, *subdm= NULL; + DerivedMesh *dm = NULL, *cddm = NULL, *subdm = NULL; DMGridData **gridData, **subGridData; - Mesh *me= (Mesh*)ob->data; - MPoly *mpoly= me->mpoly; + Mesh *me = (Mesh *)ob->data; + MPoly *mpoly = me->mpoly; /* MLoop *mloop = me->mloop; */ /* UNUSED */ MDisps *mdisps; int *gridOffset; int i, /*numGrids, */ gridSize, dGridSize, dSkip, totvert; float (*vertCos)[3] = NULL; - MultiresModifierData *mmd= get_multires_modifier(scene, ob, 1); + MultiresModifierData *mmd = get_multires_modifier(scene, ob, 1); MultiresModifierData high_mmd; CustomData_external_read(&me->ldata, &me->id, CD_MASK_MDISPS, me->totloop); - mdisps= CustomData_get_layer(&me->ldata, CD_MDISPS); + mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS); if (!mdisps || !mmd || !mmd->totlvl) return; /* we need derived mesh created from highest resolution */ - high_mmd= *mmd; - high_mmd.lvl= high_mmd.totlvl; + high_mmd = *mmd; + high_mmd.lvl = high_mmd.totlvl; /* unscaled multires with applied displacement */ - subdm= get_multires_dm(scene, &high_mmd, ob); + subdm = get_multires_dm(scene, &high_mmd, ob); /* prepare scaled CDDM to create ccgDN */ - cddm= mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH); + cddm = mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH); - totvert= cddm->getNumVerts(cddm); - vertCos= MEM_mallocN(sizeof(*vertCos) * totvert, "multiresScale vertCos"); + totvert = cddm->getNumVerts(cddm); + vertCos = MEM_mallocN(sizeof(*vertCos) * totvert, "multiresScale vertCos"); cddm->getVertCos(cddm, vertCos); - for (i=0; iflags & eMultiresModifierFlag_PlainUv); + dm = subsurf_dm_create_local(ob, cddm, high_mmd.totlvl, high_mmd.simple, 0, mmd->flags & eMultiresModifierFlag_PlainUv); cddm->release(cddm); /*numGrids= dm->getNumGrids(dm);*/ /*UNUSED*/ - gridSize= dm->getGridSize(dm); - gridData= dm->getGridData(dm); - gridOffset= dm->getGridOffset(dm); - subGridData= subdm->getGridData(subdm); + gridSize = dm->getGridSize(dm); + gridData = dm->getGridData(dm); + gridOffset = dm->getGridOffset(dm); + subGridData = subdm->getGridData(subdm); - dGridSize= multires_side_tot[high_mmd.totlvl]; - dSkip= (dGridSize-1)/(gridSize-1); + dGridSize = multires_side_tot[high_mmd.totlvl]; + dSkip = (dGridSize - 1) / (gridSize - 1); #pragma omp parallel for private(i) if (me->totface*gridSize*gridSize*4 >= CCG_OMP_LIMIT) for (i = 0; i < me->totpoly; ++i) { - const int numVerts= mpoly[i].totloop; - MDisps *mdisp= &mdisps[mpoly[i].loopstart]; + const int numVerts = mpoly[i].totloop; + MDisps *mdisp = &mdisps[mpoly[i].loopstart]; int S, x, y, gIndex = gridOffset[i]; for (S = 0; S < numVerts; ++S, ++gIndex, mdisp++) { - DMGridData *grid= gridData[gIndex]; - DMGridData *subgrid= subGridData[gIndex]; - float (*dispgrid)[3]= mdisp->disps; + DMGridData *grid = gridData[gIndex]; + DMGridData *subgrid = subGridData[gIndex]; + float (*dispgrid)[3] = mdisp->disps; for (y = 0; y < gridSize; y++) { for (x = 0; x < gridSize; x++) { - float *co= grid[x + y*gridSize].co; - float *sco= subgrid[x + y*gridSize].co; - float *no= grid[x + y*gridSize].no; - float *data= dispgrid[dGridSize*y*dSkip + x*dSkip]; + float *co = grid[x + y * gridSize].co; + float *sco = subgrid[x + y * gridSize].co; + float *no = grid[x + y * gridSize].no; + float *data = dispgrid[dGridSize * y * dSkip + x * dSkip]; float mat[3][3], tx[3], ty[3], disp[3]; /* construct tangent space matrix */ @@ -2130,11 +2130,11 @@ static void multires_apply_smat(Scene *scene, Object *ob, float smat[3][3]) int multires_mdisp_corners(MDisps *s) { - int lvl= 13; + int lvl = 13; while (lvl > 0) { - int side = (1 << (lvl-1)) + 1; - if ((s->totdisp % (side*side)) == 0) return s->totdisp / (side*side); + int side = (1 << (lvl - 1)) + 1; + if ((s->totdisp % (side * side)) == 0) return s->totdisp / (side * side); lvl--; } @@ -2204,14 +2204,14 @@ void multires_topology_changed(Mesh *me) /* Find per-corner coordinate with given per-face UV coord */ int mdisp_rot_face_to_crn(const int corners, const int face_side, const float u, const float v, float *x, float *y) { - const float offset = face_side*0.5f - 0.5f; + const float offset = face_side * 0.5f - 0.5f; int S = 0; if (corners == 4) { if (u <= offset && v <= offset) S = 0; else if (u > offset && v <= offset) S = 1; else if (u > offset && v > offset) S = 2; - else if (u <= offset && v >= offset) S = 3; + else if (u <= offset && v >= offset) S = 3; if (S == 0) { *y = offset - u; @@ -2226,7 +2226,7 @@ int mdisp_rot_face_to_crn(const int corners, const int face_side, const float u, *x = v - offset; } else if (S == 3) { - *x= offset - u; + *x = offset - u; *y = v - offset; } } @@ -2235,15 +2235,15 @@ int mdisp_rot_face_to_crn(const int corners, const int face_side, const float u, float w = (face_side - 1) - u - v; float W1, W2; - if (u >= v && u >= w) {S = 0; W1= w; W2= v;} - else if (v >= u && v >= w) {S = 1; W1 = u; W2 = w;} - else {S = 2; W1 = v; W2 = u;} + if (u >= v && u >= w) {S = 0; W1 = w; W2 = v; } + else if (v >= u && v >= w) {S = 1; W1 = u; W2 = w; } + else {S = 2; W1 = v; W2 = u; } - W1 /= (face_side-1); - W2 /= (face_side-1); + W1 /= (face_side - 1); + W2 /= (face_side - 1); - *x = (1-(2*W1)/(1-W2)) * grid_size; - *y = (1-(2*W2)/(1-W1)) * grid_size; + *x = (1 - (2 * W1) / (1 - W2)) * grid_size; + *y = (1 - (2 * W2) / (1 - W1)) * grid_size; } return S; diff --git a/source/blender/blenkernel/intern/packedFile.c b/source/blender/blenkernel/intern/packedFile.c index 3b5b4b766fb..a2c89967f44 100644 --- a/source/blender/blenkernel/intern/packedFile.c +++ b/source/blender/blenkernel/intern/packedFile.c @@ -73,17 +73,17 @@ int seekPackedFile(PackedFile *pf, int offset, int whence) if (pf) { oldseek = pf->seek; switch (whence) { - case SEEK_CUR: - seek = oldseek + offset; - break; - case SEEK_END: - seek = pf->size + offset; - break; - case SEEK_SET: - seek = offset; - break; - default: - oldseek = -1; + case SEEK_CUR: + seek = oldseek + offset; + break; + case SEEK_END: + seek = pf->size + offset; + break; + case SEEK_SET: + seek = offset; + break; + default: + oldseek = -1; } if (seek < 0) { seek = 0; @@ -133,15 +133,15 @@ int countPackedFiles(Main *bmain) int count = 0; // let's check if there are packed files... - for (ima=bmain->image.first; ima; ima=ima->id.next) + for (ima = bmain->image.first; ima; ima = ima->id.next) if (ima->packedfile) count++; - for (vf=bmain->vfont.first; vf; vf=vf->id.next) + for (vf = bmain->vfont.first; vf; vf = vf->id.next) if (vf->packedfile) count++; - for (sound=bmain->sound.first; sound; sound=sound->id.next) + for (sound = bmain->sound.first; sound; sound = sound->id.next) if (sound->packedfile) count++; @@ -176,7 +176,7 @@ PackedFile *newPackedFile(ReportList *reports, const char *filename, const char /* render result has no filename and can be ignored * any other files with no name can be ignored too */ - if (filename[0]=='\0') + if (filename[0] == '\0') return NULL; //XXX waitcursor(1); @@ -189,7 +189,7 @@ PackedFile *newPackedFile(ReportList *reports, const char *filename, const char // open the file // and create a PackedFile structure - file= BLI_open(name, O_BINARY|O_RDONLY, 0); + file = BLI_open(name, O_BINARY | O_RDONLY, 0); if (file <= 0) { BKE_reportf(reports, RPT_ERROR, "Unable to pack file, source path not found: \"%s\"", name); } @@ -222,23 +222,23 @@ void packAll(Main *bmain, ReportList *reports) VFont *vf; bSound *sound; - for (ima=bmain->image.first; ima; ima=ima->id.next) { - if (ima->packedfile == NULL && ima->id.lib==NULL) { - if (ima->source==IMA_SRC_FILE) { + for (ima = bmain->image.first; ima; ima = ima->id.next) { + if (ima->packedfile == NULL && ima->id.lib == NULL) { + if (ima->source == IMA_SRC_FILE) { ima->packedfile = newPackedFile(reports, ima->name, ID_BLEND_PATH(bmain, &ima->id)); } else if (ELEM(ima->source, IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) { - BKE_reportf(reports, RPT_WARNING, "Image '%s' skipped, movies and image sequences not supported.", ima->id.name+2); + BKE_reportf(reports, RPT_WARNING, "Image '%s' skipped, movies and image sequences not supported.", ima->id.name + 2); } } } - for (vf=bmain->vfont.first; vf; vf=vf->id.next) - if (vf->packedfile == NULL && vf->id.lib==NULL && strcmp(vf->name, FO_BUILTIN_NAME) != 0) + for (vf = bmain->vfont.first; vf; vf = vf->id.next) + if (vf->packedfile == NULL && vf->id.lib == NULL && strcmp(vf->name, FO_BUILTIN_NAME) != 0) vf->packedfile = newPackedFile(reports, vf->name, bmain->name); - for (sound=bmain->sound.first; sound; sound=sound->id.next) - if (sound->packedfile == NULL && sound->id.lib==NULL) + for (sound = bmain->sound.first; sound; sound = sound->id.next) + if (sound->packedfile == NULL && sound->id.lib == NULL) sound->packedfile = newPackedFile(reports, sound->name, bmain->name); } @@ -257,12 +257,12 @@ static char *find_new_name(char *name) if (fop_exists(name)) { for (number = 1; number <= 999; number++) { BLI_snprintf(tempname, sizeof(tempname), "%s.%03d", name, number); - if (! fop_exists(tempname)) { + if (!fop_exists(tempname)) { break; } } } - len= strlen(tempname) + 1; + len = strlen(tempname) + 1; newname = MEM_mallocN(len, "find_new_name"); memcpy(newname, tempname, len * sizeof(char)); return newname; @@ -275,7 +275,7 @@ int writePackedFile(ReportList *reports, const char *filename, PackedFile *pf, i int ret_value = RET_OK; char name[FILE_MAX]; char tempname[FILE_MAX]; -/* void *data; */ +/* void *data; */ if (guimode) {} //XXX waitcursor(1); @@ -285,7 +285,7 @@ int writePackedFile(ReportList *reports, const char *filename, PackedFile *pf, i if (BLI_exists(name)) { for (number = 1; number <= 999; number++) { BLI_snprintf(tempname, sizeof(tempname), "%s.%03d_", name, number); - if (! BLI_exists(tempname)) { + if (!BLI_exists(tempname)) { if (BLI_copy(name, tempname) == RET_OK) { remove_tmp = TRUE; } @@ -409,7 +409,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na case PF_KEEP: break; case PF_REMOVE: - temp= abs_name; + temp = abs_name; break; case PF_USE_LOCAL: // if file exists use it @@ -417,7 +417,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na temp = local_name; break; } - // else fall through and create it + // else fall through and create it case PF_WRITE_LOCAL: if (writePackedFile(reports, local_name, pf, 1) == RET_OK) { temp = local_name; @@ -429,7 +429,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na temp = abs_name; break; } - // else fall through and create it + // else fall through and create it case PF_WRITE_ORIGINAL: if (writePackedFile(reports, abs_name, pf, 1) == RET_OK) { temp = abs_name; @@ -441,7 +441,7 @@ char *unpackFile(ReportList *reports, const char *abs_name, const char *local_na } if (temp) { - newname= BLI_strdup(temp); + newname = BLI_strdup(temp); } } @@ -533,15 +533,15 @@ void unpackAll(Main *bmain, ReportList *reports, int how) VFont *vf; bSound *sound; - for (ima=bmain->image.first; ima; ima=ima->id.next) + for (ima = bmain->image.first; ima; ima = ima->id.next) if (ima->packedfile) unpackImage(reports, ima, how); - for (vf=bmain->vfont.first; vf; vf=vf->id.next) + for (vf = bmain->vfont.first; vf; vf = vf->id.next) if (vf->packedfile) unpackVFont(reports, vf, how); - for (sound=bmain->sound.first; sound; sound=sound->id.next) + for (sound = bmain->sound.first; sound; sound = sound->id.next) if (sound->packedfile) unpackSound(bmain, reports, sound, how); } diff --git a/source/blender/blenkernel/intern/property.c b/source/blender/blenkernel/intern/property.c index e7247be7f51..b82521504dd 100644 --- a/source/blender/blenkernel/intern/property.c +++ b/source/blender/blenkernel/intern/property.c @@ -57,7 +57,7 @@ void free_properties(ListBase *lb) { bProperty *prop; - while ( (prop= lb->first) ) { + while ( (prop = lb->first) ) { BLI_remlink(lb, prop); free_property(prop); } @@ -67,11 +67,11 @@ bProperty *copy_property(bProperty *prop) { bProperty *propn; - propn= MEM_dupallocN(prop); + propn = MEM_dupallocN(prop); if (prop->poin && prop->poin != &prop->data) { - propn->poin= MEM_dupallocN(prop->poin); + propn->poin = MEM_dupallocN(prop->poin); } - else propn->poin= &propn->data; + else propn->poin = &propn->data; return propn; } @@ -80,11 +80,11 @@ void copy_properties(ListBase *lbn, ListBase *lbo) { bProperty *prop, *propn; free_properties(lbn); /* in case we are copying to an object with props */ - prop= lbo->first; + prop = lbo->first; while (prop) { - propn= copy_property(prop); + propn = copy_property(prop); BLI_addtail(lbn, propn); - prop= prop->next; + prop = prop->next; } @@ -95,20 +95,20 @@ void init_property(bProperty *prop) /* also use when property changes type */ if (prop->poin && prop->poin != &prop->data) MEM_freeN(prop->poin); - prop->poin= NULL; + prop->poin = NULL; - prop->data= 0; + prop->data = 0; switch (prop->type) { - case GPROP_BOOL: - case GPROP_INT: - case GPROP_FLOAT: - case GPROP_TIME: - prop->poin= &prop->data; - break; - case GPROP_STRING: - prop->poin= MEM_callocN(MAX_PROPSTRING, "property string"); - break; + case GPROP_BOOL: + case GPROP_INT: + case GPROP_FLOAT: + case GPROP_TIME: + prop->poin = &prop->data; + break; + case GPROP_STRING: + prop->poin = MEM_callocN(MAX_PROPSTRING, "property string"); + break; } } @@ -117,8 +117,8 @@ bProperty *new_property(int type) { bProperty *prop; - prop= MEM_callocN(sizeof(bProperty), "property"); - prop->type= type; + prop = MEM_callocN(sizeof(bProperty), "property"); + prop->type = type; init_property(prop); @@ -131,8 +131,8 @@ bProperty *new_property(int type) static bProperty *get_property__internal(bProperty *first, bProperty *self, const char *name) { bProperty *p; - for (p= first; p; p= p->next) { - if (p!=self && (strcmp(p->name, name)==0)) + for (p = first; p; p = p->next) { + if (p != self && (strcmp(p->name, name) == 0)) return p; } return NULL; @@ -142,10 +142,10 @@ void unique_property(bProperty *first, bProperty *prop, int force) bProperty *p; /* set the first if its not set */ - if (first==NULL) { - first= prop; + if (first == NULL) { + first = prop; while (first->prev) { - first= first->prev; + first = first->prev; } } @@ -162,14 +162,14 @@ void unique_property(bProperty *first, bProperty *prop, int force) char new_name[sizeof(prop->name)]; char base_name[sizeof(prop->name)]; char num[sizeof(prop->name)]; - int i= 0; + int i = 0; /* strip numbers */ BLI_strncpy(base_name, prop->name, sizeof(base_name)); - for (i= strlen(base_name)-1; (i>=0 && isdigit(base_name[i])); i--) { - base_name[i]= '\0'; + for (i = strlen(base_name) - 1; (i >= 0 && isdigit(base_name[i])); i--) { + base_name[i] = '\0'; } - i= 0; + i = 0; do { /* ensure we have enough chars for the new number in the name */ BLI_snprintf(num, sizeof(num), "%d", i++); @@ -190,7 +190,7 @@ bProperty *get_ob_property(Object *ob, const char *name) void set_ob_property(Object *ob, bProperty *propc) { bProperty *prop; - prop= get_ob_property(ob, propc->name); + prop = get_ob_property(ob, propc->name); if (prop) { free_property(prop); BLI_remlink(&ob->prop, prop); @@ -207,32 +207,32 @@ int compare_property(bProperty *prop, const char *str) float fvalue, ftest; switch (prop->type) { - case GPROP_BOOL: - if (BLI_strcasecmp(str, "true")==0) { - if (prop->data==1) return 0; - else return 1; - } - else if (BLI_strcasecmp(str, "false")==0) { - if (prop->data==0) return 0; - else return 1; - } + case GPROP_BOOL: + if (BLI_strcasecmp(str, "true") == 0) { + if (prop->data == 1) return 0; + else return 1; + } + else if (BLI_strcasecmp(str, "false") == 0) { + if (prop->data == 0) return 0; + else return 1; + } /* no break, do GPROP_int too! */ - case GPROP_INT: - return prop->data - atoi(str); - - case GPROP_FLOAT: - case GPROP_TIME: - // WARNING: untested for GPROP_TIME - // function isn't used currently - fvalue= *((float *)&prop->data); - ftest= (float)atof(str); - if ( fvalue > ftest) return 1; - else if ( fvalue < ftest) return -1; - return 0; - - case GPROP_STRING: - return strcmp(prop->poin, str); + case GPROP_INT: + return prop->data - atoi(str); + + case GPROP_FLOAT: + case GPROP_TIME: + // WARNING: untested for GPROP_TIME + // function isn't used currently + fvalue = *((float *)&prop->data); + ftest = (float)atof(str); + if (fvalue > ftest) return 1; + else if (fvalue < ftest) return -1; + return 0; + + case GPROP_STRING: + return strcmp(prop->poin, str); } return 0; @@ -243,21 +243,21 @@ void set_property(bProperty *prop, const char *str) // extern int Gdfra; /* sector.c */ switch (prop->type) { - case GPROP_BOOL: - if (BLI_strcasecmp(str, "true")==0) prop->data= 1; - else if (BLI_strcasecmp(str, "false")==0) prop->data= 0; - else prop->data= (atoi(str)!=0); - break; - case GPROP_INT: - prop->data= atoi(str); - break; - case GPROP_FLOAT: - case GPROP_TIME: - *((float *)&prop->data)= (float)atof(str); - break; - case GPROP_STRING: - strcpy(prop->poin, str); /* TODO - check size? */ - break; + case GPROP_BOOL: + if (BLI_strcasecmp(str, "true") == 0) prop->data = 1; + else if (BLI_strcasecmp(str, "false") == 0) prop->data = 0; + else prop->data = (atoi(str) != 0); + break; + case GPROP_INT: + prop->data = atoi(str); + break; + case GPROP_FLOAT: + case GPROP_TIME: + *((float *)&prop->data) = (float)atof(str); + break; + case GPROP_STRING: + strcpy(prop->poin, str); /* TODO - check size? */ + break; } } @@ -267,17 +267,17 @@ void add_property(bProperty *prop, const char *str) // extern int Gdfra; /* sector.c */ switch (prop->type) { - case GPROP_BOOL: - case GPROP_INT: - prop->data+= atoi(str); - break; - case GPROP_FLOAT: - case GPROP_TIME: - *((float *)&prop->data)+= (float)atof(str); - break; - case GPROP_STRING: - /* strcpy(prop->poin, str); */ - break; + case GPROP_BOOL: + case GPROP_INT: + prop->data += atoi(str); + break; + case GPROP_FLOAT: + case GPROP_TIME: + *((float *)&prop->data) += (float)atof(str); + break; + case GPROP_STRING: + /* strcpy(prop->poin, str); */ + break; } } @@ -289,17 +289,17 @@ void set_property_valstr(bProperty *prop, char *str) if (str == NULL) return; switch (prop->type) { - case GPROP_BOOL: - case GPROP_INT: - sprintf(str, "%d", prop->data); - break; - case GPROP_FLOAT: - case GPROP_TIME: - sprintf(str, "%f", *((float *)&prop->data)); - break; - case GPROP_STRING: - BLI_strncpy(str, prop->poin, MAX_PROPSTRING); - break; + case GPROP_BOOL: + case GPROP_INT: + sprintf(str, "%d", prop->data); + break; + case GPROP_FLOAT: + case GPROP_TIME: + sprintf(str, "%f", *((float *)&prop->data)); + break; + case GPROP_STRING: + BLI_strncpy(str, prop->poin, MAX_PROPSTRING); + break; } } diff --git a/source/blender/blenkernel/intern/texture.c b/source/blender/blenkernel/intern/texture.c index 98f5f45f525..2c868ca2601 100644 --- a/source/blender/blenkernel/intern/texture.c +++ b/source/blender/blenkernel/intern/texture.c @@ -1492,7 +1492,7 @@ void BKE_free_pointdensity(PointDensity *pd) /* ------------------------------------------------------------------------- */ -void BKE_free_voxeldatadata(struct VoxelData *vd) +void BKE_free_voxeldatadata(VoxelData *vd) { if (vd->dataset) { MEM_freeN(vd->dataset); @@ -1501,17 +1501,17 @@ void BKE_free_voxeldatadata(struct VoxelData *vd) } -void BKE_free_voxeldata(struct VoxelData *vd) +void BKE_free_voxeldata(VoxelData *vd) { BKE_free_voxeldatadata(vd); MEM_freeN(vd); } -struct VoxelData *BKE_add_voxeldata(void) +VoxelData *BKE_add_voxeldata(void) { VoxelData *vd; - vd = MEM_callocN(sizeof(struct VoxelData), "voxeldata"); + vd = MEM_callocN(sizeof(VoxelData), "voxeldata"); vd->dataset = NULL; vd->resol[0] = vd->resol[1] = vd->resol[2] = 1; vd->interp_type = TEX_VD_LINEAR; @@ -1525,7 +1525,7 @@ struct VoxelData *BKE_add_voxeldata(void) return vd; } -struct VoxelData *BKE_copy_voxeldata(struct VoxelData *vd) +VoxelData *BKE_copy_voxeldata(VoxelData *vd) { VoxelData *vdn; @@ -1537,7 +1537,7 @@ struct VoxelData *BKE_copy_voxeldata(struct VoxelData *vd) /* ------------------------------------------------------------------------- */ -struct OceanTex *BKE_add_oceantex(void) +OceanTex *BKE_add_oceantex(void) { OceanTex *ot; @@ -1548,7 +1548,7 @@ struct OceanTex *BKE_add_oceantex(void) return ot; } -struct OceanTex *BKE_copy_oceantex(struct OceanTex *ot) +OceanTex *BKE_copy_oceantex(struct OceanTex *ot) { OceanTex *otn = MEM_dupallocN(ot); -- cgit v1.2.3