archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
ab063db34d60bdda6a683b13cef36d93ad6e760f
blender-archive/source/blender/editors/curve/editcurve_add.c
Germano Cavalcante f674976edd Curve: Remove 'CU_2D' flag used for nurbs 
This fixes T86440

As the CU_2D flag is set for nurbs, a Curve can have 2D nurbs mixed with 3D.

But the UI does not allow this mixing. It updates all nurbs to 2D or 3D when set.

So remove this specific flag for nurbs.

This may break old files, since 2D curves with mixed 3D are now set as 3D.

Differential Revision: https://developer.blender.org/D10738
2021-04-01 10:54:49 -03:00

842 lines
23 KiB
C
Raw Blame History

/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*/
/** \file
* \ingroup edcurve
*/
#include "DNA_anim_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BLI_math.h"
#include "BLT_translation.h"
#include "BKE_context.h"
#include "BKE_curve.h"
#include "DEG_depsgraph.h"
#include "RNA_access.h"
#include "WM_api.h"
#include "WM_types.h"
#include "ED_curve.h"
#include "ED_object.h"
#include "ED_screen.h"
#include "ED_view3d.h"
#include "curve_intern.h"
static const float nurbcircle[8][2] = {
{0.0, -1.0},
{-1.0, -1.0},
{-1.0, 0.0},
{-1.0, 1.0},
{0.0, 1.0},
{1.0, 1.0},
{1.0, 0.0},
{1.0, -1.0},
};
/************ add primitive, used by object/ module ****************/
static const char *get_curve_defname(int type)
{
int stype = type & CU_PRIMITIVE;
if ((type & CU_TYPE) == CU_BEZIER) {
switch (stype) {
case CU_PRIM_CURVE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "BezierCurve");
case CU_PRIM_CIRCLE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "BezierCircle");
case CU_PRIM_PATH:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "CurvePath");
default:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "Curve");
}
}
else {
switch (stype) {
case CU_PRIM_CURVE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "NurbsCurve");
case CU_PRIM_CIRCLE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "NurbsCircle");
case CU_PRIM_PATH:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "NurbsPath");
default:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "Curve");
}
}
}
static const char *get_surf_defname(int type)
{
int stype = type & CU_PRIMITIVE;
switch (stype) {
case CU_PRIM_CURVE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfCurve");
case CU_PRIM_CIRCLE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfCircle");
case CU_PRIM_PATCH:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfPatch");
case CU_PRIM_SPHERE:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfSphere");
case CU_PRIM_DONUT:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfTorus");
default:
return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "Surface");
}
}
Nurb *ED_curve_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);
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, SELECT, false);
/* these types call this function to return a Nurb */
if (!ELEM(stype, CU_PRIM_TUBE, 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) {
nu->pntsu = 2;
nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "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) * nu->pntsu, "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) * nu->pntsu, "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) {
nu->pntsu = 4;
nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "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) * nu->pntsu, "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 = ED_curve_add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0);
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, CU_IS_2D(cu));
ed_editnurb_extrude_flag(cu->editnurb, SELECT);
mul_v3_fl(vec, -2.0f);
ed_editnurb_translate_flag(editnurb, SELECT, vec, CU_IS_2D(cu));
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) {
const float tmp_cent[3] = {0.0f, 0.0f, 0.0f};
const float tmp_vec[3] = {0.0f, 0.0f, 1.0f};
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) * nu->pntsu, "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, NULL, obedit, tmp_vec, tmp_cent);
}
else if ((U.flag & USER_ADD_VIEWALIGNED)) {
ed_editnurb_spin(viewmat, NULL, obedit, zvec, mat[3]);
}
else {
ed_editnurb_spin(umat, NULL, 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) {
const float tmp_cent[3] = {0.0f, 0.0f, 0.0f};
const float tmp_vec[3] = {0.0f, 0.0f, 1.0f};
xzproj = 1;
nu = ED_curve_add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0);
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, NULL, obedit, tmp_vec, tmp_cent);
}
else if ((U.flag & USER_ADD_VIEWALIGNED)) {
ed_editnurb_spin(viewmat, NULL, obedit, zvec, mat[3]);
}
else {
ed_editnurb_spin(umat, NULL, 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;
if (CU_IS_2D(cu)) {
BKE_nurb_project_2d(nu);
}
}
return nu;
}
static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
{
struct Main *bmain = CTX_data_main(C);
Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
ListBase *editnurb;
Nurb *nu;
bool newob = false;
bool enter_editmode;
ushort local_view_bits;
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, NULL, &enter_editmode, &local_view_bits, NULL)) {
return OPERATOR_CANCELLED;
}
if (!isSurf) { /* adding curve */
if (obedit == NULL || obedit->type != OB_CURVE) {
const char *name = get_curve_defname(type);
Curve *cu;
obedit = ED_object_add_type(C, OB_CURVE, name, loc, rot, true, local_view_bits);
newob = true;
cu = (Curve *)obedit->data;
cu->flag |= CU_DEFORM_FILL;
if (type & CU_PRIM_PATH) {
cu->flag |= CU_PATH | CU_3D;
}
}
else {
DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
}
}
else { /* adding surface */
if (obedit == NULL || obedit->type != OB_SURF) {
const char *name = get_surf_defname(type);
obedit = ED_object_add_type(C, OB_SURF, name, loc, rot, true, local_view_bits);
newob = true;
}
else {
DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
}
}
ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
dia = RNA_float_get(op->ptr, "radius");
mul_mat3_m4_fl(mat, dia);
nu = ED_curve_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_ex(bmain, scene, obedit, EM_FREEDATA);
}
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
return OPERATOR_FINISHED;
}
static int curve_prim_add(bContext *C, wmOperator *op, int type)
{
return curvesurf_prim_add(C, op, type, 0);
}
static int surf_prim_add(bContext *C, wmOperator *op, int type)
{
return curvesurf_prim_add(C, op, type, 1);
}
/* ******************** Curves ******************* */
static int add_primitive_bezier_exec(bContext *C, wmOperator *op)
{
return curve_prim_add(C, op, CU_BEZIER | CU_PRIM_CURVE);
}
void CURVE_OT_primitive_bezier_curve_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Bezier";
ot->description = "Construct a Bezier Curve";
ot->idname = "CURVE_OT_primitive_bezier_curve_add";
/* api callbacks */
ot->exec = add_primitive_bezier_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_bezier_circle_exec(bContext *C, wmOperator *op)
{
return curve_prim_add(C, op, CU_BEZIER | CU_PRIM_CIRCLE);
}
void CURVE_OT_primitive_bezier_circle_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Bezier Circle";
ot->description = "Construct a Bezier Circle";
ot->idname = "CURVE_OT_primitive_bezier_circle_add";
/* api callbacks */
ot->exec = add_primitive_bezier_circle_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_curve_exec(bContext *C, wmOperator *op)
{
return curve_prim_add(C, op, CU_NURBS | CU_PRIM_CURVE);
}
void CURVE_OT_primitive_nurbs_curve_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Nurbs Curve";
ot->description = "Construct a Nurbs Curve";
ot->idname = "CURVE_OT_primitive_nurbs_curve_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_curve_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_circle_exec(bContext *C, wmOperator *op)
{
return curve_prim_add(C, op, CU_NURBS | CU_PRIM_CIRCLE);
}
void CURVE_OT_primitive_nurbs_circle_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Nurbs Circle";
ot->description = "Construct a Nurbs Circle";
ot->idname = "CURVE_OT_primitive_nurbs_circle_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_circle_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_curve_path_exec(bContext *C, wmOperator *op)
{
return curve_prim_add(C, op, CU_NURBS | CU_PRIM_PATH);
}
void CURVE_OT_primitive_nurbs_path_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Path";
ot->description = "Construct a Path";
ot->idname = "CURVE_OT_primitive_nurbs_path_add";
/* api callbacks */
ot->exec = add_primitive_curve_path_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
/* **************** NURBS surfaces ********************** */
static int add_primitive_nurbs_surface_curve_exec(bContext *C, wmOperator *op)
{
return surf_prim_add(C, op, CU_PRIM_CURVE | CU_NURBS);
}
void SURFACE_OT_primitive_nurbs_surface_curve_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Surface Curve";
ot->description = "Construct a Nurbs surface Curve";
ot->idname = "SURFACE_OT_primitive_nurbs_surface_curve_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_surface_curve_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_surface_circle_exec(bContext *C, wmOperator *op)
{
return surf_prim_add(C, op, CU_PRIM_CIRCLE | CU_NURBS);
}
void SURFACE_OT_primitive_nurbs_surface_circle_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Surface Circle";
ot->description = "Construct a Nurbs surface Circle";
ot->idname = "SURFACE_OT_primitive_nurbs_surface_circle_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_surface_circle_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_surface_surface_exec(bContext *C, wmOperator *op)
{
return surf_prim_add(C, op, CU_PRIM_PATCH | CU_NURBS);
}
void SURFACE_OT_primitive_nurbs_surface_surface_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Surface Patch";
ot->description = "Construct a Nurbs surface Patch";
ot->idname = "SURFACE_OT_primitive_nurbs_surface_surface_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_surface_surface_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_surface_cylinder_exec(bContext *C, wmOperator *op)
{
return surf_prim_add(C, op, CU_PRIM_TUBE | CU_NURBS);
}
void SURFACE_OT_primitive_nurbs_surface_cylinder_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Surface Cylinder";
ot->description = "Construct a Nurbs surface Cylinder";
ot->idname = "SURFACE_OT_primitive_nurbs_surface_cylinder_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_surface_cylinder_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_surface_sphere_exec(bContext *C, wmOperator *op)
{
return surf_prim_add(C, op, CU_PRIM_SPHERE | CU_NURBS);
}
void SURFACE_OT_primitive_nurbs_surface_sphere_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Surface Sphere";
ot->description = "Construct a Nurbs surface Sphere";
ot->idname = "SURFACE_OT_primitive_nurbs_surface_sphere_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_surface_sphere_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
static int add_primitive_nurbs_surface_torus_exec(bContext *C, wmOperator *op)
{
return surf_prim_add(C, op, CU_PRIM_DONUT | CU_NURBS);
}
void SURFACE_OT_primitive_nurbs_surface_torus_add(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Surface Torus";
ot->description = "Construct a Nurbs surface Torus";
ot->idname = "SURFACE_OT_primitive_nurbs_surface_torus_add";
/* api callbacks */
ot->exec = add_primitive_nurbs_surface_torus_exec;
ot->poll = ED_operator_scene_editable;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
ED_object_add_unit_props_radius(ot);
ED_object_add_generic_props(ot, true);
}
View Git Blame Copy Permalink