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