Blender  V3.3
editcurve_add.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved. */
3 
8 #include "DNA_anim_types.h"
9 #include "DNA_object_types.h"
10 #include "DNA_scene_types.h"
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "BLI_blenlib.h"
15 #include "BLI_math.h"
16 
17 #include "BLT_translation.h"
18 
19 #include "BKE_context.h"
20 #include "BKE_curve.h"
21 
22 #include "DEG_depsgraph.h"
23 
24 #include "RNA_access.h"
25 
26 #include "WM_api.h"
27 #include "WM_types.h"
28 
29 #include "ED_curve.h"
30 #include "ED_object.h"
31 #include "ED_screen.h"
32 #include "ED_view3d.h"
33 
34 #include "curve_intern.h"
35 
36 static const float nurbcircle[8][2] = {
37  {0.0, -1.0},
38  {-1.0, -1.0},
39  {-1.0, 0.0},
40  {-1.0, 1.0},
41  {0.0, 1.0},
42  {1.0, 1.0},
43  {1.0, 0.0},
44  {1.0, -1.0},
45 };
46 
47 /************ add primitive, used by object/ module ****************/
48 
49 static const char *get_curve_defname(int type)
50 {
51  int stype = type & CU_PRIMITIVE;
52 
53  if ((type & CU_TYPE) == CU_BEZIER) {
54  switch (stype) {
55  case CU_PRIM_CURVE:
56  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "BezierCurve");
57  case CU_PRIM_CIRCLE:
58  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "BezierCircle");
59  case CU_PRIM_PATH:
60  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "CurvePath");
61  default:
63  }
64  }
65  else {
66  switch (stype) {
67  case CU_PRIM_CURVE:
68  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "NurbsCurve");
69  case CU_PRIM_CIRCLE:
70  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "NurbsCircle");
71  case CU_PRIM_PATH:
72  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "NurbsPath");
73  default:
75  }
76  }
77 }
78 
79 static const char *get_surf_defname(int type)
80 {
81  int stype = type & CU_PRIMITIVE;
82 
83  switch (stype) {
84  case CU_PRIM_CURVE:
85  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "SurfCurve");
86  case CU_PRIM_CIRCLE:
87  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "SurfCircle");
88  case CU_PRIM_PATCH:
89  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "SurfPatch");
90  case CU_PRIM_TUBE:
91  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "SurfCylinder");
92  case CU_PRIM_SPHERE:
93  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "SurfSphere");
94  case CU_PRIM_DONUT:
95  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "SurfTorus");
96  default:
97  return CTX_DATA_(BLT_I18NCONTEXT_ID_CURVE_LEGACY, "Surface");
98  }
99 }
100 
102  bContext *C, Object *obedit, float mat[4][4], int type, int newob)
103 {
104  static int xzproj = 0; /* this function calls itself... */
105  ListBase *editnurb = object_editcurve_get(obedit);
107  Nurb *nu = NULL;
108  BezTriple *bezt;
109  BPoint *bp;
110  Curve *cu = (Curve *)obedit->data;
111  float vec[3], zvec[3] = {0.0f, 0.0f, 1.0f};
112  float umat[4][4], viewmat[4][4];
113  float fac;
114  int a, b;
115  const float grid = 1.0f;
116  const int cutype = (type & CU_TYPE); /* poly, bezier, nurbs, etc */
117  const int stype = (type & CU_PRIMITIVE);
118 
119  unit_m4(umat);
120  unit_m4(viewmat);
121 
122  if (rv3d) {
123  copy_m4_m4(viewmat, rv3d->viewmat);
124  copy_v3_v3(zvec, rv3d->viewinv[2]);
125  }
126 
127  BKE_nurbList_flag_set(editnurb, SELECT, false);
128 
129  /* these types call this function to return a Nurb */
130  if (!ELEM(stype, CU_PRIM_TUBE, CU_PRIM_DONUT)) {
131  nu = (Nurb *)MEM_callocN(sizeof(Nurb), "addNurbprim");
132  nu->type = cutype;
133  nu->resolu = cu->resolu;
134  nu->resolv = cu->resolv;
135  }
136 
137  switch (stype) {
138  case CU_PRIM_CURVE: /* curve */
139  nu->resolu = cu->resolu;
140  if (cutype == CU_BEZIER) {
141  nu->pntsu = 2;
142  nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "addNurbprim1");
143  bezt = nu->bezt;
144  bezt->h1 = bezt->h2 = HD_ALIGN;
145  bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
146  bezt->radius = 1.0;
147 
148  bezt->vec[1][0] += -grid;
149  bezt->vec[0][0] += -1.5f * grid;
150  bezt->vec[0][1] += -0.5f * grid;
151  bezt->vec[2][0] += -0.5f * grid;
152  bezt->vec[2][1] += 0.5f * grid;
153  for (a = 0; a < 3; a++) {
154  mul_m4_v3(mat, bezt->vec[a]);
155  }
156 
157  bezt++;
158  bezt->h1 = bezt->h2 = HD_ALIGN;
159  bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
160  bezt->radius = bezt->weight = 1.0;
161 
162  bezt->vec[0][0] = 0;
163  bezt->vec[0][1] = 0;
164  bezt->vec[1][0] = grid;
165  bezt->vec[1][1] = 0;
166  bezt->vec[2][0] = grid * 2;
167  bezt->vec[2][1] = 0;
168  for (a = 0; a < 3; a++) {
169  mul_m4_v3(mat, bezt->vec[a]);
170  }
171 
173  }
174  else {
175 
176  nu->pntsu = 4;
177  nu->pntsv = 1;
178  nu->orderu = 4;
179  nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim3");
180 
181  bp = nu->bp;
182  for (a = 0; a < 4; a++, bp++) {
183  bp->vec[3] = 1.0;
184  bp->f1 = SELECT;
185  bp->radius = bp->weight = 1.0;
186  }
187 
188  bp = nu->bp;
189  bp->vec[0] += -1.5f * grid;
190  bp++;
191  bp->vec[0] += -grid;
192  bp->vec[1] += grid;
193  bp++;
194  bp->vec[0] += grid;
195  bp->vec[1] += grid;
196  bp++;
197  bp->vec[0] += 1.5f * grid;
198 
199  bp = nu->bp;
200  for (a = 0; a < 4; a++, bp++) {
201  mul_m4_v3(mat, bp->vec);
202  }
203 
204  if (cutype == CU_NURBS) {
205  nu->knotsu = NULL; /* nurbs_knot_calc_u allocates */
207  }
208  }
209  break;
210  case CU_PRIM_PATH: /* 5 point path */
211  nu->pntsu = 5;
212  nu->pntsv = 1;
213  nu->orderu = 5;
214  nu->flagu = CU_NURB_ENDPOINT; /* endpoint */
215  nu->resolu = cu->resolu;
216  nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim3");
217 
218  bp = nu->bp;
219  for (a = 0; a < 5; a++, bp++) {
220  bp->vec[3] = 1.0;
221  bp->f1 = SELECT;
222  bp->radius = bp->weight = 1.0;
223  }
224 
225  bp = nu->bp;
226  bp->vec[0] += -2.0f * grid;
227  bp++;
228  bp->vec[0] += -grid;
229  bp++;
230  bp++;
231  bp->vec[0] += grid;
232  bp++;
233  bp->vec[0] += 2.0f * grid;
234 
235  bp = nu->bp;
236  for (a = 0; a < 5; a++, bp++) {
237  mul_m4_v3(mat, bp->vec);
238  }
239 
240  if (cutype == CU_NURBS) {
241  nu->knotsu = NULL; /* nurbs_knot_calc_u allocates */
243  }
244 
245  break;
246  case CU_PRIM_CIRCLE: /* circle */
247  nu->resolu = cu->resolu;
248 
249  if (cutype == CU_BEZIER) {
250  nu->pntsu = 4;
251  nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "addNurbprim1");
252  nu->flagu = CU_NURB_CYCLIC;
253  bezt = nu->bezt;
254 
255  bezt->h1 = bezt->h2 = HD_AUTO;
256  bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
257  bezt->vec[1][0] += -grid;
258  for (a = 0; a < 3; a++) {
259  mul_m4_v3(mat, bezt->vec[a]);
260  }
261  bezt->radius = bezt->weight = 1.0;
262 
263  bezt++;
264  bezt->h1 = bezt->h2 = HD_AUTO;
265  bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
266  bezt->vec[1][1] += grid;
267  for (a = 0; a < 3; a++) {
268  mul_m4_v3(mat, bezt->vec[a]);
269  }
270  bezt->radius = bezt->weight = 1.0;
271 
272  bezt++;
273  bezt->h1 = bezt->h2 = HD_AUTO;
274  bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
275  bezt->vec[1][0] += grid;
276  for (a = 0; a < 3; a++) {
277  mul_m4_v3(mat, bezt->vec[a]);
278  }
279  bezt->radius = bezt->weight = 1.0;
280 
281  bezt++;
282  bezt->h1 = bezt->h2 = HD_AUTO;
283  bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
284  bezt->vec[1][1] += -grid;
285  for (a = 0; a < 3; a++) {
286  mul_m4_v3(mat, bezt->vec[a]);
287  }
288  bezt->radius = bezt->weight = 1.0;
289 
291  }
292  else if (cutype == CU_NURBS) { /* nurb */
293  nu->pntsu = 8;
294  nu->pntsv = 1;
295  nu->orderu = 3;
296  nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim6");
298  bp = nu->bp;
299 
300  for (a = 0; a < 8; a++) {
301  bp->f1 = SELECT;
302  if (xzproj == 0) {
303  bp->vec[0] += nurbcircle[a][0] * grid;
304  bp->vec[1] += nurbcircle[a][1] * grid;
305  }
306  else {
307  bp->vec[0] += 0.25f * nurbcircle[a][0] * grid - 0.75f * grid;
308  bp->vec[2] += 0.25f * nurbcircle[a][1] * grid;
309  }
310  if (a & 1) {
311  bp->vec[3] = 0.5 * M_SQRT2;
312  }
313  else {
314  bp->vec[3] = 1.0;
315  }
316  mul_m4_v3(mat, bp->vec);
317  bp->radius = bp->weight = 1.0;
318 
319  bp++;
320  }
321 
323  }
324  break;
325  case CU_PRIM_PATCH: /* 4x4 patch */
326  if (cutype == CU_NURBS) { /* nurb */
327 
328  nu->pntsu = 4;
329  nu->pntsv = 4;
330  nu->orderu = 4;
331  nu->orderv = 4;
332  nu->flag = CU_SMOOTH;
333  nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * (4 * 4), "addNurbprim6");
334  nu->flagu = 0;
335  nu->flagv = 0;
336  bp = nu->bp;
337 
338  for (a = 0; a < 4; a++) {
339  for (b = 0; b < 4; b++) {
340  bp->f1 = SELECT;
341  fac = (float)a - 1.5f;
342  bp->vec[0] += fac * grid;
343  fac = (float)b - 1.5f;
344  bp->vec[1] += fac * grid;
345  if ((ELEM(a, 1, 2)) && (ELEM(b, 1, 2))) {
346  bp->vec[2] += grid;
347  }
348  mul_m4_v3(mat, bp->vec);
349  bp->vec[3] = 1.0;
350  bp++;
351  }
352  }
353 
356  }
357  break;
358  case CU_PRIM_TUBE: /* Cylinder */
359  if (cutype == CU_NURBS) {
360  nu = ED_curve_add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0);
361  nu->resolu = cu->resolu;
362  nu->flag = CU_SMOOTH;
363  BLI_addtail(editnurb, nu); /* temporal for extrude and translate */
364  vec[0] = vec[1] = 0.0;
365  vec[2] = -grid;
366 
367  mul_mat3_m4_v3(mat, vec);
368 
369  ed_editnurb_translate_flag(editnurb, SELECT, vec, CU_IS_2D(cu));
370  ed_editnurb_extrude_flag(cu->editnurb, SELECT);
371  mul_v3_fl(vec, -2.0f);
372  ed_editnurb_translate_flag(editnurb, SELECT, vec, CU_IS_2D(cu));
373 
374  BLI_remlink(editnurb, nu);
375 
376  a = nu->pntsu * nu->pntsv;
377  bp = nu->bp;
378  while (a-- > 0) {
379  bp->f1 |= SELECT;
380  bp++;
381  }
382  }
383  break;
384  case CU_PRIM_SPHERE: /* sphere */
385  if (cutype == CU_NURBS) {
386  const float tmp_cent[3] = {0.0f, 0.0f, 0.0f};
387  const float tmp_vec[3] = {0.0f, 0.0f, 1.0f};
388 
389  nu->pntsu = 5;
390  nu->pntsv = 1;
391  nu->orderu = 3;
392  nu->resolu = cu->resolu;
393  nu->resolv = cu->resolv;
394  nu->flag = CU_SMOOTH;
395  nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "addNurbprim6");
396  nu->flagu = 0;
397  bp = nu->bp;
398 
399  for (a = 0; a < 5; a++) {
400  bp->f1 = SELECT;
401  bp->vec[0] += nurbcircle[a][0] * grid;
402  bp->vec[2] += nurbcircle[a][1] * grid;
403  if (a & 1) {
404  bp->vec[3] = 0.5 * M_SQRT2;
405  }
406  else {
407  bp->vec[3] = 1.0;
408  }
409  mul_m4_v3(mat, bp->vec);
410  bp++;
411  }
412  nu->flagu = CU_NURB_BEZIER | CU_NURB_ENDPOINT;
414 
415  BLI_addtail(editnurb, nu); /* temporal for spin */
416 
417  if (newob && (U.flag & USER_ADD_VIEWALIGNED) == 0) {
418  ed_editnurb_spin(umat, NULL, obedit, tmp_vec, tmp_cent);
419  }
420  else if (U.flag & USER_ADD_VIEWALIGNED) {
421  ed_editnurb_spin(viewmat, NULL, obedit, zvec, mat[3]);
422  }
423  else {
424  ed_editnurb_spin(umat, NULL, obedit, tmp_vec, mat[3]);
425  }
426 
428 
429  a = nu->pntsu * nu->pntsv;
430  bp = nu->bp;
431  while (a-- > 0) {
432  bp->f1 |= SELECT;
433  bp++;
434  }
435  BLI_remlink(editnurb, nu);
436  }
437  break;
438  case CU_PRIM_DONUT: /* torus */
439  if (cutype == CU_NURBS) {
440  const float tmp_cent[3] = {0.0f, 0.0f, 0.0f};
441  const float tmp_vec[3] = {0.0f, 0.0f, 1.0f};
442 
443  xzproj = 1;
444  nu = ED_curve_add_nurbs_primitive(C, obedit, mat, CU_NURBS | CU_PRIM_CIRCLE, 0);
445  xzproj = 0;
446  nu->resolu = cu->resolu;
447  nu->resolv = cu->resolv;
448  nu->flag = CU_SMOOTH;
449  BLI_addtail(editnurb, nu); /* temporal for spin */
450 
451  /* same as above */
452  if (newob && (U.flag & USER_ADD_VIEWALIGNED) == 0) {
453  ed_editnurb_spin(umat, NULL, obedit, tmp_vec, tmp_cent);
454  }
455  else if (U.flag & USER_ADD_VIEWALIGNED) {
456  ed_editnurb_spin(viewmat, NULL, obedit, zvec, mat[3]);
457  }
458  else {
459  ed_editnurb_spin(umat, NULL, obedit, tmp_vec, mat[3]);
460  }
461 
462  BLI_remlink(editnurb, nu);
463 
464  a = nu->pntsu * nu->pntsv;
465  bp = nu->bp;
466  while (a-- > 0) {
467  bp->f1 |= SELECT;
468  bp++;
469  }
470  }
471  break;
472 
473  default: /* should never happen */
474  BLI_assert_msg(0, "invalid nurbs type");
475  return NULL;
476  }
477 
478  BLI_assert(nu != NULL);
479 
480  if (nu) { /* should always be set */
481  nu->flag |= CU_SMOOTH;
482  cu->actnu = BLI_listbase_count(editnurb);
483  cu->actvert = CU_ACT_NONE;
484 
485  if (CU_IS_2D(cu)) {
487  }
488  }
489 
490  return nu;
491 }
492 
493 static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
494 {
495  struct Main *bmain = CTX_data_main(C);
497  ViewLayer *view_layer = CTX_data_view_layer(C);
498  Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
499  ListBase *editnurb;
500  Nurb *nu;
501  bool newob = false;
502  bool enter_editmode;
503  ushort local_view_bits;
504  float loc[3], rot[3];
505  float mat[4][4];
506 
508 
510  C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
511  return OPERATOR_CANCELLED;
512  }
513 
514  if (!isSurf) { /* adding curve */
515  if (obedit == NULL || obedit->type != OB_CURVES_LEGACY) {
516  const char *name = get_curve_defname(type);
517  Curve *cu;
518 
519  obedit = ED_object_add_type(C, OB_CURVES_LEGACY, name, loc, rot, true, local_view_bits);
520  newob = true;
521 
522  cu = (Curve *)obedit->data;
523 
524  if (type & CU_PRIM_PATH) {
525  cu->flag |= CU_PATH | CU_3D;
526  }
527  }
528  else {
530  }
531  }
532  else { /* adding surface */
533  if (obedit == NULL || obedit->type != OB_SURF) {
534  const char *name = get_surf_defname(type);
535  obedit = ED_object_add_type(C, OB_SURF, name, loc, rot, true, local_view_bits);
536  newob = true;
537  }
538  else {
540  }
541  }
542 
543  float radius = RNA_float_get(op->ptr, "radius");
544  float scale[3];
545  copy_v3_fl(scale, radius);
546  ED_object_new_primitive_matrix(C, obedit, loc, rot, scale, mat);
547 
548  nu = ED_curve_add_nurbs_primitive(C, obedit, mat, type, newob);
549  editnurb = object_editcurve_get(obedit);
550  BLI_addtail(editnurb, nu);
551 
552  /* userdef */
553  if (newob && !enter_editmode) {
555  }
556 
558 
559  return OPERATOR_FINISHED;
560 }
561 
562 static int curve_prim_add(bContext *C, wmOperator *op, int type)
563 {
564  return curvesurf_prim_add(C, op, type, 0);
565 }
566 
567 static int surf_prim_add(bContext *C, wmOperator *op, int type)
568 {
569  return curvesurf_prim_add(C, op, type, 1);
570 }
571 
572 /* ******************** Curves ******************* */
573 
575 {
576  return curve_prim_add(C, op, CU_BEZIER | CU_PRIM_CURVE);
577 }
578 
580 {
581  /* identifiers */
582  ot->name = "Add Bezier";
583  ot->description = "Construct a Bezier Curve";
584  ot->idname = "CURVE_OT_primitive_bezier_curve_add";
585 
586  /* api callbacks */
589 
590  /* flags */
592 
595 }
596 
598 {
599  return curve_prim_add(C, op, CU_BEZIER | CU_PRIM_CIRCLE);
600 }
601 
603 {
604  /* identifiers */
605  ot->name = "Add Bezier Circle";
606  ot->description = "Construct a Bezier Circle";
607  ot->idname = "CURVE_OT_primitive_bezier_circle_add";
608 
609  /* api callbacks */
612 
613  /* flags */
615 
618 }
619 
621 {
622  return curve_prim_add(C, op, CU_NURBS | CU_PRIM_CURVE);
623 }
624 
626 {
627  /* identifiers */
628  ot->name = "Add Nurbs Curve";
629  ot->description = "Construct a Nurbs Curve";
630  ot->idname = "CURVE_OT_primitive_nurbs_curve_add";
631 
632  /* api callbacks */
635 
636  /* flags */
638 
641 }
642 
644 {
645  return curve_prim_add(C, op, CU_NURBS | CU_PRIM_CIRCLE);
646 }
647 
649 {
650  /* identifiers */
651  ot->name = "Add Nurbs Circle";
652  ot->description = "Construct a Nurbs Circle";
653  ot->idname = "CURVE_OT_primitive_nurbs_circle_add";
654 
655  /* api callbacks */
658 
659  /* flags */
661 
664 }
665 
667 {
668  return curve_prim_add(C, op, CU_NURBS | CU_PRIM_PATH);
669 }
670 
672 {
673  /* identifiers */
674  ot->name = "Add Path";
675  ot->description = "Construct a Path";
676  ot->idname = "CURVE_OT_primitive_nurbs_path_add";
677 
678  /* api callbacks */
681 
682  /* flags */
684 
687 }
688 
689 /* **************** NURBS surfaces ********************** */
691 {
692  return surf_prim_add(C, op, CU_PRIM_CURVE | CU_NURBS);
693 }
694 
696 {
697  /* identifiers */
698  ot->name = "Add Surface Curve";
699  ot->description = "Construct a Nurbs surface Curve";
700  ot->idname = "SURFACE_OT_primitive_nurbs_surface_curve_add";
701 
702  /* api callbacks */
705 
706  /* flags */
708 
711 }
712 
714 {
715  return surf_prim_add(C, op, CU_PRIM_CIRCLE | CU_NURBS);
716 }
717 
719 {
720  /* identifiers */
721  ot->name = "Add Surface Circle";
722  ot->description = "Construct a Nurbs surface Circle";
723  ot->idname = "SURFACE_OT_primitive_nurbs_surface_circle_add";
724 
725  /* api callbacks */
728 
729  /* flags */
731 
734 }
735 
737 {
738  return surf_prim_add(C, op, CU_PRIM_PATCH | CU_NURBS);
739 }
740 
742 {
743  /* identifiers */
744  ot->name = "Add Surface Patch";
745  ot->description = "Construct a Nurbs surface Patch";
746  ot->idname = "SURFACE_OT_primitive_nurbs_surface_surface_add";
747 
748  /* api callbacks */
751 
752  /* flags */
754 
757 }
758 
760 {
761  return surf_prim_add(C, op, CU_PRIM_TUBE | CU_NURBS);
762 }
763 
765 {
766  /* identifiers */
767  ot->name = "Add Surface Cylinder";
768  ot->description = "Construct a Nurbs surface Cylinder";
769  ot->idname = "SURFACE_OT_primitive_nurbs_surface_cylinder_add";
770 
771  /* api callbacks */
774 
775  /* flags */
777 
780 }
781 
783 {
784  return surf_prim_add(C, op, CU_PRIM_SPHERE | CU_NURBS);
785 }
786 
788 {
789  /* identifiers */
790  ot->name = "Add Surface Sphere";
791  ot->description = "Construct a Nurbs surface Sphere";
792  ot->idname = "SURFACE_OT_primitive_nurbs_surface_sphere_add";
793 
794  /* api callbacks */
797 
798  /* flags */
800 
803 }
804 
806 {
807  return surf_prim_add(C, op, CU_PRIM_DONUT | CU_NURBS);
808 }
809 
811 {
812  /* identifiers */
813  ot->name = "Add Surface Torus";
814  ot->description = "Construct a Nurbs surface Torus";
815  ot->idname = "SURFACE_OT_primitive_nurbs_surface_torus_add";
816 
817  /* api callbacks */
820 
821  /* flags */
823 
826 }
typedef float(TangentPoint)[2]
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct ViewLayer * CTX_data_view_layer(const bContext *C)
Definition: context.c:1100
struct Main * CTX_data_main(const bContext *C)
Definition: context.c:1074
void BKE_nurb_handles_calc(struct Nurb *nu)
Definition: curve.cc:3995
void BKE_nurb_knot_calc_v(struct Nurb *nu)
Definition: curve.cc:1239
#define CU_IS_2D(cu)
Definition: BKE_curve.h:67
void BKE_nurb_project_2d(struct Nurb *nu)
Definition: curve.cc:736
void BKE_nurb_knot_calc_u(struct Nurb *nu)
Definition: curve.cc:1234
void BKE_nurbList_flag_set(ListBase *editnurb, uint8_t flag, bool set)
Definition: curve.cc:4354
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define BLI_assert_msg(a, msg)
Definition: BLI_assert.h:53
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
int BLI_listbase_count(const struct ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
#define M_SQRT2
Definition: BLI_math_base.h:29
void unit_m4(float m[4][4])
Definition: rct.c:1090
void mul_mat3_m4_v3(const float M[4][4], float r[3])
Definition: math_matrix.c:790
void mul_m4_v3(const float M[4][4], float r[3])
Definition: math_matrix.c:729
void copy_m4_m4(float m1[4][4], const float m2[4][4])
Definition: math_matrix.c:77
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE void copy_v3_fl(float r[3], float f)
unsigned short ushort
Definition: BLI_sys_types.h:68
#define ELEM(...)
#define BLT_I18NCONTEXT_ID_CURVE_LEGACY
#define CTX_DATA_(context, msgid)
void DEG_id_tag_update(struct ID *id, int flag)
@ ID_RECALC_GEOMETRY
Definition: DNA_ID.h:791
@ CU_PRIM_SPHERE
@ CU_PRIM_CURVE
@ CU_BEZIER
@ CU_PRIMITIVE
@ CU_TYPE
@ CU_PRIM_DONUT
@ CU_PRIM_TUBE
@ CU_PRIM_CIRCLE
@ CU_NURBS
@ CU_PRIM_PATCH
@ CU_PRIM_PATH
@ CU_SMOOTH
#define CU_ACT_NONE
@ CU_NURB_CYCLIC
@ CU_NURB_ENDPOINT
@ CU_NURB_BEZIER
@ HD_AUTO
@ HD_ALIGN
@ CU_3D
@ CU_PATH
Object is a sort of wrapper for general info.
@ OB_SURF
@ OB_CURVES_LEGACY
#define OBEDIT_FROM_VIEW_LAYER(view_layer)
@ USER_ADD_VIEWALIGNED
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
@ EM_FREEDATA
Definition: ED_object.h:242
struct Object * ED_object_add_type(struct bContext *C, int type, const char *name, const float loc[3], const float rot[3], bool enter_editmode, unsigned short local_view_bits) ATTR_NONNULL(1) ATTR_RETURNS_NONNULL
Definition: object_add.cc:668
bool ED_object_editmode_exit_ex(struct Main *bmain, struct Scene *scene, struct Object *obedit, int flag)
Definition: object_edit.c:653
float ED_object_new_primitive_matrix(struct bContext *C, struct Object *obedit, const float loc[3], const float rot[3], const float scale[3], float primmat[4][4])
Definition: object_add.cc:328
bool ED_object_add_generic_get_opts(struct bContext *C, struct wmOperator *op, char view_align_axis, float r_loc[3], float r_rot[3], float r_scale[3], bool *r_enter_editmode, unsigned short *r_local_view_bits, bool *r_is_view_aligned)
Definition: object_add.cc:457
void ED_object_add_generic_props(struct wmOperatorType *ot, bool do_editmode)
Definition: object_add.cc:399
void ED_object_add_unit_props_radius(struct wmOperatorType *ot)
Definition: object_add.cc:394
bool ED_operator_scene_editable(struct bContext *C)
Definition: screen_ops.c:177
struct RegionView3D * ED_view3d_context_rv3d(struct bContext *C)
Definition: space_view3d.c:82
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
Read Guarded memory(de)allocation.
#define C
Definition: RandGen.cpp:25
@ OPTYPE_UNDO
Definition: WM_types.h:148
@ OPTYPE_REGISTER
Definition: WM_types.h:146
#define ND_DRAW
Definition: WM_types.h:410
#define NC_OBJECT
Definition: WM_types.h:329
unsigned int U
Definition: btGjkEpa3.h:78
#define SELECT
bool ed_editnurb_extrude_flag(struct EditNurb *editnurb, uint8_t flag)
Definition: editcurve.c:1979
bool ed_editnurb_spin(float viewmat[4][4], struct View3D *v3d, struct Object *obedit, const float axis[3], const float cent[3])
Definition: editcurve.c:4947
void ed_editnurb_translate_flag(struct ListBase *editnurb, uint8_t flag, const float vec[3], bool is_2d)
Definition: editcurve.c:1686
Scene scene
ListBase * object_editcurve_get(Object *ob)
Definition: editcurve.c:74
static int add_primitive_nurbs_surface_sphere_exec(bContext *C, wmOperator *op)
void CURVE_OT_primitive_nurbs_path_add(wmOperatorType *ot)
void SURFACE_OT_primitive_nurbs_surface_sphere_add(wmOperatorType *ot)
static int add_primitive_bezier_exec(bContext *C, wmOperator *op)
static int add_primitive_bezier_circle_exec(bContext *C, wmOperator *op)
static int curvesurf_prim_add(bContext *C, wmOperator *op, int type, int isSurf)
void CURVE_OT_primitive_bezier_curve_add(wmOperatorType *ot)
static int add_primitive_nurbs_circle_exec(bContext *C, wmOperator *op)
static int add_primitive_nurbs_curve_exec(bContext *C, wmOperator *op)
static int add_primitive_nurbs_surface_cylinder_exec(bContext *C, wmOperator *op)
void CURVE_OT_primitive_bezier_circle_add(wmOperatorType *ot)
void SURFACE_OT_primitive_nurbs_surface_torus_add(wmOperatorType *ot)
static int add_primitive_curve_path_exec(bContext *C, wmOperator *op)
void CURVE_OT_primitive_nurbs_circle_add(wmOperatorType *ot)
static int add_primitive_nurbs_surface_curve_exec(bContext *C, wmOperator *op)
void SURFACE_OT_primitive_nurbs_surface_surface_add(wmOperatorType *ot)
static const char * get_curve_defname(int type)
Definition: editcurve_add.c:49
void CURVE_OT_primitive_nurbs_curve_add(wmOperatorType *ot)
static int curve_prim_add(bContext *C, wmOperator *op, int type)
static const char * get_surf_defname(int type)
Definition: editcurve_add.c:79
void SURFACE_OT_primitive_nurbs_surface_cylinder_add(wmOperatorType *ot)
static int surf_prim_add(bContext *C, wmOperator *op, int type)
static int add_primitive_nurbs_surface_torus_exec(bContext *C, wmOperator *op)
static int add_primitive_nurbs_surface_surface_exec(bContext *C, wmOperator *op)
Nurb * ED_curve_add_nurbs_primitive(bContext *C, Object *obedit, float mat[4][4], int type, int newob)
void SURFACE_OT_primitive_nurbs_surface_curve_add(wmOperatorType *ot)
static const float nurbcircle[8][2]
Definition: editcurve_add.c:36
static int add_primitive_nurbs_surface_circle_exec(bContext *C, wmOperator *op)
void SURFACE_OT_primitive_nurbs_surface_circle_add(wmOperatorType *ot)
#define rot(x, k)
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
static unsigned a[3]
Definition: RandGen.cpp:78
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
float RNA_float_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4957
Definition: BKE_main.h:121
void * data
const char * name
Definition: WM_types.h:888
const char * idname
Definition: WM_types.h:890
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:943
const char * description
Definition: WM_types.h:893
int(* exec)(struct bContext *, struct wmOperator *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:903
struct PointerRNA * ptr
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmOperatorType * ot
Definition: wm_files.c:3479
void WM_operator_view3d_unit_defaults(struct bContext *C, struct wmOperator *op)
Definition: wm_operators.c:977