Page MenuHome
Differential D6562 Diff 20729 source/blender/blenkernel/intern/curve.c

Changeset View

Standalone View

View Options

source/blender/blenkernel/intern/curve.c

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
} }
/* ***************** BEVEL ****************** */ /* ***************** BEVEL ****************** */
void BKE_curve_bevel_make(Object *ob, ListBase *disp) void BKE_curve_bevel_make(Object *ob, ListBase *disp)
{ {
DispList *dl, *dlnew; DispList *dl, *dlnew;
Curve *bevcu, *cu; Curve *bevcu, *cu;
float *fp, facx, facy, angle, dangle; float *fp, facx, facy, angle, angle_increment;
int nr, a; int nr, i;
cu = ob->data; cu = ob->data;
BLI_listbase_clear(disp); BLI_listbase_clear(disp);
/* if a font object is being edited, then do nothing */ /* if a font object is being edited, then do nothing */
// XXX if ( ob == obedit && ob->type == OB_FONT ) return; // XXX if ( ob == obedit && ob->type == OB_FONT ) return;
if (cu->bevobj) { if (cu->bevobj) {
Show All 39 Lines
} }
dl = dl->next; dl = dl->next;
} }
BKE_displist_free(&bevdisp); BKE_displist_free(&bevdisp);
} }
} }
else if (cu->ext1 == 0.0f && cu->ext2 == 0.0f) { else if (cu->ext1 == 0.0f && cu->ext2 == 0.0f) {
/* pass */ /* Don't build a mesh. */
} }
else if (cu->ext2 == 0.0f) { else if (cu->ext2 == 0.0f) {
dl = MEM_callocN(sizeof(DispList), "makebevelcurve2"); dl = MEM_callocN(sizeof(DispList), "makebevelcurve2");
dl->verts = MEM_malloc_arrayN(2, sizeof(float[3]), "makebevelcurve2"); dl->verts = MEM_malloc_arrayN(2, sizeof(float[3]), "makebevelcurve2");
BLI_addtail(disp, dl); BLI_addtail(disp, dl);
dl->type = DL_SEGM; dl->type = DL_SEGM;
dl->parts = 1; dl->parts = 1;
dl->flag = DL_FRONT_CURVE | DL_BACK_CURVE; dl->flag = DL_FRONT_CURVE | DL_BACK_CURVE;
dl->nr = 2; dl->nr = 2;
fp = dl->verts; fp = dl->verts;
fp[0] = fp[1] = 0.0; fp[0] = fp[1] = 0.0;
fp[2] = -cu->ext1; fp[2] = -cu->ext1;
fp[3] = fp[4] = 0.0; fp[3] = fp[4] = 0.0;
fp[5] = cu->ext1; fp[5] = cu->ext1;
} }
else if ((cu->flag & (CU_FRONT | CU_BACK)) == 0 && cu->ext1 == 0.0f) { else if ((cu->flag & (CU_FRONT | CU_BACK)) == 0 && cu->ext1 == 0.0f) {
/* We make a full round bevel in that case. */ /* Use a separate simple case for the full loop with no extrusion. */
nr = 4 + 2 * cu->bevresol; nr = 4 + 2 * cu->bevresol;
dl = MEM_callocN(sizeof(DispList), "makebevelcurve p1"); dl = MEM_callocN(sizeof(DispList), "makebevelcurve");
dl->verts = MEM_malloc_arrayN(nr, sizeof(float[3]), "makebevelcurve p1"); dl->verts = MEM_malloc_arrayN(nr, sizeof(float[3]), "makebevelcurve");
BLI_addtail(disp, dl); BLI_addtail(disp, dl);
dl->type = DL_POLY; dl->type = DL_POLY;
dl->parts = 1; dl->parts = 1;
dl->flag = DL_BACK_CURVE; dl->flag = DL_BACK_CURVE;
dl->nr = nr; dl->nr = nr;
/* a circle */ /* Build the circle. */
fp = dl->verts; fp = dl->verts;
dangle = (2.0f * (float)M_PI / (nr)); angle_increment = 2.0f * (float)M_PI / (nr);
angle = -(nr - 1) * dangle; angle = -(nr - 1) * angle_increment;
for (a = 0; a < nr; a++) { for (i = 0; i < nr; i++) {
fp[0] = 0.0; fp[0] = 0.0;
fp[1] = (cosf(angle) * (cu->ext2)); fp[1] = cosf(angle) * cu->ext2;
fp[2] = (sinf(angle) * (cu->ext2)) - cu->ext1; fp[2] = sinf(angle) * cu->ext2;
angle += dangle; angle += angle_increment;
fp += 3; fp += 3;
} }
} }
else { else {
short dnr; /* The general case for nonzero extrusion or an incomplete loop. */
/* bevel now in three parts, for proper vertex normals */
/* part 1, back */
if ((cu->flag & CU_BACK) || !(cu->flag & CU_FRONT)) {
dnr = nr = 2 + cu->bevresol;
if ((cu->flag & (CU_FRONT | CU_BACK)) == 0) {
nr = 3 + 2 * cu->bevresol;
}
dl = MEM_callocN(sizeof(DispList), "makebevelcurve p1");
dl->verts = MEM_malloc_arrayN(nr, sizeof(float[3]), "makebevelcurve p1");
BLI_addtail(disp, dl);
dl->type = DL_SEGM;
dl->parts = 1;
dl->flag = DL_BACK_CURVE;
dl->nr = nr;
/* half a circle */
fp = dl->verts;
dangle = ((float)M_PI_2 / (dnr - 1));
angle = -(nr - 1) * dangle;
for (a = 0; a < nr; a++) {
fp[0] = 0.0;
fp[1] = (float)(cosf(angle) * (cu->ext2));
fp[2] = (float)(sinf(angle) * (cu->ext2)) - cu->ext1;
angle += dangle;
fp += 3;
}
}
/* part 2, sidefaces */ if ((cu->flag & (CU_FRONT | CU_BACK)) == 0) {
if (cu->ext1 != 0.0f) { /* The full loop. */
nr = 2; nr = 4 * cu->bevresol + 6;
dl->flag = DL_FRONT_CURVE | DL_BACK_CURVE;
mano-wiiUnsubmitted
Done
Inline Actions
Warning	C4700	uninitialized local variable 'dl' used
mano-wii: ``` Warning C4700 uninitialized local variable 'dl' used ```
dl = MEM_callocN(sizeof(DispList), "makebevelcurve p2"); }
dl->verts = MEM_malloc_arrayN(nr, sizeof(float[3]), "makebevelcurve p2"); else if ((cu->flag & CU_FRONT) && (cu->flag & CU_BACK)) {
BLI_addtail(disp, dl); /* Half the loop. */
dl->type = DL_SEGM; nr = 2 * (cu->bevresol + 1) + ((cu->ext1 == 0.0f) ? 1 : 2);
dl->parts = 1; dl->flag = DL_FRONT_CURVE | DL_BACK_CURVE;
dl->nr = nr; }
else {
/* One quarter of the loop (just front or back). */
nr = (cu->ext1 == 0.0f) ? cu->bevresol + 2 : cu->bevresol + 3;
dl->flag = (cu->flag & CU_FRONT) ? DL_FRONT_CURVE : DL_BACK_CURVE;
mano-wiiUnsubmitted
Done
Inline Actions
Warning	C6001	Using uninitialized memory 'dl'.
mano-wii: ``` Warning C6001 Using uninitialized memory 'dl'. ```
}
fp = dl->verts; dl = MEM_callocN(sizeof(DispList), "makebevelcurve");
fp[1] = cu->ext2; dl->verts = MEM_malloc_arrayN(nr, sizeof(float[3]), "makebevelcurve");
fp[2] = -cu->ext1; BLI_addtail(disp, dl);
fp[4] = cu->ext2; /* Use a different type depending on whether the loop is complete or not. */
fp[5] = cu->ext1; dl->type = ((cu->flag & (CU_FRONT | CU_BACK)) == 0) ? DL_POLY : DL_SEGM;
dl->parts = 1;
dl->nr = nr;
if ((cu->flag & (CU_FRONT | CU_BACK)) == 0) { fp = dl->verts;
dl = MEM_dupallocN(dl); angle_increment = (float)M_PI_2 / (cu->bevresol + 1);
dl->verts = MEM_dupallocN(dl->verts);
BLI_addtail(disp, dl);
fp = dl->verts; /* Build the back section. */
fp[1] = -fp[1]; if (cu->flag & CU_BACK || !(cu->flag & (CU_FRONT | CU_BACK))) {
mano-wiiUnsubmitted
Not Done
Inline Actions

These bitwise operations are a bit confusing.
For example, in this case, the CU_BACK flag does not need to be tested again.

In my opinion, this makes it easier to understand:

if (cu->flag & CU_BACK || !(cu->flag & CU_FRONT)) {

But I may be missing something. This is not very important.

mano-wii: These bitwise operations are a bit confusing. For example, in this case, the `CU_BACK` flag…
HooglyBooglyAuthorUnsubmitted
Done
Inline Actions

I agree they are confusing, your suggestion of not checking flags that were already checked cleaned it up a bit.

HooglyBoogly: I agree they are confusing, your suggestion of not checking flags that were already checked…
fp[2] = -fp[2]; angle = (float)M_PI_2 * 3.0f;
fp[4] = -fp[4]; for (i = 0; i < cu->bevresol + 2; i++) {
fp[5] = -fp[5]; fp[0] = 0.0;
fp[1] = (float)cosf(angle) * cu->ext2;
mano-wiiUnsubmitted
Done
Inline Actions
Warning	C4701	potentially uninitialized local variable 'angle' used
mano-wii: ``` Warning C4701 potentially uninitialized local variable 'angle' used ```
fp[2] = (float)sinf(angle) * cu->ext2 - cu->ext1;
campbellbartonUnsubmitted
Done
Inline Actions

Changes to parenthesis here (and elsewhere) lower the precision of operations (so the multiplication is done on floats instead of doubles), although it's unlikely to cause issues, prefer to keep this as is since it's not the purpose of this patch to make these kinds of changes.

campbellbarton: Changes to parenthesis here (and elsewhere) lower the precision of operations (so the…
angle += angle_increment;
fp += 3;
}
if ((cu->ext1 != 0.0f) && !(cu->flag & CU_FRONT) && (cu->flag & (CU_FRONT | CU_BACK))) {
/* Add the extrusion if we're only building the back. */
fp[0] = 0.0;
fp[1] = cu->ext2;
fp[2] = cu->ext1;
} }
} }
/* part 3, front */ /* Build the front section. */
if ((cu->flag & CU_FRONT) || !(cu->flag & CU_BACK)) { if (cu->flag & CU_FRONT || !(cu->flag & (CU_FRONT | CU_BACK))) {
dnr = nr = 2 + cu->bevresol; if ((cu->ext1 != 0.0f) && !(cu->flag & CU_BACK) && (cu->flag & (CU_FRONT | CU_BACK))) {
if ((cu->flag & (CU_FRONT | CU_BACK)) == 0) { /* Add the extrusion if we're only building the back. */
nr = 3 + 2 * cu->bevresol; fp[0] = 0.0;
fp[1] = cu->ext2;
fp[2] = -cu->ext1;
fp += 3;
} }
dl = MEM_callocN(sizeof(DispList), "makebevelcurve p3"); /* Don't duplicate the last back vertex. */
dl->verts = MEM_malloc_arrayN(nr, sizeof(float[3]), "makebevelcurve p3"); angle = (cu->ext1 == 0.0f && (cu->flag & CU_BACK)) ? angle_increment : 0;
BLI_addtail(disp, dl); for (i = 0; i < cu->bevresol + 2; i++) {
dl->type = DL_SEGM; fp[0] = 0.0;
dl->flag = DL_FRONT_CURVE; fp[1] = (float)cosf(angle) * cu->ext2;
dl->parts = 1; fp[2] = (float)sinf(angle) * cu->ext2 + cu->ext1;
dl->nr = nr; angle += angle_increment;
fp += 3;
}
}
/* half a circle */ /* Build the other half only if we're building the full loop. */
fp = dl->verts; if (!(cu->flag & (CU_FRONT | CU_BACK))) {
angle = 0.0; for (i = 0; i < cu->bevresol + 1; i++) {
dangle = ((float)M_PI_2 / (dnr - 1)); fp[0] = 0.0;
fp[1] = (float)cosf(angle) * cu->ext2;
fp[2] = (float)sinf(angle) * cu->ext2 + cu->ext1;
angle += angle_increment;
fp += 3;
}
for (a = 0; a < nr; a++) { angle = (float)M_PI;
for (i = 0; i < cu->bevresol + 1; i++) {
fp[0] = 0.0; fp[0] = 0.0;
fp[1] = (float)(cosf(angle) * (cu->ext2)); fp[1] = (float)cosf(angle) * cu->ext2;
fp[2] = (float)(sinf(angle) * (cu->ext2)) + cu->ext1; fp[2] = (float)sinf(angle) * cu->ext2 - cu->ext1;
angle += dangle; angle += angle_increment;
fp += 3; fp += 3;
} }
} }
} }
} }
static int cu_isectLL(const float v1[3], static int cu_isectLL(const float v1[3],
const float v2[3], const float v2[3],
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines