Blender V5.3
mball.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
11
12#include <cctype>
13#include <cfloat>
14#include <cmath>
15#include <cstdlib>
16#include <cstring>
17#include <numbers>
18#include <optional>
19
20#include "DNA_ID.h"
21#include "MEM_guardedalloc.h"
22
23/* Allow using deprecated functionality for .blend file I/O. */
24#define DNA_DEPRECATED_ALLOW
25
26#include "DNA_material_types.h"
27#include "DNA_mesh_types.h"
28#include "DNA_meta_types.h"
29#include "DNA_object_types.h"
30#include "DNA_scene_types.h"
31
32#include "BLI_listbase.hh"
33#include "BLI_math_matrix_c.hh"
35#include "BLI_math_vector_c.hh"
36#include "BLI_string_utils.hh"
37#include "BLI_utildefines.hh"
38
39#include "BLT_translation.hh"
40
41#include "BKE_main.hh"
42
43#include "BKE_geometry_set.hh"
44#include "BKE_idtype.hh"
45#include "BKE_lattice.hh"
46#include "BKE_layer.hh"
47#include "BKE_lib_id.hh"
48#include "BKE_lib_query.hh"
49#include "BKE_library.hh"
50#include "BKE_mball.hh"
52#include "BKE_object.hh"
53#include "BKE_object_types.hh"
54
55#include "DEG_depsgraph.hh"
57
58#include "BLO_read_write.hh"
59
60namespace blender {
61
62static void metaball_init_data(ID *id)
63{
64 MetaBall *metaball = id_cast<MetaBall *>(id);
65 INIT_DEFAULT_STRUCT_AFTER(metaball, id);
66}
67
68static void metaball_copy_data(Main * /*bmain*/,
69 std::optional<Library *> /*owner_library*/,
70 ID *id_dst,
71 const ID *id_src,
72 const int /*flag*/)
73{
74 MetaBall *metaball_dst = id_cast<MetaBall *>(id_dst);
75 const MetaBall *metaball_src = id_cast<const MetaBall *>(id_src);
76
77 BLI_duplicatelist(&metaball_dst->elems, &metaball_src->elems);
78
79 metaball_dst->mat = MEM_dupalloc(metaball_src->mat);
80
81 metaball_dst->editelems = nullptr;
82 metaball_dst->lastelem = nullptr;
83}
84
85static void metaball_free_data(ID *id)
86{
87 MetaBall *metaball = id_cast<MetaBall *>(id);
88
89 MEM_SAFE_DELETE(metaball->mat);
90
91 metaball->elems.free_no_destruct();
92}
93
95{
96 MetaBall *metaball = reinterpret_cast<MetaBall *>(id);
97 for (int i = 0; i < metaball->totcol; i++) {
99 }
100}
101
102static void metaball_blend_write(BlendWriter *writer, ID *id, const void *id_address)
103{
104 MetaBall *mb = id_cast<MetaBall *>(id);
105
106 /* Clean up, important in undo case to reduce false detection of changed datablocks. */
107 mb->editelems = nullptr;
108 /* Must always be cleared (meta's don't have their own edit-data). */
109 mb->needs_flush_to_id = 0;
110 mb->lastelem = nullptr;
111
112 /* write LibData */
113 writer->write_id_struct(id_address, mb);
114 BKE_id_blend_write(writer, &mb->id);
115
116 /* direct data */
117 writer->write_pointer_array(mb->totcol, mb->mat);
118
119 for (MetaElem &ml : mb->elems) {
120 writer->write_struct(&ml);
121 }
122}
123
125{
126 MetaBall *mb = id_cast<MetaBall *>(id);
127
129
130 BLO_read_struct_list(reader, MetaElem, &(mb->elems));
131
132 mb->editelems = nullptr;
133 /* Must always be cleared (meta's don't have their own edit-data). */
134 mb->needs_flush_to_id = 0;
135 // mb->edit_elems.first = mb->edit_elems.last = nullptr;
136 mb->lastelem = nullptr;
137}
138
140 .id_code = MetaBall::id_type,
141 .id_filter = FILTER_ID_MB,
142 .dependencies_id_types = FILTER_ID_MA,
143 .main_listbase_index = INDEX_ID_MB,
144 .struct_size = sizeof(MetaBall),
145 .name = "Metaball",
146 .name_plural = N_("metaballs"),
147 .translation_context = BLT_I18NCONTEXT_ID_METABALL,
149 .asset_type_info = nullptr,
150
151 .init_data = metaball_init_data,
152 .copy_data = metaball_copy_data,
153 .free_data = metaball_free_data,
154 .make_local = nullptr,
155 .foreach_id = metaball_foreach_id,
156 .foreach_cache = nullptr,
157 .foreach_path = nullptr,
158 .foreach_working_space_color = nullptr,
159 .foreach_asset_weak_reference = nullptr,
160 .owner_pointer_get = nullptr,
161
162 .blend_write = metaball_blend_write,
163 .blend_read_data = metaball_blend_read_data,
164 .blend_read_after_liblink = nullptr,
165
166 .blend_read_undo_preserve = nullptr,
167
168 .lib_override_apply_post = nullptr,
169};
170
171/* Functions */
172
173MetaBall *BKE_mball_add(Main *bmain, const char *name)
174{
175 MetaBall *mb = BKE_id_new<MetaBall>(bmain, name);
176 return mb;
177}
178
180{
181 MetaElem *ml = MEM_new<MetaElem>(__func__);
182
183 unit_qt(ml->quat);
184
185 ml->rad = 2.0;
186 ml->s = 2.0;
187 ml->flag = MB_SCALE_RAD;
188
189 switch (type) {
190 case MB_BALL:
191 ml->type = MB_BALL;
192 ml->expx = ml->expy = ml->expz = 1.0;
193
194 break;
195 case MB_TUBE:
196 ml->type = MB_TUBE;
197 ml->expx = ml->expy = ml->expz = 1.0;
198
199 break;
200 case MB_PLANE:
201 ml->type = MB_PLANE;
202 ml->expx = ml->expy = ml->expz = 1.0;
203
204 break;
205 case MB_ELLIPSOID:
206 ml->type = MB_ELLIPSOID;
207 ml->expx = 1.2f;
208 ml->expy = 0.8f;
209 ml->expz = 1.0;
210
211 break;
212 case MB_CUBE:
213 ml->type = MB_CUBE;
214 ml->expx = ml->expy = ml->expz = 1.0;
215
216 break;
217 default:
218 break;
219 }
220
221 BLI_addtail(&mb->elems, ml);
222
223 return ml;
224}
225
227{
228 float2 radius_stiffness = {
229 /* Display radius. */
230 ml->rad,
231 /* Display stiffness. */
232 ml->rad * atanf(ml->s) * float(2.0 / std::numbers::pi),
233 };
234
235 if (ml->type == MB_CUBE) {
236 /* Without this additional size, the cube can't be selected in solid mode.
237 * Use the minimum size so this doesn't become too large because of one large axis.
238 * See: #136396. */
239 const float offset = std::min({ml->expx, ml->expy, ml->expz}) * M_SQRT2;
240 radius_stiffness[0] += offset;
241 radius_stiffness[1] += offset;
242 }
243 return radius_stiffness;
244}
246{
247 float radius = ml->rad;
248 if (ml->type == MB_CUBE) {
249 const float offset = std::min({ml->expx, ml->expy, ml->expz}) * M_SQRT2;
250 radius += offset;
251 }
252 return radius;
253}
254
256{
257 /* Meta-Ball Basis Notes from Blender-2.5x
258 * =======================================
259 *
260 * NOTE(@ideasman42): This is a can of worms.
261 *
262 * This really needs a rewrite/refactor its totally broken in anything other than basic cases
263 * Multiple Scenes + Set Scenes & mixing meta-ball basis _should_ work but fails to update the
264 * depsgraph on rename and linking into scenes or removal of basis meta-ball.
265 * So take care when changing this code.
266 *
267 * Main idiot thing here is that the system returns #BKE_mball_basis_find()
268 * objects which fail a #BKE_mball_is_basis() test.
269 *
270 * Not only that but the depsgraph and their areas depend on this behavior,
271 * so making small fixes here isn't worth it. */
272
273 /* Just a quick test. */
274 const int len = strlen(ob->id.name);
275 return !isdigit(ob->id.name[len - 1]);
276}
277
278bool BKE_mball_is_same_group(const Object *ob1, const Object *ob2)
279{
280 int basis1nr, basis2nr;
281 char basis1name[MAX_ID_NAME], basis2name[MAX_ID_NAME];
282
283 if (ob1->id.name[2] != ob2->id.name[2]) {
284 /* Quick return in case first char of both ID's names is not the same... */
285 return false;
286 }
287
288 BLI_string_split_name_number(ob1->id.name + 2, '.', basis1name, &basis1nr);
289 BLI_string_split_name_number(ob2->id.name + 2, '.', basis2name, &basis2nr);
290
291 return STREQ(basis1name, basis2name);
292}
293
294bool BKE_mball_is_basis_for(const Object *ob1, const Object *ob2)
295{
296 return BKE_mball_is_same_group(ob1, ob2) && BKE_mball_is_basis(ob1);
297}
298
300{
301 for (const MetaElem &ml : *mb->editelems) {
302 if (ml.flag & SELECT) {
303 return true;
304 }
305 }
306 return false;
307}
308
310{
311 for (Base *base : bases) {
312 Object *obedit = base->object;
313 MetaBall *mb = id_cast<MetaBall *>(obedit->data);
315 return true;
316 }
317 }
318 return false;
319}
320
322{
323 for (const MetaElem &ml : *mb->editelems) {
324 if ((ml.flag & SELECT) == 0) {
325 return true;
326 }
327 }
328 return false;
329}
330
331static void mball_data_properties_copy(MetaBall *mb_dst, MetaBall *mb_src)
332{
333 mb_dst->wiresize = mb_src->wiresize;
334 mb_dst->rendersize = mb_src->rendersize;
335 mb_dst->thresh = mb_src->thresh;
336 mb_dst->flag = mb_src->flag;
337 DEG_id_tag_update(&mb_dst->id, 0);
338}
339
340void BKE_mball_properties_copy(Main *bmain, MetaBall *metaball_src)
341{
359 for (Object *ob_src = bmain->objects.first(); ob_src != nullptr && ID_IS_EDITABLE(ob_src);) {
360 if (ob_src->data != id_cast<const ID *>(metaball_src)) {
361 ob_src = static_cast<Object *>(ob_src->id.next);
362 continue;
363 }
364
365 /* In this code we take advantage of two facts:
366 * - MetaBalls of the same family have the same basis name,
367 * - IDs are sorted by name in their Main listbase.
368 * So, all MetaBall objects of the same family are contiguous in bmain list (potentially mixed
369 * with non-meta-ball objects with same basis names).
370 *
371 * Using this, it is possible to process the whole set of meta-balls with a single loop on the
372 * whole list of Objects, though additionally going backward on part of the list in some cases.
373 */
374 Object *ob_iter = nullptr;
375 int obactive_nr, ob_nr;
376 char obactive_name[MAX_ID_NAME], ob_name[MAX_ID_NAME];
377 BLI_string_split_name_number(ob_src->id.name + 2, '.', obactive_name, &obactive_nr);
378
379 for (ob_iter = static_cast<Object *>(ob_src->id.prev); ob_iter != nullptr;
380 ob_iter = static_cast<Object *>(ob_iter->id.prev))
381 {
382 if (ob_iter->id.name[2] != obactive_name[0]) {
383 break;
384 }
385 if (ob_iter->type != OB_MBALL || ob_iter->data == id_cast<const ID *>(metaball_src)) {
386 continue;
387 }
388 BLI_string_split_name_number(ob_iter->id.name + 2, '.', ob_name, &ob_nr);
389 if (!STREQ(obactive_name, ob_name)) {
390 break;
391 }
392
393 mball_data_properties_copy(id_cast<MetaBall *>(ob_iter->data), metaball_src);
394 }
395
396 for (ob_iter = static_cast<Object *>(ob_src->id.next); ob_iter != nullptr;
397 ob_iter = static_cast<Object *>(ob_iter->id.next))
398 {
399 if (ob_iter->id.name[2] != obactive_name[0] || !ID_IS_EDITABLE(ob_iter)) {
400 break;
401 }
402 if (ob_iter->type != OB_MBALL || ob_iter->data == id_cast<const ID *>(metaball_src)) {
403 continue;
404 }
405 BLI_string_split_name_number(ob_iter->id.name + 2, '.', ob_name, &ob_nr);
406 if (!STREQ(obactive_name, ob_name)) {
407 break;
408 }
409
410 mball_data_properties_copy(id_cast<MetaBall *>(ob_iter->data), metaball_src);
411 }
412
413 ob_src = ob_iter;
414 }
415}
416
417Object *BKE_mball_basis_find(const Main &bmain, Scene *scene, Object *object)
418{
419 Object *bob = object;
420 int basisnr, obnr;
421 char basisname[MAX_ID_NAME], obname[MAX_ID_NAME];
422
423 BLI_string_split_name_number(object->id.name + 2, '.', basisname, &basisnr);
424
425 for (ViewLayer &view_layer : scene->view_layers) {
426 BKE_view_layer_synced_ensure(bmain, scene, &view_layer);
427 for (Base &base : *BKE_view_layer_object_bases_get(&view_layer)) {
428 Object *ob = base.object;
429 if ((ob->type == OB_MBALL) && !(base.flag & BASE_FROM_DUPLI)) {
430 if (ob != bob) {
431 BLI_string_split_name_number(ob->id.name + 2, '.', obname, &obnr);
432
433 /* Object ob has to be in same "group" ... it means,
434 * that it has to have same base of its name. */
435 if (STREQ(obname, basisname)) {
436 if (obnr < basisnr) {
437 object = ob;
438 basisnr = obnr;
439 }
440 }
441 }
442 }
443 }
444 }
445
446 return object;
447}
448
450 const MetaBall *mb, float min[3], float max[3], const float obmat[4][4], const short flag)
451{
452 const float scale = obmat ? mat4_to_scale(obmat) : 1.0f;
453 bool changed = false;
454 float centroid[3], vec[3];
455
457
458 for (const MetaElem &ml : mb->elems) {
459 if ((ml.flag & flag) == flag) {
460 const float scale_mb = (ml.rad * 0.5f) * scale;
461
462 if (obmat) {
463 mul_v3_m4v3(centroid, obmat, &ml.x);
464 }
465 else {
466 copy_v3_v3(centroid, &ml.x);
467 }
468
469 /* TODO(@ideasman42): non circle shapes cubes etc, probably nobody notices. */
470 for (int i = -1; i != 3; i += 2) {
471 copy_v3_v3(vec, centroid);
472 add_v3_fl(vec, scale_mb * i);
473 minmax_v3v3_v3(min, max, vec);
474 }
475 changed = true;
476 }
477 }
478
479 return changed;
480}
481
482bool BKE_mball_minmax(const MetaBall *mb, float min[3], float max[3])
483{
485
486 for (const MetaElem &ml : mb->elems) {
487 minmax_v3v3_v3(min, max, &ml.x);
488 }
489
490 return (mb->elems.is_empty() == false);
491}
492
493bool BKE_mball_center_median(const MetaBall *mb, float r_cent[3])
494{
495 int total = 0;
496
497 zero_v3(r_cent);
498
499 for (const MetaElem &ml : mb->elems) {
500 add_v3_v3(r_cent, &ml.x);
501 total++;
502 }
503
504 if (total) {
505 mul_v3_fl(r_cent, 1.0f / float(total));
506 }
507
508 return (total != 0);
509}
510
511bool BKE_mball_center_bounds(const MetaBall *mb, float r_cent[3])
512{
513 float min[3], max[3];
514
515 if (BKE_mball_minmax(mb, min, max)) {
516 mid_v3_v3v3(r_cent, min, max);
517 return true;
518 }
519
520 return false;
521}
522
523void BKE_mball_transform(MetaBall *mb, const float mat[4][4], const bool do_props)
524{
525 float quat[4];
526 const float scale = mat4_to_scale(mat);
527 const float scale_sqrt = sqrtf(scale);
528
529 mat4_to_quat(quat, mat);
530
531 for (MetaElem &ml : mb->elems) {
532 mul_m4_v3(mat, &ml.x);
533 mul_qt_qtqt(ml.quat, quat, ml.quat);
534
535 if (do_props) {
536 ml.rad *= scale;
537 /* hrmf, probably elems shouldn't be
538 * treating scale differently - campbell */
539 if (!MB_TYPE_SIZE_SQUARED(ml.type)) {
540 mul_v3_fl(&ml.expx, scale);
541 }
542 else {
543 mul_v3_fl(&ml.expx, scale_sqrt);
544 }
545 }
546 }
547}
548
549void BKE_mball_translate(MetaBall *mb, const float offset[3])
550{
551 for (MetaElem &ml : mb->elems) {
552 add_v3_v3(&ml.x, offset);
553 }
554}
555
557{
558 int sel = 0;
559 for (const MetaElem &ml : *mb->editelems) {
560 if (ml.flag & SELECT) {
561 sel++;
562 }
563 }
564 return sel;
565}
566
568{
569 int sel = 0;
570 for (Base *base : bases) {
571 Object *obedit = base->object;
572 const MetaBall *mb = id_cast<MetaBall *>(obedit->data);
573 sel += BKE_mball_select_count(mb);
574 }
575 return sel;
576}
577
579{
580 bool changed = false;
581 for (MetaElem &ml : *mb->editelems) {
582 if ((ml.flag & SELECT) == 0) {
583 ml.flag |= MB_SELECT;
584 changed = true;
585 }
586 }
587 return changed;
588}
589
591{
592 bool changed_multi = false;
593 for (Base *base : bases) {
594 Object *obedit = base->object;
595 MetaBall *mb = id_cast<MetaBall *>(obedit->data);
596 changed_multi |= BKE_mball_select_all(mb);
597 }
598 return changed_multi;
599}
600
602{
603 bool changed = false;
604 for (MetaElem &ml : *mb->editelems) {
605 if ((ml.flag & SELECT) != 0) {
606 ml.flag &= ~MB_SELECT;
607 changed = true;
608 }
609 }
610 return changed;
611}
612
614{
615 bool changed_multi = false;
616 for (Base *base : bases) {
617 Object *obedit = base->object;
618 MetaBall *mb = id_cast<MetaBall *>(obedit->data);
619 changed_multi |= BKE_mball_deselect_all(mb);
621 }
622 return changed_multi;
623}
624
626{
627 bool changed = false;
628 for (MetaElem &ml : *mb->editelems) {
629 ml.flag ^= MB_SELECT;
630 changed = true;
631 }
632 return changed;
633}
634
636{
637 bool changed_multi = false;
638 for (Base *base : bases) {
639 Object *obedit = base->object;
640 MetaBall *mb = id_cast<MetaBall *>(obedit->data);
641 changed_multi |= BKE_mball_select_swap(mb);
642 }
643 return changed_multi;
644}
645
646/* **** Depsgraph evaluation **** */
647
648void BKE_mball_data_update(Depsgraph *depsgraph, Scene *scene, Object *ob)
649{
650 using namespace blender::bke;
651 BLI_assert(ob->type == OB_MBALL);
652
654
655 const Object *basis_object = BKE_mball_basis_find(*DEG_get_bmain(depsgraph), scene, ob);
656 if (ob != basis_object) {
657 return;
658 }
659
660 Mesh *mesh = BKE_mball_polygonize(depsgraph, scene, ob);
661 if (mesh == nullptr) {
662 return;
663 }
664
665 const MetaBall *mball = id_cast<MetaBall *>(ob->data);
666 mesh->mat = MEM_dupalloc(mball->mat);
667 mesh->totcol = mball->totcol;
668
669 if (ob->parent && ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
671 ob->parent,
672 ob,
673 reinterpret_cast<float (*)[3]>(mesh->vert_positions_for_write().data()),
674 mesh->verts_num,
675 0,
676 nullptr,
677 1.0f);
678 mesh->tag_positions_changed();
679 }
680
682};
683
684} // namespace blender
#define BKE_LIB_FOREACHID_PROCESS_IDSUPER(data_, id_super_, cb_flag_)
#define SELECT
Definition BKE_mask.hh:19
General operations, lookup, etc. for blender objects.
#define M_SQRT2
#define BLO_read_struct_list(reader, struct_name, list)
#define BLT_I18NCONTEXT_ID_METABALL
ID and Library types, which are fundamental for SDNA.
#define FILTER_ID_MA
Definition DNA_ID.h:1210
#define FILTER_ID_MB
Definition DNA_ID.h:1211
#define MAX_ID_NAME
Definition DNA_ID.h:367
#define ID_IS_EDITABLE(_id)
Definition DNA_ID.h:708
#define MB_TYPE_SIZE_SQUARED(type)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define INIT_MINMAX(min, max)
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define STREQ(a, b)
btScalar max
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void metaball_blend_write(BlendWriter *writer, ID *id, const void *id_address)
Definition mball.cc:102
bool BKE_mball_is_same_group(const Object *ob1, const Object *ob2)
Definition mball.cc:278
bool BKE_mball_select_all_multi_ex(Span< Base * > bases)
MetaElem * BKE_mball_element_add(MetaBall *mb, int type)
Definition mball.cc:179
void BKE_mball_data_update(Depsgraph *depsgraph, Scene *scene, Object *ob)
Definition mball.cc:648
void BKE_mball_translate(MetaBall *mb, const float offset[3])
Definition mball.cc:549
static void metaball_init_data(ID *id)
Definition mball.cc:62
MINLINE void copy_v3_v3(float r[3], const float a[3])
static void metaball_foreach_id(ID *id, LibraryForeachIDData *data)
Definition mball.cc:94
void mat4_to_quat(float q[4], const float mat[4][4])
bool BKE_mball_is_basis(const Object *ob)
Definition mball.cc:255
bool BKE_mball_minmax(const MetaBall *mb, float min[3], float max[3])
Definition mball.cc:482
static void metaball_free_data(ID *id)
Definition mball.cc:85
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
void BLO_read_pointer_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size)
bool BKE_mball_deselect_all_multi_ex(Span< Base * > bases)
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
Definition listbase.cc:834
bool BKE_mball_center_bounds(const MetaBall *mb, float r_cent[3])
Definition mball.cc:511
float mat4_to_scale(const float mat[4][4])
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
bool BKE_mball_select_swap(MetaBall *mb)
Definition mball.cc:625
MINLINE void add_v3_fl(float r[3], float f)
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
void BKE_id_blend_write(BlendWriter *writer, ID *id)
Definition lib_id.cc:2890
MINLINE void mul_v3_fl(float r[3], float f)
bool BKE_mball_select_swap_multi_ex(Span< Base * > bases)
Mesh * BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob)
IDTypeInfo IDType_ID_MB
Definition mball.cc:139
void mul_m4_v3(const float M[4][4], float r[3])
void unit_qt(float q[4])
int BKE_mball_select_count(const MetaBall *mb)
Definition mball.cc:556
int BKE_mball_select_count_multi(Span< Base * > bases)
VecBase< float, 2 > float2
void BKE_object_free_derived_caches(Object *ob)
Definition object.cc:1810
static void metaball_blend_read_data(BlendDataReader *reader, ID *id)
Definition mball.cc:124
bool BKE_mball_minmax_ex(const MetaBall *mb, float min[3], float max[3], const float obmat[4][4], short flag)
Definition mball.cc:449
Main * DEG_get_bmain(const Depsgraph *graph)
void DEG_id_tag_update(ID *id, unsigned int flags)
static void metaball_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int)
Definition mball.cc:68
BMesh const char void * data
bool BKE_mball_is_basis_for(const Object *ob1, const Object *ob2)
Definition mball.cc:294
Object * BKE_mball_basis_find(const Main &bmain, Scene *scene, Object *ob)
Definition mball.cc:417
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
void BKE_mball_transform(MetaBall *mb, const float mat[4][4], bool do_props)
Definition mball.cc:523
void BKE_lattice_deform_coords(const Object *ob_lattice, const Object *ob_target, float(*vert_coords)[3], int vert_coords_len, short flag, const char *defgrp_name, float fac)
MINLINE void zero_v3(float r[3])
void BKE_mball_properties_copy(Main *bmain, MetaBall *metaball_src)
Definition mball.cc:340
static void mball_data_properties_copy(MetaBall *mb_dst, MetaBall *mb_src)
Definition mball.cc:331
MINLINE void add_v3_v3(float r[3], const float a[3])
float BKE_mball_element_display_radius_calc(const MetaElem *ml)
Definition mball.cc:245
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
float2 BKE_mball_element_display_radius_calc_with_stiffness(const MetaElem *ml)
Definition mball.cc:226
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
@ INDEX_ID_MB
Definition DNA_ID.h:1329
bool BKE_mball_is_any_unselected(const MetaBall *mb)
Definition mball.cc:321
bool BKE_mball_deselect_all(MetaBall *mb)
Definition mball.cc:601
MetaBall * BKE_mball_add(Main *bmain, const char *name)
Definition mball.cc:173
@ ID_RECALC_SELECT
Definition DNA_ID.h:1101
bool BKE_mball_is_any_selected(const MetaBall *mb)
Definition mball.cc:299
bool BKE_mball_select_all(MetaBall *mb)
Definition mball.cc:578
size_t BLI_string_split_name_number(const char *name, char delim, char *r_name_left, int *r_number) ATTR_NONNULL(1
bool BKE_mball_is_any_selected_multi(Span< Base * > bases)
bool BKE_mball_center_median(const MetaBall *mb, float r_cent[3])
Definition mball.cc:493
void * BKE_id_new(Main *bmain, short type, const char *name)
Definition lib_id.cc:1612
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
@ IDTYPE_FLAGS_APPEND_IS_REUSABLE
Definition BKE_idtype.hh:50
#define sqrtf
#define atanf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38
void write_pointer_array(int64_t num, const void *data)
void write_id_struct(const void *id_address, const T *id, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
static GeometrySet from_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
char name[258]
Definition DNA_ID.h:433
void * prev
Definition DNA_ID.h:418
void * next
Definition DNA_ID.h:418
ListBaseT< Object > objects
Definition BKE_main.hh:388
ListBaseT< MetaElem > elems
ListBaseT< MetaElem > * editelems
struct Material ** mat
eMetaBall_Flag flag
eMetaElem_Type type
eMetaElem_Flag flag
struct Object * parent
bke::ObjectRuntime * runtime
eObject_Partype partype
ListBaseT< ViewLayer > view_layers
#define N_(msgid)