Blender  V3.3
object_data_transform.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved. */
3 
14 #include <stdlib.h>
15 #include <string.h>
16 
17 #include "DNA_anim_types.h"
18 #include "DNA_armature_types.h"
19 #include "DNA_collection_types.h"
20 #include "DNA_gpencil_types.h"
21 #include "DNA_lattice_types.h"
22 #include "DNA_mesh_types.h"
23 #include "DNA_meta_types.h"
24 #include "DNA_object_types.h"
25 #include "DNA_scene_types.h"
26 
27 #include "BLI_listbase.h"
28 #include "BLI_math.h"
29 #include "BLI_utildefines.h"
30 
31 #include "BKE_armature.h"
32 #include "BKE_curve.h"
33 #include "BKE_editmesh.h"
34 #include "BKE_gpencil_geom.h"
35 #include "BKE_key.h"
36 #include "BKE_lattice.h"
37 #include "BKE_mball.h"
38 #include "BKE_mesh.h"
39 #include "BKE_scene.h"
40 
41 #include "bmesh.h"
42 
43 #include "DEG_depsgraph.h"
44 #include "DEG_depsgraph_query.h"
45 
46 #include "WM_types.h"
47 
48 #include "ED_armature.h"
49 #include "ED_mesh.h"
50 #include "ED_object.h"
51 
52 #include "MEM_guardedalloc.h"
53 
54 /* -------------------------------------------------------------------- */
62 /* Armature */
63 
65  float tail[3];
66  float head[3];
67  float roll;
68  float arm_tail[3];
69  float arm_head[3];
70  float arm_roll;
71  float rad_tail;
72  float rad_head;
73  float dist;
74  float xwidth;
75  float zwidth;
76 };
77 
79  const ListBase *bone_base, struct ElemData_Armature *elem_array)
80 {
81  struct ElemData_Armature *elem = elem_array;
82  LISTBASE_FOREACH (const Bone *, bone, bone_base) {
83 
84 #define COPY_PTR(member) memcpy(elem->member, bone->member, sizeof(bone->member))
85 #define COPY_VAL(member) memcpy(&elem->member, &bone->member, sizeof(bone->member))
86  COPY_PTR(head);
87  COPY_PTR(tail);
88  COPY_VAL(roll);
94  COPY_VAL(dist);
97 #undef COPY_PTR
98 #undef COPY_VAL
99 
100  elem = armature_coords_and_quats_get_recurse(&bone->childbase, elem + 1);
101  }
102  return elem;
103 }
104 
106  struct ElemData_Armature *elem_array)
107 {
109 }
110 
112  ListBase *bone_base, const struct ElemData_Armature *elem_array, const float mat[4][4])
113 {
114  const struct ElemData_Armature *elem = elem_array;
115  LISTBASE_FOREACH (Bone *, bone, bone_base) {
116 
117 #define COPY_PTR(member) memcpy(bone->member, elem->member, sizeof(bone->member))
118 #define COPY_VAL(member) memcpy(&bone->member, &elem->member, sizeof(bone->member))
119  COPY_PTR(head);
120  COPY_PTR(tail);
121  COPY_VAL(roll);
127  COPY_VAL(dist);
128  COPY_VAL(xwidth);
129  COPY_VAL(zwidth);
130 #undef COPY_PTR
131 #undef COPY_VAL
132 
133  elem = armature_coords_and_quats_apply_with_mat4_recurse(&bone->childbase, elem + 1, mat);
134  }
135  return elem;
136 }
137 
139  const struct ElemData_Armature *elem_array,
140  const float mat[4][4])
141 {
143  BKE_armature_transform(arm, mat, true);
144 }
145 
147  const struct ElemData_Armature *elem_array)
148 {
149  /* Avoid code duplication by using a unit matrix. */
150  float mat[4][4];
151  unit_m4(mat);
152  armature_coords_and_quats_apply_with_mat4(arm, elem_array, mat);
153 }
154 
155 /* Edit Armature */
157  struct ElemData_Armature *elem_array)
158 {
159  struct ElemData_Armature *elem = elem_array;
160  for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next, elem++) {
161 
162 #define COPY_PTR(member) memcpy(elem->member, ebone->member, sizeof(ebone->member))
163 #define COPY_VAL(member) memcpy(&elem->member, &ebone->member, sizeof(ebone->member))
164  /* Unused for edit bones: arm_head, arm_tail, arm_roll */
165  COPY_PTR(head);
166  COPY_PTR(tail);
167  COPY_VAL(roll);
170  COPY_VAL(dist);
171  COPY_VAL(xwidth);
172  COPY_VAL(zwidth);
173 #undef COPY_PTR
174 #undef COPY_VAL
175  }
176 }
177 
179  bArmature *arm, const struct ElemData_Armature *elem_array, const float mat[4][4])
180 {
181  const struct ElemData_Armature *elem = elem_array;
182  for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next, elem++) {
183 
184 #define COPY_PTR(member) memcpy(ebone->member, elem->member, sizeof(ebone->member))
185 #define COPY_VAL(member) memcpy(&ebone->member, &elem->member, sizeof(ebone->member))
186  /* Unused for edit bones: arm_head, arm_tail, arm_roll */
187  COPY_PTR(head);
188  COPY_PTR(tail);
189  COPY_VAL(roll);
192  COPY_VAL(dist);
193  COPY_VAL(xwidth);
194  COPY_VAL(zwidth);
195 #undef COPY_PTR
196 #undef COPY_VAL
197  }
198  ED_armature_edit_transform(arm, mat, true);
199 }
200 
202  const struct ElemData_Armature *elem_array)
203 {
204  /* Avoid code duplication by using a unit matrix. */
205  float mat[4][4];
206  unit_m4(mat);
208 }
209 
210 /* MetaBall */
211 
213  float co[3];
214  float quat[4];
215  float exp[3];
216  float rad;
217 };
218 
219 static void metaball_coords_and_quats_get(const MetaBall *mb, struct ElemData_MetaBall *elem_array)
220 {
221  struct ElemData_MetaBall *elem = elem_array;
222  for (const MetaElem *ml = mb->elems.first; ml; ml = ml->next, elem++) {
223  copy_v3_v3(elem->co, &ml->x);
224  copy_qt_qt(elem->quat, ml->quat);
225  copy_v3_v3(elem->exp, &ml->expx);
226  elem->rad = ml->rad;
227  }
228 }
229 
231  const struct ElemData_MetaBall *elem_array,
232  const float mat[4][4])
233 {
234  const struct ElemData_MetaBall *elem = elem_array;
235  for (MetaElem *ml = mb->elems.first; ml; ml = ml->next, elem++) {
236  copy_v3_v3(&ml->x, elem->co);
237  copy_qt_qt(ml->quat, elem->quat);
238  copy_v3_v3(&ml->expx, elem->exp);
239  ml->rad = elem->rad;
240  }
241  BKE_mball_transform(mb, mat, true);
242 }
243 
245  const struct ElemData_MetaBall *elem_array)
246 {
247  /* Avoid code duplication by using a unit matrix. */
248  float mat[4][4];
249  unit_m4(mat);
250  metaball_coords_and_quats_apply_with_mat4(mb, elem_array, mat);
251 }
252 
255 /* -------------------------------------------------------------------- */
264  ID *id;
266 };
267 
269  struct XFormObjectData base;
270  /* Optional data for shape keys. */
271  void *key_data;
272  float elem_array[0][3];
273 };
274 
276  struct XFormObjectData base;
277  /* Optional data for shape keys. */
278  void *key_data;
279  float elem_array[0][3];
280 };
281 
283  struct XFormObjectData base;
284  /* Optional data for shape keys. */
285  void *key_data;
286  float elem_array[0][3];
287 };
288 
290  struct XFormObjectData base;
291  struct ElemData_Armature elem_array[0];
292 };
293 
295  struct XFormObjectData base;
296  struct ElemData_MetaBall elem_array[0];
297 };
298 
300  struct XFormObjectData base;
302 };
303 
305 {
306  struct XFormObjectData *xod_base = NULL;
307  if (id == NULL) {
308  return xod_base;
309  }
310 
311  switch (GS(id->name)) {
312  case ID_ME: {
313  Mesh *me = (Mesh *)id;
314  struct Key *key = me->key;
315  const int key_index = -1;
316 
317  if (is_edit_mode) {
318  BMesh *bm = me->edit_mesh->bm;
319  /* Always operate on all keys for the moment. */
320  // key_index = bm->shapenr - 1;
321  const int elem_array_len = bm->totvert;
322  struct XFormObjectData_Mesh *xod = MEM_mallocN(
323  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
324  memset(xod, 0x0, sizeof(*xod));
325 
327  xod_base = &xod->base;
328 
329  if (key != NULL) {
330  const size_t key_size = BKE_keyblock_element_calc_size_from_shape(key, key_index);
331  if (key_size) {
332  xod->key_data = MEM_mallocN(key_size, __func__);
333  BKE_keyblock_data_get_from_shape(key, xod->key_data, key_index);
334  }
335  }
336  }
337  else {
338  const int elem_array_len = me->totvert;
339  struct XFormObjectData_Mesh *xod = MEM_mallocN(
340  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
341  memset(xod, 0x0, sizeof(*xod));
342 
344  xod_base = &xod->base;
345 
346  if (key != NULL) {
347  const size_t key_size = BKE_keyblock_element_calc_size_from_shape(key, key_index);
348  if (key_size) {
349  xod->key_data = MEM_mallocN(key_size, __func__);
350  BKE_keyblock_data_get_from_shape(key, xod->key_data, key_index);
351  }
352  }
353  }
354  break;
355  }
356  case ID_LT: {
357  Lattice *lt_orig = (Lattice *)id;
358  Lattice *lt = is_edit_mode ? lt_orig->editlatt->latt : lt_orig;
359  struct Key *key = lt->key;
360  const int key_index = -1;
361 
362  if (is_edit_mode) {
363  /* Always operate on all keys for the moment. */
364  // key_index = lt_orig->editlatt->shapenr - 1;
365  }
366 
367  const int elem_array_len = lt->pntsu * lt->pntsv * lt->pntsw;
368  struct XFormObjectData_Lattice *xod = MEM_mallocN(
369  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
370  memset(xod, 0x0, sizeof(*xod));
371 
373  xod_base = &xod->base;
374 
375  if (key != NULL) {
376  const size_t key_size = BKE_keyblock_element_calc_size_from_shape(key, key_index);
377  if (key_size) {
378  xod->key_data = MEM_mallocN(key_size, __func__);
379  BKE_keyblock_data_get_from_shape(key, xod->key_data, key_index);
380  }
381  }
382 
383  break;
384  }
385  case ID_CU_LEGACY: {
386  Curve *cu = (Curve *)id;
387  struct Key *key = cu->key;
388 
389  const short ob_type = BKE_curve_type_get(cu);
390  if (ob_type == OB_FONT) {
391  /* We could support translation. */
392  break;
393  }
394 
395  const int key_index = -1;
396  ListBase *nurbs;
397  if (is_edit_mode) {
398  EditNurb *editnurb = cu->editnurb;
399  nurbs = &editnurb->nurbs;
400  /* Always operate on all keys for the moment. */
401  // key_index = editnurb->shapenr - 1;
402  }
403  else {
404  nurbs = &cu->nurb;
405  }
406 
407  const int elem_array_len = BKE_nurbList_verts_count(nurbs);
408  struct XFormObjectData_Curve *xod = MEM_mallocN(
409  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
410  memset(xod, 0x0, sizeof(*xod));
411 
412  BKE_curve_nurbs_vert_coords_get(nurbs, xod->elem_array, elem_array_len);
413  xod_base = &xod->base;
414 
415  if (key != NULL) {
416  const size_t key_size = BKE_keyblock_element_calc_size_from_shape(key, key_index);
417  if (key_size) {
418  xod->key_data = MEM_mallocN(key_size, __func__);
419  BKE_keyblock_data_get_from_shape(key, xod->key_data, key_index);
420  }
421  }
422 
423  break;
424  }
425  case ID_AR: {
426  bArmature *arm = (bArmature *)id;
427  if (is_edit_mode) {
428  const int elem_array_len = BLI_listbase_count(arm->edbo);
430  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
431  memset(xod, 0x0, sizeof(*xod));
432 
434  xod_base = &xod->base;
435  }
436  else {
437  const int elem_array_len = BKE_armature_bonelist_count(&arm->bonebase);
439  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
440  memset(xod, 0x0, sizeof(*xod));
441 
443  xod_base = &xod->base;
444  }
445  break;
446  }
447  case ID_MB: {
448  /* Edit mode and object mode are shared. */
449  MetaBall *mb = (MetaBall *)id;
450  const int elem_array_len = BLI_listbase_count(&mb->elems);
452  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
453  memset(xod, 0x0, sizeof(*xod));
454 
456  xod_base = &xod->base;
457  break;
458  }
459  case ID_GD: {
460  bGPdata *gpd = (bGPdata *)id;
461  const int elem_array_len = BKE_gpencil_stroke_point_count(gpd);
462  struct XFormObjectData_GPencil *xod = MEM_mallocN(
463  sizeof(*xod) + (sizeof(*xod->elem_array) * elem_array_len), __func__);
464  memset(xod, 0x0, sizeof(*xod));
465 
467  xod_base = &xod->base;
468  break;
469  }
470  default: {
471  break;
472  }
473  }
474  if (xod_base) {
475  xod_base->id = id;
476  xod_base->is_edit_mode = is_edit_mode;
477  }
478  return xod_base;
479 }
480 
482 {
483  return ED_object_data_xform_create_ex(id, false);
484 }
485 
487 {
488  return ED_object_data_xform_create_ex(id, true);
489 }
490 
492 {
493  switch (GS(xod_base->id->name)) {
494  case ID_ME: {
495  struct XFormObjectData_Mesh *xod = (struct XFormObjectData_Mesh *)xod_base;
496  if (xod->key_data != NULL) {
497  MEM_freeN(xod->key_data);
498  }
499  break;
500  }
501  case ID_LT: {
502  struct XFormObjectData_Lattice *xod = (struct XFormObjectData_Lattice *)xod_base;
503  if (xod->key_data != NULL) {
504  MEM_freeN(xod->key_data);
505  }
506  break;
507  }
508  case ID_CU_LEGACY: {
509  struct XFormObjectData_Curve *xod = (struct XFormObjectData_Curve *)xod_base;
510  if (xod->key_data != NULL) {
511  MEM_freeN(xod->key_data);
512  }
513  break;
514  }
515  default: {
516  break;
517  }
518  }
519  MEM_freeN(xod_base);
520 }
521 
522 void ED_object_data_xform_by_mat4(struct XFormObjectData *xod_base, const float mat[4][4])
523 {
524  switch (GS(xod_base->id->name)) {
525  case ID_ME: {
526  Mesh *me = (Mesh *)xod_base->id;
527 
528  struct Key *key = me->key;
529  const int key_index = -1;
530 
531  struct XFormObjectData_Mesh *xod = (struct XFormObjectData_Mesh *)xod_base;
532  if (xod_base->is_edit_mode) {
533  BMesh *bm = me->edit_mesh->bm;
534  BM_mesh_vert_coords_apply_with_mat4(bm, xod->elem_array, mat);
535  /* Always operate on all keys for the moment. */
536  // key_index = bm->shapenr - 1;
537  }
538  else {
539  BKE_mesh_vert_coords_apply_with_mat4(me, xod->elem_array, mat);
540  }
541 
542  if (key != NULL) {
543  BKE_keyblock_data_set_with_mat4(key, key_index, xod->key_data, mat);
544  }
545 
546  break;
547  }
548  case ID_LT: {
549  Lattice *lt_orig = (Lattice *)xod_base->id;
550  Lattice *lt = xod_base->is_edit_mode ? lt_orig->editlatt->latt : lt_orig;
551 
552  struct Key *key = lt->key;
553  const int key_index = -1;
554 
555  struct XFormObjectData_Lattice *xod = (struct XFormObjectData_Lattice *)xod_base;
556  BKE_lattice_vert_coords_apply_with_mat4(lt, xod->elem_array, mat);
557  if (xod_base->is_edit_mode) {
558  /* Always operate on all keys for the moment. */
559  // key_index = lt_orig->editlatt->shapenr - 1;
560  }
561 
562  if ((key != NULL) && (xod->key_data != NULL)) {
563  BKE_keyblock_data_set_with_mat4(key, key_index, xod->key_data, mat);
564  }
565 
566  break;
567  }
568  case ID_CU_LEGACY: {
569  BLI_assert(xod_base->is_edit_mode == false); /* Not used currently. */
570  Curve *cu = (Curve *)xod_base->id;
571 
572  struct Key *key = cu->key;
573  const int key_index = -1;
574  ListBase *nurb = NULL;
575 
576  struct XFormObjectData_Curve *xod = (struct XFormObjectData_Curve *)xod_base;
577  if (xod_base->is_edit_mode) {
578  EditNurb *editnurb = cu->editnurb;
579  nurb = &editnurb->nurbs;
581  &editnurb->nurbs, xod->elem_array, mat, CU_IS_2D(cu));
582  /* Always operate on all keys for the moment. */
583  // key_index = editnurb->shapenr - 1;
584  }
585  else {
586  nurb = &cu->nurb;
587  BKE_curve_nurbs_vert_coords_apply_with_mat4(&cu->nurb, xod->elem_array, mat, CU_IS_2D(cu));
588  }
589 
590  if ((key != NULL) && (xod->key_data != NULL)) {
591  BKE_keyblock_curve_data_set_with_mat4(key, nurb, key_index, xod->key_data, mat);
592  }
593 
594  break;
595  }
596  case ID_AR: {
597  BLI_assert(xod_base->is_edit_mode == false); /* Not used currently. */
598  bArmature *arm = (bArmature *)xod_base->id;
599  struct XFormObjectData_Armature *xod = (struct XFormObjectData_Armature *)xod_base;
600  if (xod_base->is_edit_mode) {
601  edit_armature_coords_and_quats_apply_with_mat4(arm, xod->elem_array, mat);
602  }
603  else {
604  armature_coords_and_quats_apply_with_mat4(arm, xod->elem_array, mat);
605  }
606  break;
607  }
608  case ID_MB: {
609  /* Metaballs are a special case, edit-mode and object mode data is shared. */
610  MetaBall *mb = (MetaBall *)xod_base->id;
611  struct XFormObjectData_MetaBall *xod = (struct XFormObjectData_MetaBall *)xod_base;
612  metaball_coords_and_quats_apply_with_mat4(mb, xod->elem_array, mat);
613  break;
614  }
615  case ID_GD: {
616  bGPdata *gpd = (bGPdata *)xod_base->id;
617  struct XFormObjectData_GPencil *xod = (struct XFormObjectData_GPencil *)xod_base;
618  BKE_gpencil_point_coords_apply_with_mat4(gpd, xod->elem_array, mat);
619  break;
620  }
621  default: {
622  break;
623  }
624  }
625 }
626 
628 {
629  switch (GS(xod_base->id->name)) {
630  case ID_ME: {
631  Mesh *me = (Mesh *)xod_base->id;
632 
633  struct Key *key = me->key;
634  const int key_index = -1;
635 
636  struct XFormObjectData_Mesh *xod = (struct XFormObjectData_Mesh *)xod_base;
637  if (xod_base->is_edit_mode) {
638  BMesh *bm = me->edit_mesh->bm;
639  BM_mesh_vert_coords_apply(bm, xod->elem_array);
640  /* Always operate on all keys for the moment. */
641  // key_index = bm->shapenr - 1;
642  }
643  else {
644  BKE_mesh_vert_coords_apply(me, xod->elem_array);
645  }
646 
647  if ((key != NULL) && (xod->key_data != NULL)) {
648  BKE_keyblock_data_set(key, key_index, xod->key_data);
649  }
650 
651  break;
652  }
653  case ID_LT: {
654  Lattice *lt_orig = (Lattice *)xod_base->id;
655  Lattice *lt = xod_base->is_edit_mode ? lt_orig->editlatt->latt : lt_orig;
656 
657  struct Key *key = lt->key;
658  const int key_index = -1;
659 
660  struct XFormObjectData_Lattice *xod = (struct XFormObjectData_Lattice *)xod_base;
661  BKE_lattice_vert_coords_apply(lt, xod->elem_array);
662  if (xod_base->is_edit_mode) {
663  /* Always operate on all keys for the moment. */
664  // key_index = lt_orig->editlatt->shapenr - 1;
665  }
666 
667  if ((key != NULL) && (xod->key_data != NULL)) {
668  BKE_keyblock_data_set(key, key_index, xod->key_data);
669  }
670 
671  break;
672  }
673  case ID_CU_LEGACY: {
674  Curve *cu = (Curve *)xod_base->id;
675 
676  struct Key *key = cu->key;
677  const int key_index = -1;
678 
679  struct XFormObjectData_Curve *xod = (struct XFormObjectData_Curve *)xod_base;
680  if (xod_base->is_edit_mode) {
681  EditNurb *editnurb = cu->editnurb;
682  BKE_curve_nurbs_vert_coords_apply(&editnurb->nurbs, xod->elem_array, CU_IS_2D(cu));
683  /* Always operate on all keys for the moment. */
684  // key_index = editnurb->shapenr - 1;
685  }
686  else {
687  BKE_curve_nurbs_vert_coords_apply(&cu->nurb, xod->elem_array, CU_IS_2D(cu));
688  }
689 
690  if ((key != NULL) && (xod->key_data != NULL)) {
691  BKE_keyblock_data_set(key, key_index, xod->key_data);
692  }
693 
694  break;
695  }
696  case ID_AR: {
697  bArmature *arm = (bArmature *)xod_base->id;
698  struct XFormObjectData_Armature *xod = (struct XFormObjectData_Armature *)xod_base;
699  if (xod_base->is_edit_mode) {
700  edit_armature_coords_and_quats_apply(arm, xod->elem_array);
701  }
702  else {
703  armature_coords_and_quats_apply(arm, xod->elem_array);
704  }
705  break;
706  }
707  case ID_MB: {
708  /* Metaballs are a special case, edit-mode and object mode data is shared. */
709  MetaBall *mb = (MetaBall *)xod_base->id;
710  struct XFormObjectData_MetaBall *xod = (struct XFormObjectData_MetaBall *)xod_base;
711  metaball_coords_and_quats_apply(mb, xod->elem_array);
712  break;
713  }
714  case ID_GD: {
715  bGPdata *gpd = (bGPdata *)xod_base->id;
716  struct XFormObjectData_GPencil *xod = (struct XFormObjectData_GPencil *)xod_base;
717  BKE_gpencil_point_coords_apply(gpd, xod->elem_array);
718  break;
719  }
720  default: {
721  break;
722  }
723  }
724 }
725 
727 {
728  switch (GS(xod_base->id->name)) {
729  case ID_ME: {
730  Mesh *me = (Mesh *)xod_base->id;
731  if (xod_base->is_edit_mode) {
732  EDBM_update(me,
733  &(const struct EDBMUpdate_Params){
734  .calc_looptri = true,
735  .calc_normals = true,
736  .is_destructive = false,
737  });
738  }
740  break;
741  }
742  case ID_LT: {
743  /* Generic update. */
744  Lattice *lt = (Lattice *)xod_base->id;
746  break;
747  }
748  case ID_CU_LEGACY: {
749  /* Generic update. */
750  Curve *cu = (Curve *)xod_base->id;
752  break;
753  }
754  case ID_AR: {
755  /* Generic update. */
756  bArmature *arm = (bArmature *)xod_base->id;
757  /* XXX, zero is needed, no other flags properly update this. */
758  DEG_id_tag_update(&arm->id, 0);
759  break;
760  }
761  case ID_MB: {
762  /* Generic update. */
763  MetaBall *mb = (MetaBall *)xod_base->id;
765  break;
766  }
767  case ID_GD: {
768  /* Generic update. */
769  bGPdata *gpd = (bGPdata *)xod_base->id;
771  break;
772  }
773 
774  default: {
775  break;
776  }
777  }
778 }
779 
void BKE_armature_transform(struct bArmature *arm, const float mat[4][4], bool do_props)
Definition: armature.c:556
int BKE_armature_bonelist_count(const struct ListBase *lb)
int BKE_nurbList_verts_count(const struct ListBase *nurb)
void BKE_curve_nurbs_vert_coords_get(const struct ListBase *lb, float(*vert_coords)[3], int vert_len)
#define CU_IS_2D(cu)
Definition: BKE_curve.h:67
short BKE_curve_type_get(const struct Curve *cu)
void BKE_curve_nurbs_vert_coords_apply_with_mat4(struct ListBase *lb, const float(*vert_coords)[3], const float mat[4][4], bool constrain_2d)
Definition: curve.cc:4580
void BKE_curve_nurbs_vert_coords_apply(struct ListBase *lb, const float(*vert_coords)[3], bool constrain_2d)
Definition: curve.cc:4617
void BKE_gpencil_point_coords_apply(struct bGPdata *gpd, const GPencilPointCoordinates *elem_data)
void BKE_gpencil_point_coords_get(struct bGPdata *gpd, GPencilPointCoordinates *elem_data)
int BKE_gpencil_stroke_point_count(const struct bGPdata *gpd)
void BKE_gpencil_point_coords_apply_with_mat4(struct bGPdata *gpd, const GPencilPointCoordinates *elem_data, const float mat[4][4])
void BKE_keyblock_data_set(struct Key *key, int shape_index, const void *data)
Definition: key.c:1731
void BKE_keyblock_data_set_with_mat4(struct Key *key, int shape_index, const float(*coords)[3], const float mat[4][4])
Definition: key.c:1689
void BKE_keyblock_data_get_from_shape(const struct Key *key, float(*arr)[3], int shape_index)
void BKE_keyblock_curve_data_set_with_mat4(struct Key *key, const struct ListBase *nurb, int shape_index, const void *data, const float mat[4][4])
size_t BKE_keyblock_element_calc_size_from_shape(const struct Key *key, int shape_index)
void BKE_lattice_vert_coords_apply(struct Lattice *lt, const float(*vert_coords)[3])
Definition: lattice.c:525
void BKE_lattice_vert_coords_apply_with_mat4(struct Lattice *lt, const float(*vert_coords)[3], const float mat[4][4])
Definition: lattice.c:515
void BKE_lattice_vert_coords_get(const struct Lattice *lt, float(*vert_coords)[3])
void BKE_mball_transform(struct MetaBall *mb, const float mat[4][4], bool do_props)
Definition: mball.c:613
void BKE_mesh_vert_coords_apply(struct Mesh *mesh, const float(*vert_coords)[3])
Definition: mesh.cc:1834
void BKE_mesh_vert_coords_apply_with_mat4(struct Mesh *mesh, const float(*vert_coords)[3], const float mat[4][4])
Definition: mesh.cc:1846
void BKE_mesh_vert_coords_get(const struct Mesh *mesh, float(*vert_coords)[3])
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
int BLI_listbase_count(const struct ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void unit_m4(float m[4][4])
Definition: rct.c:1090
void copy_qt_qt(float q[4], const float a[4])
Definition: math_rotation.c:33
MINLINE void copy_v3_v3(float r[3], const float a[3])
void DEG_id_tag_update(struct ID *id, int flag)
@ ID_RECALC_COPY_ON_WRITE
Definition: DNA_ID.h:834
@ ID_RECALC_GEOMETRY
Definition: DNA_ID.h:791
@ ID_AR
Definition: DNA_ID_enums.h:66
@ ID_GD
Definition: DNA_ID_enums.h:71
@ ID_CU_LEGACY
Definition: DNA_ID_enums.h:49
@ ID_ME
Definition: DNA_ID_enums.h:48
@ ID_MB
Definition: DNA_ID_enums.h:50
@ ID_LT
Definition: DNA_ID_enums.h:54
Object groups, one object can be in many groups at once.
Object is a sort of wrapper for general info.
@ OB_FONT
void EDBM_update(struct Mesh *me, const struct EDBMUpdate_Params *params)
Read Guarded memory(de)allocation.
void ED_armature_edit_transform(bArmature *arm, const float mat[4][4], const bool do_props)
Definition: armature_edit.c:53
ATTR_WARN_UNUSED_RESULT BMesh * bm
void BM_mesh_vert_coords_apply_with_mat4(BMesh *bm, const float(*vert_coords)[3], const float mat[4][4])
Definition: bmesh_mesh.cc:1338
void BM_mesh_vert_coords_apply(BMesh *bm, const float(*vert_coords)[3])
Definition: bmesh_mesh.cc:1328
void BM_mesh_vert_coords_get(BMesh *bm, float(*vert_coords)[3])
Definition: bmesh_mesh.cc:1310
#define GS(x)
Definition: iris.c:225
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
static const struct ElemData_Armature * armature_coords_and_quats_apply_with_mat4_recurse(ListBase *bone_base, const struct ElemData_Armature *elem_array, const float mat[4][4])
static void metaball_coords_and_quats_apply(MetaBall *mb, const struct ElemData_MetaBall *elem_array)
struct XFormObjectData * ED_object_data_xform_create_ex(ID *id, bool is_edit_mode)
static void metaball_coords_and_quats_apply_with_mat4(MetaBall *mb, const struct ElemData_MetaBall *elem_array, const float mat[4][4])
void ED_object_data_xform_restore(struct XFormObjectData *xod_base)
static void edit_armature_coords_and_quats_apply_with_mat4(bArmature *arm, const struct ElemData_Armature *elem_array, const float mat[4][4])
void ED_object_data_xform_tag_update(struct XFormObjectData *xod_base)
#define COPY_PTR(member)
struct XFormObjectData * ED_object_data_xform_create(ID *id)
static void edit_armature_coords_and_quats_get(const bArmature *arm, struct ElemData_Armature *elem_array)
static void metaball_coords_and_quats_get(const MetaBall *mb, struct ElemData_MetaBall *elem_array)
struct XFormObjectData * ED_object_data_xform_create_from_edit_mode(ID *id)
void ED_object_data_xform_destroy(struct XFormObjectData *xod_base)
static void armature_coords_and_quats_apply(bArmature *arm, const struct ElemData_Armature *elem_array)
#define COPY_VAL(member)
static void edit_armature_coords_and_quats_apply(bArmature *arm, const struct ElemData_Armature *elem_array)
static void armature_coords_and_quats_apply_with_mat4(bArmature *arm, const struct ElemData_Armature *elem_array, const float mat[4][4])
static struct ElemData_Armature * armature_coords_and_quats_get_recurse(const ListBase *bone_base, struct ElemData_Armature *elem_array)
void ED_object_data_xform_by_mat4(struct XFormObjectData *xod_base, const float mat[4][4])
static void armature_coords_and_quats_get(const bArmature *arm, struct ElemData_Armature *elem_array)
struct BMesh * bm
Definition: BKE_editmesh.h:40
int totvert
Definition: bmesh_class.h:297
struct Key * key
EditNurb * editnurb
ListBase nurb
struct Lattice * latt
ListBase nurbs
Definition: DNA_ID.h:368
char name[66]
Definition: DNA_ID.h:378
struct Key * key
struct EditLatt * editlatt
void * first
Definition: DNA_listBase.h:31
struct BMEditMesh * edit_mesh
int totvert
struct Key * key
ListBase elems
struct ElemData_Armature elem_array[0]
struct XFormObjectData base
struct XFormObjectData base
struct XFormObjectData base
struct GPencilPointCoordinates elem_array[0]
struct XFormObjectData base
struct XFormObjectData base
struct XFormObjectData base
struct ElemData_MetaBall elem_array[0]
ListBase bonebase
ListBase * edbo