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