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