static int object_add_surface_exec(bContext *C, wmOperator *op)
{
Object *obedit= CTX_data_edit_object(C);
ListBase *editnurb;
Nurb *nu;
int newob= 0;
if(obedit==NULL || obedit->type!=OB_SURF) {
ED_object_add_type(C, OB_SURF);
ED_object_enter_editmode(C, 0);
newob = 1;
}
else DAG_id_flush_update(&obedit->id, OB_RECALC_DATA);
obedit= CTX_data_edit_object(C);
nu= add_nurbs_primitive(C, RNA_enum_get(op->ptr, "type"), newob);
editnurb= curve_get_editcurve(obedit);
BLI_addtail(editnurb, nu);
/* userdef */
if (newob && (U.flag & USER_ADD_EDITMODE)==0) {
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
}
WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
/* for effector add primitive operators */
static Object *effector_add_type(bContext *C, int type)
{
Scene *scene= CTX_data_scene(C);
Object *ob;
/* for as long scene has editmode... */
if (CTX_data_edit_object(C))
ED_object_exit_editmode(C, EM_FREEDATA|EM_FREEUNDO|EM_WAITCURSOR|EM_DO_UNDO); /* freedata, and undo */
/* deselects all, sets scene->basact */
if(type==PFIELD_GUIDE) {
ob = add_object(scene, OB_CURVE);
((Curve*)ob->data)->flag |= CU_PATH|CU_3D;
ED_object_enter_editmode(C, 0);
BLI_addtail(curve_get_editcurve(ob), add_nurbs_primitive(C, CU_NURBS|CU_PRIM_PATH, 1));
ED_object_exit_editmode(C, EM_FREEDATA|EM_DO_UNDO);
}
else
ob= add_object(scene, OB_EMPTY);
ob->pd= object_add_collision_fields(type);
/* editor level activate, notifiers */
ED_base_object_activate(C, BASACT);
/* more editor stuff */
ED_object_base_init_from_view(C, BASACT);
DAG_scene_sort(scene);
return ob;
}
/* for effector add primitive operators */
static Object *effector_add_type(bContext *C, wmOperator *op, int type)
{
Object *ob;
int enter_editmode;
unsigned int layer;
float loc[3], rot[3];
float mat[4][4];
object_add_generic_invoke_options(C, op);
if(!ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer))
return NULL;
if(type==PFIELD_GUIDE) {
ob= ED_object_add_type(C, OB_CURVE, loc, rot, FALSE, layer);
rename_id(&ob->id, "CurveGuide");
((Curve*)ob->data)->flag |= CU_PATH|CU_3D;
ED_object_enter_editmode(C, 0);
ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
BLI_addtail(curve_get_editcurve(ob), add_nurbs_primitive(C, mat, CU_NURBS|CU_PRIM_PATH, 1));
if(!enter_editmode)
ED_object_exit_editmode(C, EM_FREEDATA);
}
else {
ob= ED_object_add_type(C, OB_EMPTY, loc, rot, FALSE, layer);
rename_id(&ob->id, "Field");
switch(type) {
case PFIELD_WIND:
case PFIELD_VORTEX:
ob->empty_drawtype = OB_SINGLE_ARROW;
break;
}
}
ob->pd= object_add_collision_fields(type);
DAG_scene_sort(CTX_data_main(C), CTX_data_scene(C));
return ob;
}
static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
{
Object *obedit = CTX_data_edit_object(C);
ListBase *editnurb;
Nurb *nu;
bool newob = false;
bool enter_editmode;
unsigned int layer;
float dia;
float loc[3], rot[3];
float mat[4][4];
WM_operator_view3d_unit_defaults(C, op);
if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &layer, NULL))
return OPERATOR_CANCELLED;
if (!isSurf) { /* adding curve */
if (obedit == NULL || obedit->type != OB_CURVE) {
Curve *cu;
obedit = ED_object_add_type(C, OB_CURVE, loc, rot, true, layer);
newob = true;
cu = (Curve *)obedit->data;
cu->flag |= CU_DEFORM_FILL;
if (type & CU_PRIM_PATH)
cu->flag |= CU_PATH | CU_3D;
}
else {
DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
}
}
else { /* adding surface */
if (obedit == NULL || obedit->type != OB_SURF) {
obedit = ED_object_add_type(C, OB_SURF, loc, rot, true, layer);
newob = true;
}
else {
DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
}
}
/* rename here, the undo stack checks name for valid undo pushes */
if (newob) {
if (obedit->type == OB_CURVE) {
rename_id((ID *)obedit, get_curve_defname(type));
rename_id((ID *)obedit->data, get_curve_defname(type));
}
else {
rename_id((ID *)obedit, get_surf_defname(type));
rename_id((ID *)obedit->data, get_surf_defname(type));
}
}
/* ED_object_add_type doesnt do an undo, is needed for redo operator on primitive */
if (newob && enter_editmode)
ED_undo_push(C, "Enter Editmode");
ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
dia = RNA_float_get(op->ptr, "radius");
mul_mat3_m4_fl(mat, dia);
nu = add_nurbs_primitive(C, obedit, mat, type, newob);
editnurb = object_editcurve_get(obedit);
BLI_addtail(editnurb, nu);
/* userdef */
if (newob && !enter_editmode) {
ED_object_editmode_exit(C, EM_FREEDATA);
}
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
Nurb *add_nurbs_primitive(bContext *C, Object *obedit, float mat[4][4], int type, int newob)
{
static int xzproj = 0; /* this function calls itself... */
ListBase *editnurb = object_editcurve_get(obedit);
RegionView3D *rv3d = ED_view3d_context_rv3d(C);
Nurb *nu = NULL;
BezTriple *bezt;
BPoint *bp;
Curve *cu = (Curve *)obedit->data;
float vec[3], zvec[3] = {0.0f, 0.0f, 1.0f};
float umat[4][4], viewmat[4][4];
float fac;
int a, b;
const float grid = 1.0f;
const int cutype = (type & CU_TYPE); // poly, bezier, nurbs, etc
const int stype = (type & CU_PRIMITIVE);
const int force_3d = ((Curve *)obedit->data)->flag & CU_3D; /* could be adding to an existing 3D curve */
unit_m4(umat);
unit_m4(viewmat);
if (rv3d) {
copy_m4_m4(viewmat, rv3d->viewmat);
copy_v3_v3(zvec, rv3d->viewinv[2]);
}
BKE_nurbList_flag_set(editnurb, 0);
/* these types call this function to return a Nurb */
if (stype != CU_PRIM_TUBE && stype != CU_PRIM_DONUT) {
nu = (Nurb *)MEM_callocN(sizeof(Nurb), "addNurbprim");
nu->type = cutype;
nu->resolu = cu->resolu;
nu->resolv = cu->resolv;
}
switch (stype) {
case CU_PRIM_CURVE: /* curve */
nu->resolu = cu->resolu;
if (cutype == CU_BEZIER) {
if (!force_3d) nu->flag |= CU_2D;
nu->pntsu = 2;
nu->bezt = (BezTriple *)MEM_callocN(2 * sizeof(BezTriple), "addNurbprim1");
bezt = nu->bezt;
bezt->h1 = bezt->h2 = HD_ALIGN;
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
bezt->radius = 1.0;
bezt->vec[1][0] += -grid;
bezt->vec[0][0] += -1.5f * grid;
bezt->vec[0][1] += -0.5f * grid;
bezt->vec[2][0] += -0.5f * grid;
bezt->vec[2][1] += 0.5f * grid;
for (a = 0; a < 3; a++) mul_m4_v3(mat, bezt->vec[a]);
bezt++;
bezt->h1 = bezt->h2 = HD_ALIGN;
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
bezt->radius = bezt->weight = 1.0;
bezt->vec[0][0] = 0;
bezt->vec[0][1] = 0;
bezt->vec[1][0] = grid;
bezt->vec[1][1] = 0;
bezt->vec[2][0] = grid * 2;
bezt->vec[2][1] = 0;
for (a = 0; a < 3; a++) mul_m4_v3(mat, bezt->vec[a]);
BKE_nurb_handles_calc(nu);
}
else {
nu->pntsu = 4;
nu->pntsv = 1;
nu->orderu = 4;
nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * 4, "addNurbprim3");
bp = nu->bp;
for (a = 0; a < 4; a++, bp++) {
bp->vec[3] = 1.0;
bp->f1 = SELECT;
bp->radius = bp->weight = 1.0;
}
bp = nu->bp;
bp->vec[0] += -1.5f * grid;
bp++;
bp->vec[0] += -grid;
bp->vec[1] += grid;
bp++;
bp->vec[0] += grid;
bp->vec[1] += grid;
bp++;
bp->vec[0] += 1.5f * grid;
bp = nu->bp;
for (a = 0; a < 4; a++, bp++) mul_m4_v3(mat, bp->vec);
if (cutype == CU_NURBS) {
nu->knotsu = NULL; /* nurbs_knot_calc_u allocates */
BKE_nurb_knot_calc_u(nu);
}
}
break;
case CU_PRIM_PATH: /* 5 point path */
nu->pntsu = 5;
nu->pntsv = 1;
nu->orderu = 5;
nu->flagu = CU_NURB_ENDPOINT; /* endpoint */
nu->resolu = cu->resolu;
nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * 5, "addNurbprim3");
bp = nu->bp;
for (a = 0; a < 5; a++, bp++) {
bp->vec[3] = 1.0;
bp->f1 = SELECT;
bp->radius = bp->weight = 1.0;
}
bp = nu->bp;
bp->vec[0] += -2.0f * grid;
bp++;
bp->vec[0] += -grid;
bp++; bp++;
bp->vec[0] += grid;
bp++;
bp->vec[0] += 2.0f * grid;
bp = nu->bp;
for (a = 0; a < 5; a++, bp++) mul_m4_v3(mat, bp->vec);
if (cutype == CU_NURBS) {
nu->knotsu = NULL; /* nurbs_knot_calc_u allocates */
BKE_nurb_knot_calc_u(nu);
}
break;
case CU_PRIM_CIRCLE: /* circle */
nu->resolu = cu->resolu;
if (cutype == CU_BEZIER) {
if (!force_3d) nu->flag |= CU_2D;
nu->pntsu = 4;
nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * 4, "addNurbprim1");
nu->flagu = CU_NURB_CYCLIC;
bezt = nu->bezt;
bezt->h1 = bezt->h2 = HD_AUTO;
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
bezt->vec[1][0] += -grid;
for (a = 0; a < 3; a++) mul_m4_v3(mat, bezt->vec[a]);
bezt->radius = bezt->weight = 1.0;
bezt++;
bezt->h1 = bezt->h2 = HD_AUTO;
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
bezt->vec[1][1] += grid;
for (a = 0; a < 3; a++) mul_m4_v3(mat, bezt->vec[a]);
bezt->radius = bezt->weight = 1.0;
bezt++;
bezt->h1 = bezt->h2 = HD_AUTO;
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
bezt->vec[1][0] += grid;
for (a = 0; a < 3; a++) mul_m4_v3(mat, bezt->vec[a]);
bezt->radius = bezt->weight = 1.0;
bezt++;
bezt->h1 = bezt->h2 = HD_AUTO;
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
bezt->vec[1][1] += -grid;
for (a = 0; a < 3; a++) mul_m4_v3(mat, bezt->vec[a]);
bezt->radius = bezt->weight = 1.0;
BKE_nurb_handles_calc(nu);
}
else if (cutype == CU_NURBS) { /* nurb */
nu->pntsu = 8;
nu->pntsv = 1;
nu->orderu = 4;
nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * 8, "addNurbprim6");
nu->flagu = CU_NURB_CYCLIC;
bp = nu->bp;
for (a = 0; a < 8; a++) {
bp->f1 = SELECT;
if (xzproj == 0) {
bp->vec[0] += nurbcircle[a][0] * grid;
bp->vec[1] += nurbcircle[a][1] * grid;
}
else {
bp->vec[0] += 0.25f * nurbcircle[a][0] * grid - 0.75f * grid;
bp->vec[2] += 0.25f * nurbcircle[a][1] * grid;
}
if (a & 1) bp->vec[3] = 0.25 * M_SQRT2;
else bp->vec[3] = 1.0;
mul_m4_v3(mat, bp->vec);
bp->radius = bp->weight = 1.0;
bp++;
}
BKE_nurb_knot_calc_u(nu);
}
break;
case CU_PRIM_PATCH: /* 4x4 patch */
if (cutype == CU_NURBS) { /* nurb */
nu->pntsu = 4;
nu->pntsv = 4;
nu->orderu = 4;
nu->orderv = 4;
nu->flag = CU_SMOOTH;
nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * (4 * 4), "addNurbprim6");
nu->flagu = 0;
nu->flagv = 0;
bp = nu->bp;
for (a = 0; a < 4; a++) {
for (b = 0; b < 4; b++) {
bp->f1 = SELECT;
fac = (float)a - 1.5f;
bp->vec[0] += fac * grid;
fac = (float)b - 1.5f;
bp->vec[1] += fac * grid;
if ((a == 1 || a == 2) && (b == 1 || b == 2)) {
bp->vec[2] += grid;
}
mul_m4_v3(mat, bp->vec);
bp->vec[3] = 1.0;
bp++;
}
}
BKE_nurb_knot_calc_u(nu);
BKE_nurb_knot_calc_v(nu);
}
break;
case CU_PRIM_TUBE: /* Cylinder */
if (cutype == CU_NURBS) {
nu = add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0); /* circle */
nu->resolu = cu->resolu;
nu->flag = CU_SMOOTH;
BLI_addtail(editnurb, nu); /* temporal for extrude and translate */
vec[0] = vec[1] = 0.0;
vec[2] = -grid;
mul_mat3_m4_v3(mat, vec);
ed_editnurb_translate_flag(editnurb, SELECT, vec);
ed_editnurb_extrude_flag(cu->editnurb, SELECT);
mul_v3_fl(vec, -2.0f);
ed_editnurb_translate_flag(editnurb, SELECT, vec);
BLI_remlink(editnurb, nu);
a = nu->pntsu * nu->pntsv;
bp = nu->bp;
while (a-- > 0) {
bp->f1 |= SELECT;
bp++;
}
}
break;
case CU_PRIM_SPHERE: /* sphere */
if (cutype == CU_NURBS) {
float tmp_cent[3] = {0.f, 0.f, 0.f};
float tmp_vec[3] = {0.f, 0.f, 1.f};
nu->pntsu = 5;
nu->pntsv = 1;
nu->orderu = 3;
nu->resolu = cu->resolu;
nu->resolv = cu->resolv;
nu->flag = CU_SMOOTH;
nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * 5, "addNurbprim6");
nu->flagu = 0;
bp = nu->bp;
for (a = 0; a < 5; a++) {
bp->f1 = SELECT;
bp->vec[0] += nurbcircle[a][0] * grid;
bp->vec[2] += nurbcircle[a][1] * grid;
if (a & 1) bp->vec[3] = 0.5 * M_SQRT2;
else bp->vec[3] = 1.0;
mul_m4_v3(mat, bp->vec);
bp++;
}
nu->flagu = CU_NURB_BEZIER;
BKE_nurb_knot_calc_u(nu);
BLI_addtail(editnurb, nu); /* temporal for spin */
if (newob && (U.flag & USER_ADD_VIEWALIGNED) == 0)
ed_editnurb_spin(umat, obedit, tmp_vec, tmp_cent);
else if ((U.flag & USER_ADD_VIEWALIGNED))
ed_editnurb_spin(viewmat, obedit, zvec, mat[3]);
else
ed_editnurb_spin(umat, obedit, tmp_vec, mat[3]);
BKE_nurb_knot_calc_v(nu);
a = nu->pntsu * nu->pntsv;
bp = nu->bp;
while (a-- > 0) {
bp->f1 |= SELECT;
bp++;
}
BLI_remlink(editnurb, nu);
}
break;
case CU_PRIM_DONUT: /* torus */
if (cutype == CU_NURBS) {
float tmp_cent[3] = {0.f, 0.f, 0.f};
float tmp_vec[3] = {0.f, 0.f, 1.f};
xzproj = 1;
nu = add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0); /* circle */
xzproj = 0;
nu->resolu = cu->resolu;
nu->resolv = cu->resolv;
nu->flag = CU_SMOOTH;
BLI_addtail(editnurb, nu); /* temporal for spin */
/* same as above */
if (newob && (U.flag & USER_ADD_VIEWALIGNED) == 0)
ed_editnurb_spin(umat, obedit, tmp_vec, tmp_cent);
else if ((U.flag & USER_ADD_VIEWALIGNED))
ed_editnurb_spin(viewmat, obedit, zvec, mat[3]);
else
ed_editnurb_spin(umat, obedit, tmp_vec, mat[3]);
BLI_remlink(editnurb, nu);
a = nu->pntsu * nu->pntsv;
bp = nu->bp;
while (a-- > 0) {
bp->f1 |= SELECT;
bp++;
}
}
break;
default: /* should never happen */
BLI_assert(!"invalid nurbs type");
return NULL;
}
BLI_assert(nu != NULL);
if (nu) { /* should always be set */
nu->flag |= CU_SMOOTH;
cu->actnu = BLI_listbase_count(editnurb);
cu->actvert = CU_ACT_NONE;
BKE_nurb_test2D(nu);
}
return nu;
}
