Merge branch 'blender-v2.91-release'
[blender.git] / source / blender / editors / curve / editcurve_add.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edcurve
22  */
23
24 #include "DNA_anim_types.h"
25 #include "DNA_object_types.h"
26 #include "DNA_scene_types.h"
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_blenlib.h"
31 #include "BLI_math.h"
32
33 #include "BLT_translation.h"
34
35 #include "BKE_context.h"
36 #include "BKE_curve.h"
37
38 #include "DEG_depsgraph.h"
39
40 #include "RNA_access.h"
41
42 #include "WM_api.h"
43 #include "WM_types.h"
44
45 #include "ED_curve.h"
46 #include "ED_object.h"
47 #include "ED_screen.h"
48 #include "ED_view3d.h"
49
50 #include "curve_intern.h"
51
52 static const float nurbcircle[8][2] = {
53     {0.0, -1.0},
54     {-1.0, -1.0},
55     {-1.0, 0.0},
56     {-1.0, 1.0},
57     {0.0, 1.0},
58     {1.0, 1.0},
59     {1.0, 0.0},
60     {1.0, -1.0},
61 };
62
63 /************ add primitive, used by object/ module ****************/
64
65 static const char *get_curve_defname(int type)
66 {
67   int stype = type & CU_PRIMITIVE;
68
69   if ((type & CU_TYPE) == CU_BEZIER) {
70     switch (stype) {
71       case CU_PRIM_CURVE:
72         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "BezierCurve");
73       case CU_PRIM_CIRCLE:
74         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "BezierCircle");
75       case CU_PRIM_PATH:
76         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "CurvePath");
77       default:
78         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "Curve");
79     }
80   }
81   else {
82     switch (stype) {
83       case CU_PRIM_CURVE:
84         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "NurbsCurve");
85       case CU_PRIM_CIRCLE:
86         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "NurbsCircle");
87       case CU_PRIM_PATH:
88         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "NurbsPath");
89       default:
90         return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "Curve");
91     }
92   }
93 }
94
95 static const char *get_surf_defname(int type)
96 {
97   int stype = type & CU_PRIMITIVE;
98
99   switch (stype) {
100     case CU_PRIM_CURVE:
101       return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfCurve");
102     case CU_PRIM_CIRCLE:
103       return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfCircle");
104     case CU_PRIM_PATCH:
105       return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfPatch");
106     case CU_PRIM_SPHERE:
107       return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfSphere");
108     case CU_PRIM_DONUT:
109       return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "SurfTorus");
110     default:
111       return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE, "Surface");
112   }
113 }
114
115 Nurb *ED_curve_add_nurbs_primitive(
116     bContext *C, Object *obedit, float mat[4][4], int type, int newob)
117 {
118   static int xzproj = 0; /* this function calls itself... */
119   ListBase *editnurb = object_editcurve_get(obedit);
120   RegionView3D *rv3d = ED_view3d_context_rv3d(C);
121   Nurb *nu = NULL;
122   BezTriple *bezt;
123   BPoint *bp;
124   Curve *cu = (Curve *)obedit->data;
125   float vec[3], zvec[3] = {0.0f, 0.0f, 1.0f};
126   float umat[4][4], viewmat[4][4];
127   float fac;
128   int a, b;
129   const float grid = 1.0f;
130   const int cutype = (type & CU_TYPE); /* poly, bezier, nurbs, etc */
131   const int stype = (type & CU_PRIMITIVE);
132
133   unit_m4(umat);
134   unit_m4(viewmat);
135
136   if (rv3d) {
137     copy_m4_m4(viewmat, rv3d->viewmat);
138     copy_v3_v3(zvec, rv3d->viewinv[2]);
139   }
140
141   BKE_nurbList_flag_set(editnurb, SELECT, false);
142
143   /* these types call this function to return a Nurb */
144   if (stype != CU_PRIM_TUBE && stype != CU_PRIM_DONUT) {
145     nu = (Nurb *)MEM_callocN(sizeof(Nurb), "addNurbprim");
146     nu->type = cutype;
147     nu->resolu = cu->resolu;
148     nu->resolv = cu->resolv;
149   }
150
151   switch (stype) {
152     case CU_PRIM_CURVE: /* curve */
153       nu->resolu = cu->resolu;
154       if (cutype == CU_BEZIER) {
155         nu->pntsu = 2;
156         nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "addNurbprim1");
157         bezt = nu->bezt;
158         bezt->h1 = bezt->h2 = HD_ALIGN;
159         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
160         bezt->radius = 1.0;
161
162         bezt->vec[1][0] += -grid;
163         bezt->vec[0][0] += -1.5f * grid;
164         bezt->vec[0][1] += -0.5f * grid;
165         bezt->vec[2][0] += -0.5f * grid;
166         bezt->vec[2][1] += 0.5f * grid;
167         for (a = 0; a < 3; a++) {
168           mul_m4_v3(mat, bezt->vec[a]);
169         }
170
171         bezt++;
172         bezt->h1 = bezt->h2 = HD_ALIGN;
173         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
174         bezt->radius = bezt->weight = 1.0;
175
176         bezt->vec[0][0] = 0;
177         bezt->vec[0][1] = 0;
178         bezt->vec[1][0] = grid;
179         bezt->vec[1][1] = 0;
180         bezt->vec[2][0] = grid * 2;
181         bezt->vec[2][1] = 0;
182         for (a = 0; a < 3; a++) {
183           mul_m4_v3(mat, bezt->vec[a]);
184         }
185
186         BKE_nurb_handles_calc(nu);
187       }
188       else {
189
190         nu->pntsu = 4;
191         nu->pntsv = 1;
192         nu->orderu = 4;
193         nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim3");
194
195         bp = nu->bp;
196         for (a = 0; a < 4; a++, bp++) {
197           bp->vec[3] = 1.0;
198           bp->f1 = SELECT;
199           bp->radius = bp->weight = 1.0;
200         }
201
202         bp = nu->bp;
203         bp->vec[0] += -1.5f * grid;
204         bp++;
205         bp->vec[0] += -grid;
206         bp->vec[1] += grid;
207         bp++;
208         bp->vec[0] += grid;
209         bp->vec[1] += grid;
210         bp++;
211         bp->vec[0] += 1.5f * grid;
212
213         bp = nu->bp;
214         for (a = 0; a < 4; a++, bp++) {
215           mul_m4_v3(mat, bp->vec);
216         }
217
218         if (cutype == CU_NURBS) {
219           nu->knotsu = NULL; /* nurbs_knot_calc_u allocates */
220           BKE_nurb_knot_calc_u(nu);
221         }
222       }
223       break;
224     case CU_PRIM_PATH: /* 5 point path */
225       nu->pntsu = 5;
226       nu->pntsv = 1;
227       nu->orderu = 5;
228       nu->flagu = CU_NURB_ENDPOINT; /* endpoint */
229       nu->resolu = cu->resolu;
230       nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim3");
231
232       bp = nu->bp;
233       for (a = 0; a < 5; a++, bp++) {
234         bp->vec[3] = 1.0;
235         bp->f1 = SELECT;
236         bp->radius = bp->weight = 1.0;
237       }
238
239       bp = nu->bp;
240       bp->vec[0] += -2.0f * grid;
241       bp++;
242       bp->vec[0] += -grid;
243       bp++;
244       bp++;
245       bp->vec[0] += grid;
246       bp++;
247       bp->vec[0] += 2.0f * grid;
248
249       bp = nu->bp;
250       for (a = 0; a < 5; a++, bp++) {
251         mul_m4_v3(mat, bp->vec);
252       }
253
254       if (cutype == CU_NURBS) {
255         nu->knotsu = NULL; /* nurbs_knot_calc_u allocates */
256         BKE_nurb_knot_calc_u(nu);
257       }
258
259       break;
260     case CU_PRIM_CIRCLE: /* circle */
261       nu->resolu = cu->resolu;
262
263       if (cutype == CU_BEZIER) {
264         nu->pntsu = 4;
265         nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "addNurbprim1");
266         nu->flagu = CU_NURB_CYCLIC;
267         bezt = nu->bezt;
268
269         bezt->h1 = bezt->h2 = HD_AUTO;
270         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
271         bezt->vec[1][0] += -grid;
272         for (a = 0; a < 3; a++) {
273           mul_m4_v3(mat, bezt->vec[a]);
274         }
275         bezt->radius = bezt->weight = 1.0;
276
277         bezt++;
278         bezt->h1 = bezt->h2 = HD_AUTO;
279         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
280         bezt->vec[1][1] += grid;
281         for (a = 0; a < 3; a++) {
282           mul_m4_v3(mat, bezt->vec[a]);
283         }
284         bezt->radius = bezt->weight = 1.0;
285
286         bezt++;
287         bezt->h1 = bezt->h2 = HD_AUTO;
288         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
289         bezt->vec[1][0] += grid;
290         for (a = 0; a < 3; a++) {
291           mul_m4_v3(mat, bezt->vec[a]);
292         }
293         bezt->radius = bezt->weight = 1.0;
294
295         bezt++;
296         bezt->h1 = bezt->h2 = HD_AUTO;
297         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
298         bezt->vec[1][1] += -grid;
299         for (a = 0; a < 3; a++) {
300           mul_m4_v3(mat, bezt->vec[a]);
301         }
302         bezt->radius = bezt->weight = 1.0;
303
304         BKE_nurb_handles_calc(nu);
305       }
306       else if (cutype == CU_NURBS) { /* nurb */
307         nu->pntsu = 8;
308         nu->pntsv = 1;
309         nu->orderu = 4;
310         nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim6");
311         nu->flagu = CU_NURB_CYCLIC;
312         bp = nu->bp;
313
314         for (a = 0; a < 8; a++) {
315           bp->f1 = SELECT;
316           if (xzproj == 0) {
317             bp->vec[0] += nurbcircle[a][0] * grid;
318             bp->vec[1] += nurbcircle[a][1] * grid;
319           }
320           else {
321             bp->vec[0] += 0.25f * nurbcircle[a][0] * grid - 0.75f * grid;
322             bp->vec[2] += 0.25f * nurbcircle[a][1] * grid;
323           }
324           if (a & 1) {
325             bp->vec[3] = 0.25 * M_SQRT2;
326           }
327           else {
328             bp->vec[3] = 1.0;
329           }
330           mul_m4_v3(mat, bp->vec);
331           bp->radius = bp->weight = 1.0;
332
333           bp++;
334         }
335
336         BKE_nurb_knot_calc_u(nu);
337       }
338       break;
339     case CU_PRIM_PATCH:         /* 4x4 patch */
340       if (cutype == CU_NURBS) { /* nurb */
341
342         nu->pntsu = 4;
343         nu->pntsv = 4;
344         nu->orderu = 4;
345         nu->orderv = 4;
346         nu->flag = CU_SMOOTH;
347         nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * (4 * 4), "addNurbprim6");
348         nu->flagu = 0;
349         nu->flagv = 0;
350         bp = nu->bp;
351
352         for (a = 0; a < 4; a++) {
353           for (b = 0; b < 4; b++) {
354             bp->f1 = SELECT;
355             fac = (float)a - 1.5f;
356             bp->vec[0] += fac * grid;
357             fac = (float)b - 1.5f;
358             bp->vec[1] += fac * grid;
359             if ((a == 1 || a == 2) && (b == 1 || b == 2)) {
360               bp->vec[2] += grid;
361             }
362             mul_m4_v3(mat, bp->vec);
363             bp->vec[3] = 1.0;
364             bp++;
365           }
366         }
367
368         BKE_nurb_knot_calc_u(nu);
369         BKE_nurb_knot_calc_v(nu);
370       }
371       break;
372     case CU_PRIM_TUBE: /* Cylinder */
373       if (cutype == CU_NURBS) {
374         nu = ED_curve_add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0);
375         nu->resolu = cu->resolu;
376         nu->flag = CU_SMOOTH;
377         BLI_addtail(editnurb, nu); /* temporal for extrude and translate */
378         vec[0] = vec[1] = 0.0;
379         vec[2] = -grid;
380
381         mul_mat3_m4_v3(mat, vec);
382
383         ed_editnurb_translate_flag(editnurb, SELECT, vec);
384         ed_editnurb_extrude_flag(cu->editnurb, SELECT);
385         mul_v3_fl(vec, -2.0f);
386         ed_editnurb_translate_flag(editnurb, SELECT, vec);
387
388         BLI_remlink(editnurb, nu);
389
390         a = nu->pntsu * nu->pntsv;
391         bp = nu->bp;
392         while (a-- > 0) {
393           bp->f1 |= SELECT;
394           bp++;
395         }
396       }
397       break;
398     case CU_PRIM_SPHERE: /* sphere */
399       if (cutype == CU_NURBS) {
400         const float tmp_cent[3] = {0.f, 0.f, 0.f};
401         const float tmp_vec[3] = {0.f, 0.f, 1.f};
402
403         nu->pntsu = 5;
404         nu->pntsv = 1;
405         nu->orderu = 3;
406         nu->resolu = cu->resolu;
407         nu->resolv = cu->resolv;
408         nu->flag = CU_SMOOTH;
409         nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim6");
410         nu->flagu = 0;
411         bp = nu->bp;
412
413         for (a = 0; a < 5; a++) {
414           bp->f1 = SELECT;
415           bp->vec[0] += nurbcircle[a][0] * grid;
416           bp->vec[2] += nurbcircle[a][1] * grid;
417           if (a & 1) {
418             bp->vec[3] = 0.5 * M_SQRT2;
419           }
420           else {
421             bp->vec[3] = 1.0;
422           }
423           mul_m4_v3(mat, bp->vec);
424           bp++;
425         }
426         nu->flagu = CU_NURB_BEZIER;
427         BKE_nurb_knot_calc_u(nu);
428
429         BLI_addtail(editnurb, nu); /* temporal for spin */
430
431         if (newob && (U.flag & USER_ADD_VIEWALIGNED) == 0) {
432           ed_editnurb_spin(umat, NULL, obedit, tmp_vec, tmp_cent);
433         }
434         else if ((U.flag & USER_ADD_VIEWALIGNED)) {
435           ed_editnurb_spin(viewmat, NULL, obedit, zvec, mat[3]);
436         }
437         else {
438           ed_editnurb_spin(umat, NULL, obedit, tmp_vec, mat[3]);
439         }
440
441         BKE_nurb_knot_calc_v(nu);
442
443         a = nu->pntsu * nu->pntsv;
444         bp = nu->bp;
445         while (a-- > 0) {
446           bp->f1 |= SELECT;
447           bp++;
448         }
449         BLI_remlink(editnurb, nu);
450       }
451       break;
452     case CU_PRIM_DONUT: /* torus */
453       if (cutype == CU_NURBS) {
454         const float tmp_cent[3] = {0.f, 0.f, 0.f};
455         const float tmp_vec[3] = {0.f, 0.f, 1.f};
456
457         xzproj = 1;
458         nu = ED_curve_add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0);
459         xzproj = 0;
460         nu->resolu = cu->resolu;
461         nu->resolv = cu->resolv;
462         nu->flag = CU_SMOOTH;
463         BLI_addtail(editnurb, nu); /* temporal for spin */
464
465         /* same as above */
466         if (newob && (U.flag & USER_ADD_VIEWALIGNED) == 0) {
467           ed_editnurb_spin(umat, NULL, obedit, tmp_vec, tmp_cent);
468         }
469         else if ((U.flag & USER_ADD_VIEWALIGNED)) {
470           ed_editnurb_spin(viewmat, NULL, obedit, zvec, mat[3]);
471         }
472         else {
473           ed_editnurb_spin(umat, NULL, obedit, tmp_vec, mat[3]);
474         }
475
476         BLI_remlink(editnurb, nu);
477
478         a = nu->pntsu * nu->pntsv;
479         bp = nu->bp;
480         while (a-- > 0) {
481           bp->f1 |= SELECT;
482           bp++;
483         }
484       }
485       break;
486
487     default: /* should never happen */
488       BLI_assert(!"invalid nurbs type");
489       return NULL;
490   }
491
492   BLI_assert(nu != NULL);
493
494   if (nu) { /* should always be set */
495     if ((obedit->type != OB_SURF) && ((cu->flag & CU_3D) == 0)) {
496       nu->flag |= CU_2D;
497     }
498
499     nu->flag |= CU_SMOOTH;
500     cu->actnu = BLI_listbase_count(editnurb);
501     cu->actvert = CU_ACT_NONE;
502
503     BKE_nurb_test_2d(nu);
504   }
505
506   return nu;
507 }
508
509 static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
510 {
511   struct Main *bmain = CTX_data_main(C);
512   Scene *scene = CTX_data_scene(C);
513   ViewLayer *view_layer = CTX_data_view_layer(C);
514   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
515   ListBase *editnurb;
516   Nurb *nu;
517   bool newob = false;
518   bool enter_editmode;
519   ushort local_view_bits;
520   float dia;
521   float loc[3], rot[3];
522   float mat[4][4];
523
524   WM_operator_view3d_unit_defaults(C, op);
525
526   if (!ED_object_add_generic_get_opts(
527           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
528     return OPERATOR_CANCELLED;
529   }
530
531   if (!isSurf) { /* adding curve */
532     if (obedit == NULL || obedit->type != OB_CURVE) {
533       const char *name = get_curve_defname(type);
534       Curve *cu;
535
536       obedit = ED_object_add_type(C, OB_CURVE, name, loc, rot, true, local_view_bits);
537       newob = true;
538
539       cu = (Curve *)obedit->data;
540       cu->flag |= CU_DEFORM_FILL;
541
542       if (type & CU_PRIM_PATH) {
543         cu->flag |= CU_PATH | CU_3D;
544       }
545     }
546     else {
547       DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
548     }
549   }
550   else { /* adding surface */
551     if (obedit == NULL || obedit->type != OB_SURF) {
552       const char *name = get_surf_defname(type);
553       obedit = ED_object_add_type(C, OB_SURF, name, loc, rot, true, local_view_bits);
554       newob = true;
555     }
556     else {
557       DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
558     }
559   }
560
561   ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
562   dia = RNA_float_get(op->ptr, "radius");
563   mul_mat3_m4_fl(mat, dia);
564
565   nu = ED_curve_add_nurbs_primitive(C, obedit, mat, type, newob);
566   editnurb = object_editcurve_get(obedit);
567   BLI_addtail(editnurb, nu);
568
569   /* userdef */
570   if (newob && !enter_editmode) {
571     ED_object_editmode_exit_ex(bmain, scene, obedit, EM_FREEDATA);
572   }
573
574   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
575
576   return OPERATOR_FINISHED;
577 }
578
579 static int curve_prim_add(bContext *C, wmOperator *op, int type)
580 {
581   return curvesurf_prim_add(C, op, type, 0);
582 }
583
584 static int surf_prim_add(bContext *C, wmOperator *op, int type)
585 {
586   return curvesurf_prim_add(C, op, type, 1);
587 }
588
589 /* ******************** Curves ******************* */
590
591 static int add_primitive_bezier_exec(bContext *C, wmOperator *op)
592 {
593   return curve_prim_add(C, op, CU_BEZIER | CU_PRIM_CURVE);
594 }
595
596 void CURVE_OT_primitive_bezier_curve_add(wmOperatorType *ot)
597 {
598   /* identifiers */
599   ot->name = "Add Bezier";
600   ot->description = "Construct a Bezier Curve";
601   ot->idname = "CURVE_OT_primitive_bezier_curve_add";
602
603   /* api callbacks */
604   ot->exec = add_primitive_bezier_exec;
605   ot->poll = ED_operator_scene_editable;
606
607   /* flags */
608   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
609
610   ED_object_add_unit_props_radius(ot);
611   ED_object_add_generic_props(ot, true);
612 }
613
614 static int add_primitive_bezier_circle_exec(bContext *C, wmOperator *op)
615 {
616   return curve_prim_add(C, op, CU_BEZIER | CU_PRIM_CIRCLE);
617 }
618
619 void CURVE_OT_primitive_bezier_circle_add(wmOperatorType *ot)
620 {
621   /* identifiers */
622   ot->name = "Add Bezier Circle";
623   ot->description = "Construct a Bezier Circle";
624   ot->idname = "CURVE_OT_primitive_bezier_circle_add";
625
626   /* api callbacks */
627   ot->exec = add_primitive_bezier_circle_exec;
628   ot->poll = ED_operator_scene_editable;
629
630   /* flags */
631   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
632
633   ED_object_add_unit_props_radius(ot);
634   ED_object_add_generic_props(ot, true);
635 }
636
637 static int add_primitive_nurbs_curve_exec(bContext *C, wmOperator *op)
638 {
639   return curve_prim_add(C, op, CU_NURBS | CU_PRIM_CURVE);
640 }
641
642 void CURVE_OT_primitive_nurbs_curve_add(wmOperatorType *ot)
643 {
644   /* identifiers */
645   ot->name = "Add Nurbs Curve";
646   ot->description = "Construct a Nurbs Curve";
647   ot->idname = "CURVE_OT_primitive_nurbs_curve_add";
648
649   /* api callbacks */
650   ot->exec = add_primitive_nurbs_curve_exec;
651   ot->poll = ED_operator_scene_editable;
652
653   /* flags */
654   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
655
656   ED_object_add_unit_props_radius(ot);
657   ED_object_add_generic_props(ot, true);
658 }
659
660 static int add_primitive_nurbs_circle_exec(bContext *C, wmOperator *op)
661 {
662   return curve_prim_add(C, op, CU_NURBS | CU_PRIM_CIRCLE);
663 }
664
665 void CURVE_OT_primitive_nurbs_circle_add(wmOperatorType *ot)
666 {
667   /* identifiers */
668   ot->name = "Add Nurbs Circle";
669   ot->description = "Construct a Nurbs Circle";
670   ot->idname = "CURVE_OT_primitive_nurbs_circle_add";
671
672   /* api callbacks */
673   ot->exec = add_primitive_nurbs_circle_exec;
674   ot->poll = ED_operator_scene_editable;
675
676   /* flags */
677   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
678
679   ED_object_add_unit_props_radius(ot);
680   ED_object_add_generic_props(ot, true);
681 }
682
683 static int add_primitive_curve_path_exec(bContext *C, wmOperator *op)
684 {
685   return curve_prim_add(C, op, CU_NURBS | CU_PRIM_PATH);
686 }
687
688 void CURVE_OT_primitive_nurbs_path_add(wmOperatorType *ot)
689 {
690   /* identifiers */
691   ot->name = "Add Path";
692   ot->description = "Construct a Path";
693   ot->idname = "CURVE_OT_primitive_nurbs_path_add";
694
695   /* api callbacks */
696   ot->exec = add_primitive_curve_path_exec;
697   ot->poll = ED_operator_scene_editable;
698
699   /* flags */
700   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
701
702   ED_object_add_unit_props_radius(ot);
703   ED_object_add_generic_props(ot, true);
704 }
705
706 /* **************** NURBS surfaces ********************** */
707 static int add_primitive_nurbs_surface_curve_exec(bContext *C, wmOperator *op)
708 {
709   return surf_prim_add(C, op, CU_PRIM_CURVE | CU_NURBS);
710 }
711
712 void SURFACE_OT_primitive_nurbs_surface_curve_add(wmOperatorType *ot)
713 {
714   /* identifiers */
715   ot->name = "Add Surface Curve";
716   ot->description = "Construct a Nurbs surface Curve";
717   ot->idname = "SURFACE_OT_primitive_nurbs_surface_curve_add";
718
719   /* api callbacks */
720   ot->exec = add_primitive_nurbs_surface_curve_exec;
721   ot->poll = ED_operator_scene_editable;
722
723   /* flags */
724   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
725
726   ED_object_add_unit_props_radius(ot);
727   ED_object_add_generic_props(ot, true);
728 }
729
730 static int add_primitive_nurbs_surface_circle_exec(bContext *C, wmOperator *op)
731 {
732   return surf_prim_add(C, op, CU_PRIM_CIRCLE | CU_NURBS);
733 }
734
735 void SURFACE_OT_primitive_nurbs_surface_circle_add(wmOperatorType *ot)
736 {
737   /* identifiers */
738   ot->name = "Add Surface Circle";
739   ot->description = "Construct a Nurbs surface Circle";
740   ot->idname = "SURFACE_OT_primitive_nurbs_surface_circle_add";
741
742   /* api callbacks */
743   ot->exec = add_primitive_nurbs_surface_circle_exec;
744   ot->poll = ED_operator_scene_editable;
745
746   /* flags */
747   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
748
749   ED_object_add_unit_props_radius(ot);
750   ED_object_add_generic_props(ot, true);
751 }
752
753 static int add_primitive_nurbs_surface_surface_exec(bContext *C, wmOperator *op)
754 {
755   return surf_prim_add(C, op, CU_PRIM_PATCH | CU_NURBS);
756 }
757
758 void SURFACE_OT_primitive_nurbs_surface_surface_add(wmOperatorType *ot)
759 {
760   /* identifiers */
761   ot->name = "Add Surface Patch";
762   ot->description = "Construct a Nurbs surface Patch";
763   ot->idname = "SURFACE_OT_primitive_nurbs_surface_surface_add";
764
765   /* api callbacks */
766   ot->exec = add_primitive_nurbs_surface_surface_exec;
767   ot->poll = ED_operator_scene_editable;
768
769   /* flags */
770   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
771
772   ED_object_add_unit_props_radius(ot);
773   ED_object_add_generic_props(ot, true);
774 }
775
776 static int add_primitive_nurbs_surface_cylinder_exec(bContext *C, wmOperator *op)
777 {
778   return surf_prim_add(C, op, CU_PRIM_TUBE | CU_NURBS);
779 }
780
781 void SURFACE_OT_primitive_nurbs_surface_cylinder_add(wmOperatorType *ot)
782 {
783   /* identifiers */
784   ot->name = "Add Surface Cylinder";
785   ot->description = "Construct a Nurbs surface Cylinder";
786   ot->idname = "SURFACE_OT_primitive_nurbs_surface_cylinder_add";
787
788   /* api callbacks */
789   ot->exec = add_primitive_nurbs_surface_cylinder_exec;
790   ot->poll = ED_operator_scene_editable;
791
792   /* flags */
793   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
794
795   ED_object_add_unit_props_radius(ot);
796   ED_object_add_generic_props(ot, true);
797 }
798
799 static int add_primitive_nurbs_surface_sphere_exec(bContext *C, wmOperator *op)
800 {
801   return surf_prim_add(C, op, CU_PRIM_SPHERE | CU_NURBS);
802 }
803
804 void SURFACE_OT_primitive_nurbs_surface_sphere_add(wmOperatorType *ot)
805 {
806   /* identifiers */
807   ot->name = "Add Surface Sphere";
808   ot->description = "Construct a Nurbs surface Sphere";
809   ot->idname = "SURFACE_OT_primitive_nurbs_surface_sphere_add";
810
811   /* api callbacks */
812   ot->exec = add_primitive_nurbs_surface_sphere_exec;
813   ot->poll = ED_operator_scene_editable;
814
815   /* flags */
816   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
817
818   ED_object_add_unit_props_radius(ot);
819   ED_object_add_generic_props(ot, true);
820 }
821
822 static int add_primitive_nurbs_surface_torus_exec(bContext *C, wmOperator *op)
823 {
824   return surf_prim_add(C, op, CU_PRIM_DONUT | CU_NURBS);
825 }
826
827 void SURFACE_OT_primitive_nurbs_surface_torus_add(wmOperatorType *ot)
828 {
829   /* identifiers */
830   ot->name = "Add Surface Torus";
831   ot->description = "Construct a Nurbs surface Torus";
832   ot->idname = "SURFACE_OT_primitive_nurbs_surface_torus_add";
833
834   /* api callbacks */
835   ot->exec = add_primitive_nurbs_surface_torus_exec;
836   ot->poll = ED_operator_scene_editable;
837
838   /* flags */
839   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
840
841   ED_object_add_unit_props_radius(ot);
842   ED_object_add_generic_props(ot, true);
843 }