Cleanup: Rename 'make local' functions to new scheme.
[blender-staging.git] / source / blender / blenkernel / intern / mball.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  * MetaBalls are created from a single Object (with a name without number in it),
19  * here the DispList and BoundBox also is located.
20  * All objects with the same name (but with a number in it) are added to this.
21  *
22  * texture coordinates are patched within the displist
23  */
24
25 /** \file
26  * \ingroup bke
27  */
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <math.h>
32 #include <stdlib.h>
33 #include <ctype.h>
34 #include <float.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "DNA_material_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_meta_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_defaults.h"
43
44 #include "BLI_blenlib.h"
45 #include "BLI_math.h"
46 #include "BLI_string_utils.h"
47 #include "BLI_utildefines.h"
48
49 #include "BKE_main.h"
50
51 #include "BKE_animsys.h"
52 #include "BKE_curve.h"
53 #include "BKE_scene.h"
54 #include "BKE_lib_id.h"
55 #include "BKE_displist.h"
56 #include "BKE_mball.h"
57 #include "BKE_object.h"
58 #include "BKE_material.h"
59
60 #include "DEG_depsgraph.h"
61
62 /* Functions */
63
64 /** Free (or release) any data used by this mball (does not free the mball itself). */
65 void BKE_mball_free(MetaBall *mb)
66 {
67   BKE_animdata_free((ID *)mb, false);
68
69   BKE_mball_batch_cache_free(mb);
70
71   MEM_SAFE_FREE(mb->mat);
72
73   BLI_freelistN(&mb->elems);
74   if (mb->disp.first) {
75     BKE_displist_free(&mb->disp);
76   }
77 }
78
79 void BKE_mball_init(MetaBall *mb)
80 {
81   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(mb, id));
82
83   MEMCPY_STRUCT_AFTER(mb, DNA_struct_default_get(MetaBall), id);
84 }
85
86 MetaBall *BKE_mball_add(Main *bmain, const char *name)
87 {
88   MetaBall *mb;
89
90   mb = BKE_libblock_alloc(bmain, ID_MB, name, 0);
91
92   BKE_mball_init(mb);
93
94   return mb;
95 }
96
97 /**
98  * Only copy internal data of MetaBall ID from source
99  * to already allocated/initialized destination.
100  * You probably never want to use that directly,
101  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
102  *
103  * WARNING! This function will not handle ID user count!
104  *
105  * \param flag: Copying options (see BKE_lib_id.h's LIB_ID_COPY_... flags for more).
106  */
107 void BKE_mball_copy_data(Main *UNUSED(bmain),
108                          MetaBall *mb_dst,
109                          const MetaBall *mb_src,
110                          const int UNUSED(flag))
111 {
112   BLI_duplicatelist(&mb_dst->elems, &mb_src->elems);
113
114   mb_dst->mat = MEM_dupallocN(mb_src->mat);
115
116   mb_dst->editelems = NULL;
117   mb_dst->lastelem = NULL;
118   mb_dst->batch_cache = NULL;
119 }
120
121 MetaBall *BKE_mball_copy(Main *bmain, const MetaBall *mb)
122 {
123   MetaBall *mb_copy;
124   BKE_id_copy(bmain, &mb->id, (ID **)&mb_copy);
125   return mb_copy;
126 }
127
128 void BKE_mball_make_local(Main *bmain, MetaBall *mb, const bool lib_local)
129 {
130   BKE_lib_id_make_local_generic(bmain, &mb->id, true, lib_local);
131 }
132
133 /* most simple meta-element adding function
134  * don't do context manipulation here (rna uses) */
135 MetaElem *BKE_mball_element_add(MetaBall *mb, const int type)
136 {
137   MetaElem *ml = MEM_callocN(sizeof(MetaElem), "metaelem");
138
139   unit_qt(ml->quat);
140
141   ml->rad = 2.0;
142   ml->s = 2.0;
143   ml->flag = MB_SCALE_RAD;
144
145   switch (type) {
146     case MB_BALL:
147       ml->type = MB_BALL;
148       ml->expx = ml->expy = ml->expz = 1.0;
149
150       break;
151     case MB_TUBE:
152       ml->type = MB_TUBE;
153       ml->expx = ml->expy = ml->expz = 1.0;
154
155       break;
156     case MB_PLANE:
157       ml->type = MB_PLANE;
158       ml->expx = ml->expy = ml->expz = 1.0;
159
160       break;
161     case MB_ELIPSOID:
162       ml->type = MB_ELIPSOID;
163       ml->expx = 1.2f;
164       ml->expy = 0.8f;
165       ml->expz = 1.0;
166
167       break;
168     case MB_CUBE:
169       ml->type = MB_CUBE;
170       ml->expx = ml->expy = ml->expz = 1.0;
171
172       break;
173     default:
174       break;
175   }
176
177   BLI_addtail(&mb->elems, ml);
178
179   return ml;
180 }
181 /**
182  * Compute bounding box of all MetaElems/MetaBalls.
183  *
184  * Bounding box is computed from polygonized surface. Object *ob is
185  * basic MetaBall (usually with name Meta). All other MetaBalls (with
186  * names Meta.001, Meta.002, etc) are included in this Bounding Box.
187  */
188 void BKE_mball_texspace_calc(Object *ob)
189 {
190   DispList *dl;
191   BoundBox *bb;
192   float *data, min[3], max[3] /*, loc[3], size[3] */;
193   int tot;
194   bool do_it = false;
195
196   if (ob->runtime.bb == NULL) {
197     ob->runtime.bb = MEM_callocN(sizeof(BoundBox), "mb boundbox");
198   }
199   bb = ob->runtime.bb;
200
201   /* Weird one, this. */
202   /*      INIT_MINMAX(min, max); */
203   (min)[0] = (min)[1] = (min)[2] = 1.0e30f;
204   (max)[0] = (max)[1] = (max)[2] = -1.0e30f;
205
206   dl = ob->runtime.curve_cache->disp.first;
207   while (dl) {
208     tot = dl->nr;
209     if (tot) {
210       do_it = true;
211     }
212     data = dl->verts;
213     while (tot--) {
214       /* Also weird... but longer. From utildefines. */
215       minmax_v3v3_v3(min, max, data);
216       data += 3;
217     }
218     dl = dl->next;
219   }
220
221   if (!do_it) {
222     min[0] = min[1] = min[2] = -1.0f;
223     max[0] = max[1] = max[2] = 1.0f;
224   }
225
226   BKE_boundbox_init_from_minmax(bb, min, max);
227
228   bb->flag &= ~BOUNDBOX_DIRTY;
229 }
230
231 /** Return or compute bbox for given metaball object. */
232 BoundBox *BKE_mball_boundbox_get(Object *ob)
233 {
234   BLI_assert(ob->type == OB_MBALL);
235
236   if (ob->runtime.bb != NULL && (ob->runtime.bb->flag & BOUNDBOX_DIRTY) == 0) {
237     return ob->runtime.bb;
238   }
239
240   /* This should always only be called with evaluated objects,
241    * but currently RNA is a problem here... */
242   if (ob->runtime.curve_cache != NULL) {
243     BKE_mball_texspace_calc(ob);
244   }
245
246   return ob->runtime.bb;
247 }
248
249 float *BKE_mball_make_orco(Object *ob, ListBase *dispbase)
250 {
251   BoundBox *bb;
252   DispList *dl;
253   float *data, *orco, *orcodata;
254   float loc[3], size[3];
255   int a;
256
257   /* restore size and loc */
258   bb = ob->runtime.bb;
259   loc[0] = (bb->vec[0][0] + bb->vec[4][0]) / 2.0f;
260   size[0] = bb->vec[4][0] - loc[0];
261   loc[1] = (bb->vec[0][1] + bb->vec[2][1]) / 2.0f;
262   size[1] = bb->vec[2][1] - loc[1];
263   loc[2] = (bb->vec[0][2] + bb->vec[1][2]) / 2.0f;
264   size[2] = bb->vec[1][2] - loc[2];
265
266   dl = dispbase->first;
267   orcodata = MEM_mallocN(sizeof(float) * 3 * dl->nr, "MballOrco");
268
269   data = dl->verts;
270   orco = orcodata;
271   a = dl->nr;
272   while (a--) {
273     orco[0] = (data[0] - loc[0]) / size[0];
274     orco[1] = (data[1] - loc[1]) / size[1];
275     orco[2] = (data[2] - loc[2]) / size[2];
276
277     data += 3;
278     orco += 3;
279   }
280
281   return orcodata;
282 }
283
284 /* Note on mball basis stuff 2.5x (this is a can of worms)
285  * This really needs a rewrite/refactor its totally broken in anything other then basic cases
286  * Multiple Scenes + Set Scenes & mixing mball basis SHOULD work but fails to update the depsgraph
287  * on rename and linking into scenes or removal of basis mball.
288  * So take care when changing this code.
289  *
290  * Main idiot thing here is that the system returns find_basis_mball()
291  * objects which fail a is_basis_mball() test.
292  *
293  * Not only that but the depsgraph and their areas depend on this behavior!,
294  * so making small fixes here isn't worth it.
295  * - Campbell
296  */
297
298 /** \brief Test, if Object *ob is basic MetaBall.
299  *
300  * It test last character of Object ID name. If last character
301  * is digit it return 0, else it return 1.
302  */
303 bool BKE_mball_is_basis(Object *ob)
304 {
305   /* just a quick test */
306   const int len = strlen(ob->id.name);
307   return (!isdigit(ob->id.name[len - 1]));
308 }
309
310 /* return nonzero if ob1 is a basis mball for ob */
311 bool BKE_mball_is_basis_for(Object *ob1, Object *ob2)
312 {
313   int basis1nr, basis2nr;
314   char basis1name[MAX_ID_NAME], basis2name[MAX_ID_NAME];
315
316   if (ob1->id.name[2] != ob2->id.name[2]) {
317     /* Quick return in case first char of both ID's names is not the same... */
318     return false;
319   }
320
321   BLI_split_name_num(basis1name, &basis1nr, ob1->id.name + 2, '.');
322   BLI_split_name_num(basis2name, &basis2nr, ob2->id.name + 2, '.');
323
324   if (STREQ(basis1name, basis2name)) {
325     return BKE_mball_is_basis(ob1);
326   }
327   else {
328     return false;
329   }
330 }
331
332 bool BKE_mball_is_any_selected(const MetaBall *mb)
333 {
334   for (const MetaElem *ml = mb->editelems->first; ml != NULL; ml = ml->next) {
335     if (ml->flag & SELECT) {
336       return true;
337     }
338   }
339   return false;
340 }
341
342 bool BKE_mball_is_any_selected_multi(Base **bases, int bases_len)
343 {
344   for (uint base_index = 0; base_index < bases_len; base_index++) {
345     Object *obedit = bases[base_index]->object;
346     MetaBall *mb = (MetaBall *)obedit->data;
347     if (BKE_mball_is_any_selected(mb)) {
348       return true;
349     }
350   }
351   return false;
352 }
353
354 bool BKE_mball_is_any_unselected(const MetaBall *mb)
355 {
356   for (const MetaElem *ml = mb->editelems->first; ml != NULL; ml = ml->next) {
357     if ((ml->flag & SELECT) == 0) {
358       return true;
359     }
360   }
361   return false;
362 }
363
364 /**
365  * \brief copy some properties from object to other metaball object with same base name
366  *
367  * When some properties (wiresize, threshold, update flags) of metaball are changed, then this
368  * properties are copied to all metaballs in same "group" (metaballs with same base name: MBall,
369  * MBall.001, MBall.002, etc). The most important is to copy properties to the base metaball,
370  * because this metaball influence polygonization of metaballs. */
371 void BKE_mball_properties_copy(Scene *scene, Object *active_object)
372 {
373   Scene *sce_iter = scene;
374   Base *base;
375   Object *ob;
376   MetaBall *active_mball = (MetaBall *)active_object->data;
377   int basisnr, obnr;
378   char basisname[MAX_ID_NAME], obname[MAX_ID_NAME];
379   SceneBaseIter iter;
380
381   BLI_split_name_num(basisname, &basisnr, active_object->id.name + 2, '.');
382
383   /* Pass depsgraph as NULL, which means we will not expand into
384    * duplis unlike when we generate the mball. Expanding duplis
385    * would not be compatible when editing multiple view layers. */
386   BKE_scene_base_iter_next(NULL, &iter, &sce_iter, 0, NULL, NULL);
387   while (BKE_scene_base_iter_next(NULL, &iter, &sce_iter, 1, &base, &ob)) {
388     if (ob->type == OB_MBALL) {
389       if (ob != active_object) {
390         BLI_split_name_num(obname, &obnr, ob->id.name + 2, '.');
391
392         /* Object ob has to be in same "group" ... it means, that it has to have
393          * same base of its name */
394         if (STREQ(obname, basisname)) {
395           MetaBall *mb = ob->data;
396
397           /* Copy properties from selected/edited metaball */
398           mb->wiresize = active_mball->wiresize;
399           mb->rendersize = active_mball->rendersize;
400           mb->thresh = active_mball->thresh;
401           mb->flag = active_mball->flag;
402           DEG_id_tag_update(&mb->id, 0);
403         }
404       }
405     }
406   }
407 }
408
409 /** \brief This function finds basic MetaBall.
410  *
411  * Basic MetaBall doesn't include any number at the end of
412  * its name. All MetaBalls with same base of name can be
413  * blended. MetaBalls with different basic name can't be
414  * blended.
415  *
416  * warning!, is_basis_mball() can fail on returned object, see long note above.
417  */
418 Object *BKE_mball_basis_find(Scene *scene, Object *basis)
419 {
420   Object *bob = basis;
421   int basisnr, obnr;
422   char basisname[MAX_ID_NAME], obname[MAX_ID_NAME];
423
424   BLI_split_name_num(basisname, &basisnr, basis->id.name + 2, '.');
425
426   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
427        view_layer = view_layer->next) {
428     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
429       Object *ob = base->object;
430       if ((ob->type == OB_MBALL) && !(base->flag & BASE_FROM_DUPLI)) {
431         if (ob != bob) {
432           BLI_split_name_num(obname, &obnr, ob->id.name + 2, '.');
433
434           /* Object ob has to be in same "group" ... it means,
435            * that it has to have same base of its name. */
436           if (STREQ(obname, basisname)) {
437             if (obnr < basisnr) {
438               basis = ob;
439               basisnr = obnr;
440             }
441           }
442         }
443       }
444     }
445   }
446
447   return basis;
448 }
449
450 bool BKE_mball_minmax_ex(
451     const MetaBall *mb, float min[3], float max[3], const float obmat[4][4], const short flag)
452 {
453   const float scale = obmat ? mat4_to_scale(obmat) : 1.0f;
454   bool changed = false;
455   float centroid[3], vec[3];
456
457   INIT_MINMAX(min, max);
458
459   for (const MetaElem *ml = mb->elems.first; ml; ml = ml->next) {
460     if ((ml->flag & flag) == flag) {
461       const float scale_mb = (ml->rad * 0.5f) * scale;
462       int i;
463
464       if (obmat) {
465         mul_v3_m4v3(centroid, obmat, &ml->x);
466       }
467       else {
468         copy_v3_v3(centroid, &ml->x);
469       }
470
471       /* TODO, non circle shapes cubes etc, probably nobody notices - campbell */
472       for (i = -1; i != 3; i += 2) {
473         copy_v3_v3(vec, centroid);
474         add_v3_fl(vec, scale_mb * i);
475         minmax_v3v3_v3(min, max, vec);
476       }
477       changed = true;
478     }
479   }
480
481   return changed;
482 }
483
484 /* basic vertex data functions */
485 bool BKE_mball_minmax(const MetaBall *mb, float min[3], float max[3])
486 {
487   INIT_MINMAX(min, max);
488
489   for (const MetaElem *ml = mb->elems.first; ml; ml = ml->next) {
490     minmax_v3v3_v3(min, max, &ml->x);
491   }
492
493   return (BLI_listbase_is_empty(&mb->elems) == false);
494 }
495
496 bool BKE_mball_center_median(const MetaBall *mb, float r_cent[3])
497 {
498   int total = 0;
499
500   zero_v3(r_cent);
501
502   for (const MetaElem *ml = mb->elems.first; ml; ml = ml->next) {
503     add_v3_v3(r_cent, &ml->x);
504     total++;
505   }
506
507   if (total) {
508     mul_v3_fl(r_cent, 1.0f / (float)total);
509   }
510
511   return (total != 0);
512 }
513
514 bool BKE_mball_center_bounds(const MetaBall *mb, float r_cent[3])
515 {
516   float min[3], max[3];
517
518   if (BKE_mball_minmax(mb, min, max)) {
519     mid_v3_v3v3(r_cent, min, max);
520     return true;
521   }
522
523   return false;
524 }
525
526 void BKE_mball_transform(MetaBall *mb, const float mat[4][4], const bool do_props)
527 {
528   float quat[4];
529   const float scale = mat4_to_scale(mat);
530   const float scale_sqrt = sqrtf(scale);
531
532   mat4_to_quat(quat, mat);
533
534   for (MetaElem *ml = mb->elems.first; ml; ml = ml->next) {
535     mul_m4_v3(mat, &ml->x);
536     mul_qt_qtqt(ml->quat, quat, ml->quat);
537
538     if (do_props) {
539       ml->rad *= scale;
540       /* hrmf, probably elems shouldn't be
541        * treating scale differently - campbell */
542       if (!MB_TYPE_SIZE_SQUARED(ml->type)) {
543         mul_v3_fl(&ml->expx, scale);
544       }
545       else {
546         mul_v3_fl(&ml->expx, scale_sqrt);
547       }
548     }
549   }
550 }
551
552 void BKE_mball_translate(MetaBall *mb, const float offset[3])
553 {
554   for (MetaElem *ml = mb->elems.first; ml; ml = ml->next) {
555     add_v3_v3(&ml->x, offset);
556   }
557 }
558
559 /* *** select funcs *** */
560 int BKE_mball_select_count(const MetaBall *mb)
561 {
562   int sel = 0;
563   for (const MetaElem *ml = mb->editelems->first; ml; ml = ml->next) {
564     if (ml->flag & SELECT) {
565       sel++;
566     }
567   }
568   return sel;
569 }
570
571 int BKE_mball_select_count_multi(Base **bases, int bases_len)
572 {
573   int sel = 0;
574   for (uint ob_index = 0; ob_index < bases_len; ob_index++) {
575     const Object *obedit = bases[ob_index]->object;
576     const MetaBall *mb = (MetaBall *)obedit->data;
577     sel += BKE_mball_select_count(mb);
578   }
579   return sel;
580 }
581
582 bool BKE_mball_select_all(MetaBall *mb)
583 {
584   bool changed = false;
585   for (MetaElem *ml = mb->editelems->first; ml; ml = ml->next) {
586     if ((ml->flag & SELECT) == 0) {
587       ml->flag |= SELECT;
588       changed = true;
589     }
590   }
591   return changed;
592 }
593
594 bool BKE_mball_select_all_multi_ex(Base **bases, int bases_len)
595 {
596   bool changed_multi = false;
597   for (uint ob_index = 0; ob_index < bases_len; ob_index++) {
598     Object *obedit = bases[ob_index]->object;
599     MetaBall *mb = obedit->data;
600     changed_multi |= BKE_mball_select_all(mb);
601   }
602   return changed_multi;
603 }
604
605 bool BKE_mball_deselect_all(MetaBall *mb)
606 {
607   bool changed = false;
608   for (MetaElem *ml = mb->editelems->first; ml; ml = ml->next) {
609     if ((ml->flag & SELECT) != 0) {
610       ml->flag &= ~SELECT;
611       changed = true;
612     }
613   }
614   return changed;
615 }
616
617 bool BKE_mball_deselect_all_multi_ex(Base **bases, int bases_len)
618 {
619   bool changed_multi = false;
620   for (uint ob_index = 0; ob_index < bases_len; ob_index++) {
621     Object *obedit = bases[ob_index]->object;
622     MetaBall *mb = obedit->data;
623     changed_multi |= BKE_mball_deselect_all(mb);
624     DEG_id_tag_update(&mb->id, ID_RECALC_SELECT);
625   }
626   return changed_multi;
627 }
628
629 bool BKE_mball_select_swap(MetaBall *mb)
630 {
631   bool changed = false;
632   for (MetaElem *ml = mb->editelems->first; ml; ml = ml->next) {
633     ml->flag ^= SELECT;
634     changed = true;
635   }
636   return changed;
637 }
638
639 bool BKE_mball_select_swap_multi_ex(Base **bases, int bases_len)
640 {
641   bool changed_multi = false;
642   for (uint ob_index = 0; ob_index < bases_len; ob_index++) {
643     Object *obedit = bases[ob_index]->object;
644     MetaBall *mb = (MetaBall *)obedit->data;
645     changed_multi |= BKE_mball_select_swap(mb);
646   }
647   return changed_multi;
648 }
649
650 /* **** Depsgraph evaluation **** */
651
652 /* Draw Engine */
653
654 void (*BKE_mball_batch_cache_dirty_tag_cb)(MetaBall *mb, int mode) = NULL;
655 void (*BKE_mball_batch_cache_free_cb)(MetaBall *mb) = NULL;
656
657 void BKE_mball_batch_cache_dirty_tag(MetaBall *mb, int mode)
658 {
659   if (mb->batch_cache) {
660     BKE_mball_batch_cache_dirty_tag_cb(mb, mode);
661   }
662 }
663 void BKE_mball_batch_cache_free(MetaBall *mb)
664 {
665   if (mb->batch_cache) {
666     BKE_mball_batch_cache_free_cb(mb);
667   }
668 }