29#define DNA_DEPRECATED_ALLOW
58#include "RNA_prototypes.hh"
65 std::optional<Library *> ,
70 Key *key_dst = id_cast<Key *>(id_dst);
71 const Key *key_src = id_cast<const Key *>(id_src);
75 for (kb_src = key_src->
block.first(), kb_dst = key_dst->
block.first(); kb_dst;
76 kb_src = kb_src->
next, kb_dst = kb_dst->
next)
81 if (kb_src == key_src->
refkey) {
89 Key *key = id_cast<Key *>(
id);
100 Key *key =
reinterpret_cast<Key *
>(
id);
106 Key *key = id_cast<Key *>(
id);
108 if (debug_relationship_assert) {
118 Key *key = id_cast<Key *>(
id);
119 const bool is_undo = writer->
is_undo();
136 if (kb.
data !=
nullptr) {
145#define IPO_BEZTRIPLE 100
146#define IPO_BPOINT 101
150 Key *key = id_cast<Key *>(
id);
174 .id_code = Key::id_type,
179 .struct_size =
sizeof(
Key),
181 .name_plural =
N_(
"shape_keys"),
184 .asset_type_info =
nullptr,
186 .init_data =
nullptr,
189 .make_local =
nullptr,
191 .foreach_cache =
nullptr,
192 .foreach_path =
nullptr,
193 .foreach_working_space_color =
nullptr,
194 .foreach_asset_weak_reference =
nullptr,
203 .blend_read_undo_preserve =
nullptr,
205 .lib_override_apply_post =
nullptr,
208#define KEY_MODE_DUMMY 0
209#define KEY_MODE_BPOINT 1
210#define KEY_MODE_BEZTRIPLE 2
240 switch (
GS(
id->name)) {
284 for (kb = key->
block.first(); kb; kb = kb->
next) {
326 data[0] = -fc * t3 + 2.0f * fc * t2 - fc * t;
327 data[1] = (2.0f - fc) * t3 + (fc - 3.0f) * t2 + 1.0f;
328 data[2] = (fc - 2.0f) * t3 + (3.0f - 2.0f * fc) * t2 + fc * t;
329 data[3] = fc * t3 - fc * t2;
335 data[0] = -0.16666666f * t3 + 0.5f * t2 - 0.5f * t + 0.16666666f;
336 data[1] = 0.5f * t3 - t2 + 0.66666666f;
337 data[2] = -0.5f * t3 + 0.5f * t2 + 0.5f * t + 0.16666666f;
338 data[3] = 0.16666666f * t3;
345 data[0] = -fc * t3 + 2.0f * fc * t2 - fc * t;
346 data[1] = (2.0f - fc) * t3 + (fc - 3.0f) * t2 + 1.0f;
347 data[2] = (fc - 2.0f) * t3 + (3.0f - 2.0f * fc) * t2 + fc * t;
348 data[3] = fc * t3 - fc * t2;
368 data[0] = -3.0f * fc * t2 + 4.0f * fc * t - fc;
369 data[1] = 3.0f * (2.0f - fc) * t2 + 2.0f * (fc - 3.0f) * t;
370 data[2] = 3.0f * (fc - 2.0f) * t2 + 2.0f * (3.0f - 2.0f * fc) * t + fc;
371 data[3] = 3.0f * fc * t2 - 2.0f * fc * t;
376 data[0] = -0.5f * t2 + t - 0.5f;
377 data[1] = 1.5f * t2 - t * 2.0f;
378 data[2] = -1.5f * t2 + t + 0.5f;
385 data[0] = -3.0f * fc * t2 + 4.0f * fc * t - fc;
386 data[1] = 3.0f * (2.0f - fc) * t2 + 2.0f * (fc - 3.0f) * t;
387 data[2] = 3.0f * (fc - 2.0f) * t2 + 2.0f * (3.0f - 2.0f * fc) * t + fc;
388 data[3] = 3.0f * fc * t2 - 2.0f * fc * t;
407 data[0] = -6.0f * fc * t + 4.0f * fc;
408 data[1] = 6.0f * (2.0f - fc) * t + 2.0f * (fc - 3.0f);
409 data[2] = 6.0f * (fc - 2.0f) * t + 2.0f * (3.0f - 2.0f * fc);
410 data[3] = 6.0f * fc * t - 2.0f * fc;
413 data[0] = -1.0f * t + 1.0f;
414 data[1] = 3.0f * t - 2.0f;
415 data[2] = -3.0f * t + 1.0f;
421 data[0] = -6.0f * fc * t + 4.0f * fc;
422 data[1] = 6.0f * (2.0f - fc) * t + 2.0f * (fc - 3.0f);
423 data[2] = 6.0f * (fc - 2.0f) * t + 2.0f * (3.0f - 2.0f * fc);
424 data[3] = 6.0f * fc * t - 2.0f * fc;
440 const ListBaseT<KeyBlock> *keyblocks,
444 KeyBlock *firstkey = keyblocks->first();
445 KeyBlock *lastkey = keyblocks->last();
448 r_target_keys[0] = r_target_keys[1] = r_target_keys[2] = r_target_keys[3] = firstkey;
449 r_weights[0] = r_weights[1] = r_weights[2] = r_weights[3] = firstkey->
pos;
451 if (firstkey->
next ==
nullptr) {
456 r_target_keys[2] = firstkey->
next;
457 r_weights[2] = r_target_keys[2]->
pos;
458 r_target_keys[3] = r_target_keys[2]->
next;
459 if (r_target_keys[3] ==
nullptr) {
460 r_target_keys[3] = r_target_keys[2];
462 r_weights[3] = r_target_keys[3]->
pos;
463 KeyBlock *key_iter = r_target_keys[3];
466 while (r_weights[2] < eval_time) {
467 if (key_iter->
next ==
nullptr) {
469 if (r_weights[2] == r_weights[3]) {
474 key_iter = key_iter->
next;
477 r_weights[0] = r_weights[1];
478 r_target_keys[0] = r_target_keys[1];
479 r_weights[1] = r_weights[2];
480 r_target_keys[1] = r_target_keys[2];
481 r_weights[2] = r_weights[3];
482 r_target_keys[2] = r_target_keys[3];
483 r_weights[3] = key_iter->
pos;
484 r_target_keys[3] = key_iter;
487 bool bsplinetype =
false;
492 if (bsplinetype ==
false) {
493 if (eval_time <= r_weights[1]) {
495 r_weights[2] = r_weights[1];
496 r_target_keys[2] = r_target_keys[1];
499 if (eval_time >= r_weights[2]) {
503 else if (eval_time > r_weights[2]) {
504 eval_time = r_weights[2];
505 r_target_keys[3] = r_target_keys[2];
506 r_weights[3] = r_weights[2];
509 float delta = r_weights[2] - r_weights[1];
511 if (bsplinetype ==
false) {
516 delta = (eval_time - r_weights[1]) / delta;
522 if (r_target_keys[1]->type != r_target_keys[2]->type) {
553 *freedata =
reinterpret_cast<char *
>(co);
554 return reinterpret_cast<char *
>(co);
560 return static_cast<char *
>(kb->
data);
570 const int start_index,
const float weight,
const float *a,
const float *
b,
float *r_target)
572 r_target[start_index + 0] += weight * (
b[start_index + 0] - a[start_index + 0]);
573 r_target[start_index + 1] += weight * (
b[start_index + 1] - a[start_index + 1]);
574 r_target[start_index + 2] += weight * (
b[start_index + 2] - a[start_index + 2]);
584 const float weights[4],
587 r_out[0] = weights[0] * f0[0] + weights[1] * f1[0] + weights[2] * f2[0] + weights[3] * f3[0];
588 r_out[1] = weights[0] * f0[1] + weights[1] * f1[1] + weights[2] * f2[1] + weights[3] * f3[1];
589 r_out[2] = weights[0] * f0[2] + weights[1] * f1[2] + weights[2] * f2[2] + weights[3] * f3[2];
596 const int vertex_count,
Key *key,
KeyBlock *active_keyblock,
KeyBlock *source,
float *r_target)
598 if (vertex_count == 0 || source->
totelem == 0) {
601 char *free_keyblock_data;
602 float *keyblock_data =
reinterpret_cast<float *
>(
605 if (vertex_count == source->
totelem) {
606 memcpy(r_target, keyblock_data, vertex_count * 3 *
sizeof(
float));
612 const float step_rate = source->
totelem /
float(vertex_count);
613 for (
int i = 0; i < vertex_count; i++) {
615 const int source_index = int(step_rate * i);
616 memcpy(&r_target[i * 3], &keyblock_data[source_index * 3], 3 *
sizeof(
float));
620 if (free_keyblock_data) {
621 MEM_delete(free_keyblock_data);
637 const float *weights,
645 if (vertex_count != source->
totelem) {
652 char *free_source_data, *free_refkey_data;
653 const float *source_data =
reinterpret_cast<float *
>(
655 const float *refkey_data =
reinterpret_cast<float *
>(
658 for (
int i = 0; i < vertex_count; i++) {
659 const int vector_index = i * 3;
660 memcpy(&r_target[vector_index], &refkey_data[vector_index], 3 *
sizeof(
float));
661 if (weights[i] != 0.0f) {
666 if (free_source_data) {
667 MEM_delete(free_source_data);
669 if (free_refkey_data) {
670 MEM_delete(free_refkey_data);
683 const std::optional<
Span<bool>> keys_to_process,
684 const int vertex_count,
685 float **per_keyblock_weights,
693 for (std::pair<int, KeyBlock &> enumerator : key->
block.enumerate()) {
698 if (keys_to_process && !(*keys_to_process)[enumerator.first]) {
705 const float kb_influence = kb.
curval;
706 if (kb_influence == 0.0f) {
711 if (reference_kb ==
nullptr) {
715 const float *weights = per_keyblock_weights ? per_keyblock_weights[enumerator.first] :
nullptr;
717 char *freefrom =
nullptr;
718 const float *from =
reinterpret_cast<float *
>(
723 const float *reffrom =
static_cast<float *
>(reference_kb->
data);
725 for (
const int i : range) {
726 const float weight = weights ? (weights[i] * kb.
curval) : kb.
curval;
728 const int vector_index = i * 3;
734 MEM_delete(freefrom);
746 const float weights[4],
749 char *freek1, *freek2, *freek3, *freek4;
750 float *k1 =
reinterpret_cast<float *
>(
752 float *k2 =
reinterpret_cast<float *
>(
754 float *k3 =
reinterpret_cast<float *
>(
756 float *k4 =
reinterpret_cast<float *
>(
761 const float step_k1 = shapekeys[0]->
totelem /
float(vertex_count);
762 const float step_k2 = shapekeys[1]->
totelem /
float(vertex_count);
763 const float step_k3 = shapekeys[2]->
totelem /
float(vertex_count);
764 const float step_k4 = shapekeys[3]->
totelem /
float(vertex_count);
767 for (
const int i : range) {
768 flerp(&k1[
int(i * step_k1) * 3],
769 &k2[
int(i * step_k2) * 3],
770 &k3[
int(i * step_k3) * 3],
771 &k4[
int(i * step_k4) * 3],
794 if (vgroup[0] == 0) {
805 dvert =
mesh->deform_verts().data();
806 totvert =
mesh->verts_num;
809 if (bm_test && bm_test->
totvert == totvert) {
819 if (dvert ==
nullptr) {
825 if (defgrp_index != -1) {
832 "cached defgroup weights");
854 for (
int i = 0; i < totvert; i++, dvert++) {
871 "per keyblock weights");
873 for (
const auto [keyblock_index, keyblock] : key->
block.enumerate()) {
874 per_keyblock_weights[keyblock_index] =
get_weights_array(ob, keyblock.vgroup, cache);
877 return per_keyblock_weights;
881 float **per_keyblock_weights,
896 for (
int a = 0; a < key->
totkey; a++) {
897 if (per_keyblock_weights[a]) {
898 MEM_delete(per_keyblock_weights[a]);
903 MEM_delete(per_keyblock_weights);
908 const std::optional<
Span<bool>> keys_to_process,
916 float **per_keyblock_weights;
919 key, actkb, keys_to_process, tot, per_keyblock_weights,
reinterpret_cast<float *
>(
out));
923 const float ctime_scaled = key->
ctime / 100.0f;
927 ctime_scaled, &key->
block, shapekeys, weights);
929 if (simple_copy ==
false) {
940 const std::optional<
Span<bool>> keys_to_process,
948 key, actkb, keys_to_process, tot,
nullptr,
reinterpret_cast<float *
>(
out));
951 const float ctime_scaled = key->
ctime / 100.0f;
955 ctime_scaled, &key->
block, shapekeys, weights);
957 if (simple_copy ==
false) {
968 const std::optional<
Span<bool>> keys_to_process,
976 float **per_keyblock_weights;
979 key, actkb, keys_to_process, tot, per_keyblock_weights,
reinterpret_cast<float *
>(
out));
983 const float ctime_scaled = key->
ctime / 100.0f;
987 ctime_scaled, &key->
block, shapekeys, weights);
989 if (simple_copy ==
false) {
1004 const int totpoint);
1006 ListBaseT<Nurb> *nurb,
1007 const int totpoint);
1013 const std::optional<
Span<bool>> keys_to_process,
1019 if (key ==
nullptr || key->
block.is_empty()) {
1024 int tot = 0, size = 0;
1028 tot =
mesh->verts_num;
1045 if (tot == 0 || size == 0) {
1051 if (arr ==
nullptr) {
1055 if (arr_size != size) {
1059 out =
reinterpret_cast<char *
>(arr);
1070 if (kb ==
nullptr) {
1071 kb = key->
block.first();
1080 MEM_delete(weights);
1102 if (obdata !=
nullptr) {
1103 switch (
GS(obdata->
name)) {
1105 Mesh *
mesh = id_cast<Mesh *>(obdata);
1106 const int totvert =
min_ii(tot,
mesh->verts_num);
1107 mesh->vert_positions_for_write().take_front(totvert).copy_from(
1108 {
reinterpret_cast<const float3 *
>(
out), totvert});
1109 mesh->tag_positions_changed();
1113 Lattice *lattice = id_cast<Lattice *>(obdata);
1116 reinterpret_cast<const float (*)[3]
>(
out), lattice->
def, totpoint);
1120 Curve *curve = id_cast<Curve *>(obdata);
1123 reinterpret_cast<const float *
>(
out), &curve->
nurb, totpoint);
1134 return reinterpret_cast<float *
>(
out);
1146 for (
const auto [
index, kb] : key->
block.enumerate()) {
1178 const int shape_index)
1182 for (
const auto [
index, kb] : key->
block.enumerate()) {
1184 const int block_elem_len = kb.totelem * key->
elemsize;
1185 memcpy(elements, kb.data, block_elem_len);
1186 elements += block_elem_len;
1197 const int shape_index,
1201 if (key->
elemsize !=
sizeof(
float[3])) {
1208 for (
const auto [
index, kb] : key->
block.enumerate()) {
1210 const int block_elem_len = kb.totelem;
1211 float (*block_data)[3] =
static_cast<float (*)[3]
>(kb.data);
1212 for (
int data_offset = 0; data_offset < block_elem_len; ++data_offset) {
1213 const float *src_data =
reinterpret_cast<const float *
>(elements + data_offset);
1214 float *dst_data =
reinterpret_cast<float *
>(block_data + data_offset);
1217 elements += block_elem_len;
1223 const ListBaseT<Nurb> *nurb,
1224 const int shape_index,
1230 for (
const auto [
index, kb] : key->
block.enumerate()) {
1232 const int block_elem_size = kb.totelem * key->
elemsize;
1234 elements += block_elem_size;
1243 for (
const auto [
index, kb] : key->
block.enumerate()) {
1245 const int block_elem_size = kb.totelem * key->
elemsize;
1246 memcpy(kb.data, elements, block_elem_size);
1247 elements += block_elem_size;
1268 switch (
GS(
id->name)) {
1274 Curve *cu = id_cast<Curve *>(
id);
1281 Lattice *lt = id_cast<Lattice *>(
id);
1304 if (ob ==
nullptr || ob->
data ==
nullptr) {
1324 float curpos = -0.1;
1331 kb = MEM_new<KeyBlock>(
"Keyblock");
1335 const int tot = key->
block.count();
1362 kb->
pos = curpos + 0.1f;
1383 const float cpos = key->
ctime / 100.0f;
1442 if (kb.
uid == uid) {
1451 kb_dst->
pos = kb_src->
pos;
1462 if (
ELEM(
nullptr, key, kb)) {
1463 return std::nullopt;
1466 const_cast<ID *
>(&key->
id), RNA_ShapeKey, (
KeyBlock *)kb);
1487 fp =
static_cast<float (*)[3]
>(kb->
data);
1488 for (
int a = 0; a < kb->
totelem; a++, fp++, bp++) {
1500 MEM_SAFE_DELETE_VOID(kb->
data);
1512 for (
int i = 0; i < totpoint; i++, fp++, bpoint++) {
1520 const float (*fp)[3] =
static_cast<const float (*)[3]
>(kb->
data);
1549 const ListBaseT<Nurb> *nurb)
1561 float *fp =
static_cast<float *
>(kb->
data);
1562 for (
Nurb &nu : *nurb) {
1564 for (a = nu.pntsu, bezt = nu.bezt; a; a--, bezt++) {
1565 for (
int i = 0; i < 3; i++) {
1574 for (a = nu.pntsu * nu.pntsv, bp = nu.bp; a; a--, bp++) {
1585 const float mat[4][4],
1586 const void *src_data,
1589 const float *src =
static_cast<const float *
>(src_data);
1590 float *dst =
static_cast<float *
>(dst_data);
1591 for (
Nurb &nu : *nurb) {
1593 for (
int a = nu.pntsu; a; a--) {
1594 for (
int i = 0; i < 3; i++) {
1604 for (
int a = nu.pntsu * nu.pntsv; a; a--) {
1622 MEM_SAFE_DELETE_VOID(kb->
data);
1632 for (
Nurb *nu = nurb->first(); nu && totpoint > 0; nu = nu->
next) {
1633 if (nu->bezt !=
nullptr) {
1638 for (
int j = 0; j < 3; j++) {
1660 const float *fp =
static_cast<const float *
>(kb->
data);
1672 const int tot =
mesh->verts_num;
1678 memcpy(kb->
data, positions.
data(),
sizeof(
float[3]) * tot);
1683 const int len =
mesh->verts_num;
1685 if (
mesh->verts_num == 0) {
1689 MEM_SAFE_DELETE_VOID(kb->
data);
1704 float (*r_vert_normals)[3],
1705 float (*r_face_normals)[3],
1706 float (*r_loop_normals)[3])
1709 if (r_vert_normals ==
nullptr && r_face_normals ==
nullptr && r_loop_normals ==
nullptr) {
1719 const bool loop_normals_needed = r_loop_normals !=
nullptr;
1720 const bool vert_normals_needed = r_vert_normals !=
nullptr;
1721 const bool face_normals_needed = r_face_normals !=
nullptr || vert_normals_needed ||
1722 loop_normals_needed;
1724 float (*vert_normals)[3] = r_vert_normals;
1725 float (*face_normals)[3] = r_face_normals;
1726 bool free_vert_normals =
false;
1727 bool free_face_normals =
false;
1728 if (vert_normals_needed && r_vert_normals ==
nullptr) {
1730 free_vert_normals =
true;
1732 if (face_normals_needed && r_face_normals ==
nullptr) {
1734 free_face_normals =
true;
1737 if (face_normals_needed) {
1739 positions, faces, corner_verts, {
reinterpret_cast<float3 *
>(face_normals), faces.
size()});
1741 if (vert_normals_needed) {
1745 mesh->vert_to_face_map(),
1746 {reinterpret_cast<const float3 *>(face_normals), faces.size()},
1747 {reinterpret_cast<float3 *>(vert_normals), mesh->verts_num});
1749 if (loop_normals_needed) {
1759 mesh->vert_to_face_map(),
1760 {reinterpret_cast<float3 *>(face_normals), faces.size()},
1765 {reinterpret_cast<float3 *>(r_loop_normals), corner_verts.size()});
1768 if (free_vert_normals) {
1769 MEM_delete(vert_normals);
1771 if (free_face_normals) {
1772 MEM_delete(face_normals);
1782 const int act_index = ob->
shapenr - 1;
1783 const int totkey = key->
totkey;
1785 bool rev, in_range =
false;
1787 if (org_index < 0) {
1788 org_index = act_index;
1794 if (new_index == org_index) {
1798 rev = ((new_index - org_index) < 0) ?
true :
false;
1804 i = (rev ? totkey - 1 : 0);
1806 kb = (rev ? kb->
prev : kb->
next), rev ? i-- : i++)
1808 if (i == org_index) {
1811 else if (i == new_index) {
1822 std::swap(kb->
pos, other_kb->
pos);
1843 if (org_index == act_index) {
1846 else if (act_index < org_index && act_index >= new_index) {
1849 else if (act_index > org_index && act_index <= new_index) {
1865 for (i = 0, kb = key->
block.first(); kb; i++, kb = kb->
next) {
1878 return std::nullopt;
1881 const int count = key->
block.count();
1883 if (index < 0 || index >= count) {
1884 return std::nullopt;
1890 marked[
index] =
true;
1894 bool updated, found =
false;
1899 for (
const auto [i, kb] : key->
block.enumerate()) {
1902 updated = found =
true;
1908 return std::nullopt;
1912 marked[
index] =
false;
1918 char oldname[
sizeof(kb->
name)];
CustomData interface, see also DNA_customdata_types.h.
#define BKE_LIB_FOREACHID_PROCESS_ID(data_, id_, cb_flag_)
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define BLO_read_struct_list(reader, struct_name, list)
#define BLO_read_struct(reader, struct_name, ptr_p)
#define BLT_I18NCONTEXT_ID_SHAPEKEY
#define CTX_DATA_(context, msgid)
ID and Library types, which are fundamental for SDNA.
#define ID_IS_PACKED(_id)
#define FILTER_ID_CU_LEGACY
#define ID_IS_OVERRIDE_LIBRARY(_id)
#define KEYELEM_FLOAT_LEN_COORD
#define KEYELEM_ELEM_LEN_BPOINT
#define KEYELEM_FLOAT_LEN_BEZTRIPLE
#define KEYELEM_ELEM_SIZE_CURVE
#define KEYELEM_FLOAT_LEN_BPOINT
#define KEYELEM_ELEM_LEN_BEZTRIPLE
Object is a sort of wrapper for general info.
#define OB_TYPE_SUPPORT_VGROUP(_type)
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_INDEX(ele, iter, bm, itype, indexvar)
constexpr IndexRange()=default
constexpr T * data() const
constexpr MutableSpan take_front(const int64_t n) const
constexpr const T * data() const
GAttributeReader lookup(const StringRef name) const
constexpr void copy_from(Span< T > values) const
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
void normals_calc_corners(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, Span< int > corner_edges, GroupedSpan< int > vert_to_face_map, Span< float3 > face_normals, Span< bool > sharp_edges, Span< bool > sharp_faces, Span< short2 > custom_normals, CornerNormalSpaceArray *r_fan_spaces, MutableSpan< float3 > r_corner_normals)
void normals_calc_verts(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, GroupedSpan< int > vert_to_face_map, Span< float3 > face_normals, MutableSpan< float3 > vert_normals)
void normals_calc_faces(Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, MutableSpan< float3 > face_normals)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
int CustomData_get_offset(const CustomData *data, eCustomDataType type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_keyblock_data_set_with_mat4(Key *key, int shape_index, Span< float3 > coords, const float4x4 &transform)
void BKE_keyblock_update_from_lattice(const Lattice *lt, KeyBlock *kb)
static float ** keyblock_get_per_block_weights(Object *ob, Key *key, WeightsArrayCache *cache)
static void flerp(const float f0[3], const float f1[3], const float f2[3], const float f3[3], const float weights[4], float r_out[3])
void BKE_keyblock_data_get_from_shape(const Key *key, MutableSpan< float3 > arr, int shape_index)
KeyBlock * BKE_keyblock_duplicate(Key *key, KeyBlock *kb_src)
char * STRNCPY(char(&dst)[N], const char *src)
static void keyblock_data_convert_to_curve(const float *fp, ListBaseT< Nurb > *nurb, const int totpoint)
Key ** BKE_key_from_object_p(Object *ob)
bool BKE_key_idtype_support(short id_type)
static void do_curve_key(Object *ob, Key *key, const std::optional< Span< bool > > keys_to_process, char *out, const int tot)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
int BKE_object_defgroup_count(const Object *ob)
bool BKE_keyblock_move(Object *ob, int org_index, int new_index)
std::optional< std::string > RNA_path_from_ID_to_property(const PointerRNA *ptr, PropertyRNA *prop)
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
void BKE_keyblock_curve_data_transform(const ListBaseT< Nurb > *nurb, const float mat[4][4], const void *src, void *dst)
static float * get_weights_array(Object *ob, const char *vgroup, WeightsArrayCache *cache)
void interp_v4_v4v4(float r[4], const float a[4], const float b[4], float t)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
bool BKE_keyblock_is_basis(const Key *key, int index)
void BKE_keyblock_convert_to_mesh(const KeyBlock *kb, MutableSpan< float3 > vert_positions)
int BKE_keyblock_element_count_from_shape(const Key *key, int shape_index)
void BKE_keyblock_update_from_mesh(const Mesh *mesh, KeyBlock *kb)
void BKE_key_sort(Key *key)
void BKE_keyblock_curve_data_set_with_mat4(Key *key, const ListBaseT< Nurb > *nurb, int shape_index, const void *data, const float4x4 &transform)
KeyBlock * BKE_keyblock_from_object(Object *ob)
std::string RNA_path_name_to_infix(const StringRefNull string)
void BKE_keyblock_convert_to_curve(KeyBlock *kb, Curve *cu, ListBaseT< Nurb > *nurb)
static void key_evaluate_relative_float3(Key *key, KeyBlock *active_keyblock, const std::optional< Span< bool > > keys_to_process, const int vertex_count, float **per_keyblock_weights, float *target_data)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
static void shapekey_blend_write(BlendWriter *writer, ID *id, const void *id_address)
float * BKE_key_evaluate_object_ex(Object *ob, int *r_totelem, float *arr, size_t arr_size, std::optional< Span< bool > > keys_to_process, ID *obdata)
static void shapekey_foreach_id(ID *id, LibraryForeachIDData *data)
KeyBlock * BKE_keyblock_from_object_reference(Object *ob)
KeyBlock * BKE_keyblock_find_name(Key *key, const char name[])
static ID ** shapekey_owner_pointer_get(ID *id, const bool debug_relationship_assert)
MatBase< float, 4, 4 > float4x4
void key_curve_normal_weights(float t, float data[4], KeyInterpolationType type)
void BKE_keyblock_rename(Main &bmain, Key *key, KeyBlock *kb, const char *newname)
static char * key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **freedata)
void BKE_id_blend_write(BlendWriter *writer, ID *id)
void MEM_delete_void(void *vmemh)
std::optional< Array< bool > > BKE_keyblock_get_dependent_keys(const Key *key, int index)
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
void BKE_animdata_fix_paths(ID &id, StringRef prefix, StringRef old_infix, StringRef new_infix, bool verify_paths, const DriverMap &driver_map)
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
KeyBlock * BKE_keyblock_find_by_index(Key *key, int index)
void BLI_uniquename(const ListBase *list, void *vlink, const char *defname, char delim, int name_offset, size_t name_maxncpy) ATTR_NONNULL(1
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Key * BKE_key_from_id(ID *id)
KeyBlock * BKE_keyblock_find_uid(Key *key, int uid)
void * MEM_dupalloc_void(const void *vmemh) ATTR_WARN_UNUSED_RESULT
void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb, Mesh *mesh, float(*r_vert_normals)[3], float(*r_face_normals)[3], float(*r_loop_normals)[3])
Key * BKE_key_add(Main *bmain, ID *id)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
BMesh const char void * data
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
void outside_lattice(Lattice *lt)
Key ** BKE_key_from_id_p(ID *id)
std::optional< std::string > BKE_keyblock_curval_rnapath_get(const Key *key, const KeyBlock *kb)
static void do_latt_key(Object *ob, Key *key, const std::optional< Span< bool > > keys_to_process, char *out, const int tot)
void BLI_listbase_swaplinks(ListBase *listbase, void *vlinka, void *vlinkb) ATTR_NONNULL(1
static bool get_keys_for_absolute_eval(float eval_time, const ListBaseT< KeyBlock > *keyblocks, KeyBlock *r_target_keys[4], float r_weights[4])
int BKE_object_defgroup_name_index(const Object *ob, StringRef name)
static void keyblock_data_convert_to_lattice(const float(*fp)[3], BPoint *bpoint, const int totpoint)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
size_t BKE_keyblock_element_calc_size(const Key *key)
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
void BKE_keyblock_data_get(const Key *key, MutableSpan< float3 > arr)
static void keyblock_free_per_block_weights(Key *key, float **per_keyblock_weights, WeightsArrayCache *cache)
void BKE_keyblock_convert_from_lattice(const Lattice *lt, KeyBlock *kb)
static void copy_key_float3(const int vertex_count, Key *key, KeyBlock *active_keyblock, KeyBlock *source, float *r_target)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_keyblock_data_set(Key *key, int shape_index, const void *data)
int BKE_keyblock_curve_element_count(const ListBaseT< Nurb > *nurb)
VecBase< int16_t, 2 > short2
static void shapekey_blend_read_after_liblink(BlendLibReader *, ID *id)
KeyBlock * BKE_keyblock_add(Key *key, const char *name)
float * BKE_key_evaluate_object(Object *ob, int *r_totelem)
ID_Type GS(const char *name)
static void copy_key_float3_weighted(const int vertex_count, Key *key, KeyBlock *active_keyblock, KeyBlock *source, const float *weights, float *r_target)
static void shapekey_copy_data(Main *, std::optional< Library * >, ID *id_dst, const ID *id_src, const int)
const BMesh * BKE_editmesh_bmesh_get(const Object *ob)
void BKE_keyblock_copy_settings(KeyBlock *kb_dst, const KeyBlock *kb_src)
copy shape-key attributes, but not key data or name/UID.
static void shapekey_free_data(ID *id)
static void add_weighted_vector(const int start_index, const float weight, const float *a, const float *b, float *r_target)
int BKE_keyblock_element_count(const Key *key)
KeyBlock * BKE_keyblock_add_ctime(Key *key, const char *name, bool do_force)
void key_curve_position_weights(float t, float data[4], KeyInterpolationType type)
void BKE_key_free_nolib(Key *key)
size_t BKE_keyblock_element_calc_size_from_shape(const Key *key, int shape_index)
VecBase< float, 3 > float3
Key * BKE_key_from_object(Object *ob)
void BKE_keyblock_convert_to_lattice(const KeyBlock *kb, Lattice *lt)
static void do_mesh_key(Object *ob, Key *key, const std::optional< Span< bool > > keys_to_process, char *out, const int tot)
void BKE_keyblock_convert_from_mesh(const Mesh *mesh, const Key *key, KeyBlock *kb)
MINLINE int min_ii(int a, int b)
void * BKE_id_new(Main *bmain, short type, const char *name)
void BKE_keyblock_update_from_curve(const Curve *cu, KeyBlock *kb, const ListBaseT< Nurb > *nurb)
MINLINE int compare_ff(float a, float b, float max_diff)
void BKE_keyblock_convert_from_curve(const Curve *cu, KeyBlock *kb, const ListBaseT< Nurb > *nurb)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
MINLINE float clamp_f(float value, float min, float max)
static void key_evaluate_absolute(const int vertex_count, Key *key, KeyBlock *active_keyblock, KeyBlock *shapekeys[4], const float weights[4], float *r_target)
static void shapekey_blend_read_data(BlendDataReader *reader, ID *id)
@ IDTYPE_FLAGS_NO_LIBLINKING
void key_curve_tangent_weights(float t, float data[4], KeyInterpolationType type)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
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)
void write_raw(size_t size_in_bytes, const void *data)
KeyInterpolationType type
ListBaseT< KeyBlock > block
ShapekeyContainerType type
struct MDeformVert * dvert
eObject_ShapeFlag shapeflag
float ** defgroup_weights