Page MenuHome
Differential D430 Diff 1347 source/blender/editors/curve/editcurve.c

Changeset View

Standalone View

View Options

source/blender/editors/curve/editcurve.c

Context not available.
/********************* smooth operator ********************/ /********************* smooth operator ********************/
static void smooth_single_bezt(BezTriple *beztOrig, BezTriple *bezt, int ind_prev, int ind_next, float factor)
{
float val, newval, offset;
int i;
if (factor > 1) {
campbellbartonAuthorUnsubmitted
Not Done
Inline Actions

Dont think this is needed - just BLI_assert(factor >= 0.0f && factor <= 1.0f)

campbellbarton: Dont think this is needed - just `BLI_assert(factor >= 0.0f && factor <= 1.0f)`
factor = 1;
}
else if (factor < 0) {
factor = 0;
}
/* iterate over 3 dimensions */
for (i = 0; i < 3; i++) {
/* get single dimension pos of the mid handle */
val = bezt->vec[1][i];
/* get the weights of the previous/next mid handles and calc offset */
newval = ((beztOrig + (ind_prev))->vec[1][i] * 0.5f) + ((beztOrig + (ind_next))->vec[1][i] * 0.5f);
offset = (val * ((1.0f / 6.0f) * 5.0f)) + (newval * (1.0f / 6.0f)) - val;
walidUnsubmitted
Not Done
Inline Actions

ops, missed to change this one :/

walid: ops, missed to change this one :/
/* offset midpoint and 2 handles */
bezt->vec[1][i] += offset;
bezt->vec[0][i] += offset;
bezt->vec[2][i] += offset;
}
}
campbellbartonAuthorUnsubmitted
Not Done
Inline Actions
  • No need to set these for every x/y/z axis.
  • Theres no check for cyclic.
campbellbarton: - No need to set these for every x/y/z axis. - Theres no check for cyclic.
/* Same as smooth_single_bezt(), keep these the same! */
static void smooth_single_bp(BPoint *bpOrig, BPoint *bp, int ind_prev, int ind_next, float factor)
{
float val, newval, offset;
int i;
if (factor > 1) {
campbellbartonAuthorUnsubmitted
Not Done
Inline Actions

again, just remove.

campbellbarton: again, just remove.
factor = 1;
}
else if (factor < 0) {
factor = 0;
}
for (i = 0; i < 3; i++) {
val = bp->vec[i];
newval = ((bpOrig + (ind_prev))->vec[i] * 0.5f) + ((bpOrig + (ind_next))->vec[i] * 0.5f);
offset = (val * ( 1 - factor)) + (newval * factor) - val;
bp->vec[i] += offset;
}
}
static int smooth_exec(bContext *C, wmOperator *UNUSED(op)) static int smooth_exec(bContext *C, wmOperator *UNUSED(op))
{ {
Object *obedit = CTX_data_edit_object(C); Object *obedit = CTX_data_edit_object(C);
Context not available.
Nurb *nu; Nurb *nu;
BezTriple *bezt, *beztOrig; BezTriple *bezt, *beztOrig;
BPoint *bp, *bpOrig; BPoint *bp, *bpOrig;
float val, newval, offset; int point_final;
int a, i; int a, ind_prev, ind_next;
bool changed = false; bool changed = false;
for (nu = editnurb->first; nu; nu = nu->next) { for (nu = editnurb->first; nu; nu = nu->next) {
if (nu->bezt) { if (nu->bezt) {
changed = false; changed = false;
/* duplicate the curve to use in weight calculation */
beztOrig = MEM_dupallocN(nu->bezt); beztOrig = MEM_dupallocN(nu->bezt);
for (bezt = &nu->bezt[1], a = 1; a < nu->pntsu - 1; a++, bezt++) {
/* check whether its cyclic or not, and set initial & final conditions */
if (nu->flagu & CU_NURB_CYCLIC) {
bezt = &nu->bezt[0];
a = 0;
point_final = nu->pntsu;
}
else {
bezt = &nu->bezt[1];
a = 1;
point_final = nu->pntsu - 1;
}
/* for all the curve points */
for (; a < point_final; a++, bezt++) {
/* respect selection */
walidUnsubmitted
Not Done
Inline Actions

we could be a bit cryptic and make it for(bp = &nu->bp[bias], a = bias; a < nu->pntsu - bias; a++, bp++)
and only set bias = 0 or bias = 1 if cyclic flag was raised,

should you make it cryptic, or leave it very simple like that?

walid: we could be a bit cryptic and make it for(bp = &nu->bp[bias], a = bias; a < nu->pntsu - bias…
if (bezt->f2 & SELECT) { if (bezt->f2 & SELECT) {
for (i = 0; i < 3; i++) {
val = bezt->vec[1][i]; /* respect cyclic in getting the previous/next points' indices */
newval = ((beztOrig + (a - 1))->vec[1][i] * 0.5f) + ((beztOrig + (a + 1))->vec[1][i] * 0.5f); if (nu->flagu & CU_NURB_CYCLIC) {
offset = (val * ((1.0f / 6.0f) * 5.0f)) + (newval * (1.0f / 6.0f)) - val; ind_prev = (a - 1 + nu->pntsu) % nu->pntsu;
/* offset handles */ ind_next = (a + 1 + nu->pntsu) % nu->pntsu;
bezt->vec[1][i] += offset; }
bezt->vec[0][i] += offset; else {
bezt->vec[2][i] += offset; ind_prev = a - 1;
ind_next = a + 1;
} }
smooth_single_bezt(beztOrig, bezt, ind_prev, ind_next, (1.0f / 6.0f));
changed = true; changed = true;
} }
} }
Context not available.
else if (nu->bp) { else if (nu->bp) {
bpOrig = MEM_dupallocN(nu->bp); bpOrig = MEM_dupallocN(nu->bp);
/* Same as above, keep these the same! */ /* Same as above, keep these the same! */
for (bp = &nu->bp[1], a = 1; a < nu->pntsu - 1; a++, bp++) {
if (nu->flagu & CU_NURB_CYCLIC) {
bp = &nu->bp[0];
a = 0;
point_final = nu->pntsu;
}
else {
bp = &nu->bp[1];
a = 1;
point_final = nu->pntsu - 1;
}
for (; a < point_final; a++, bp++) {
if (bp->f1 & SELECT) { if (bp->f1 & SELECT) {
for (i = 0; i < 3; i++) {
val = bp->vec[i]; /* respect cyclic in getting the previous/next points' indices */
newval = ((bpOrig + (a - 1))->vec[i] * 0.5f) + ((bpOrig + (a + 1))->vec[i] * 0.5f); if (nu->flagu & CU_NURB_CYCLIC) {
offset = (val * ((1.0f / 6.0f) * 5.0f)) + (newval * (1.0f / 6.0f)) - val; ind_prev = (a - 1 + nu->pntsu) % nu->pntsu;
ind_next = (a + 1 + nu->pntsu) % nu->pntsu;
bp->vec[i] += offset;
} }
else {
ind_prev = a - 1;
ind_next = a + 1;
}
smooth_single_bp(bpOrig, bp, ind_prev, ind_next, (1.0f / 6.0f));
} }
} }
MEM_freeN(bpOrig); MEM_freeN(bpOrig);
Context not available.