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