BKE_key.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include <optional>
#include <string>
 
#include "BLI_array.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_span.hh"
 
#include "DNA_key_types.h"

struct Curve;
struct ID;
struct Key;
struct KeyBlock;
struct Lattice;
struct ListBase;
struct Main;
struct Mesh;
struct Object;
 
void BKE_key_free_nolib(Key *key);
Key *BKE_key_add(Main *bmain, ID *id);
void BKE_key_sort(Key *key);
 
void key_curve_position_weights(float t, float data[4], KeyInterpolationType type);
void key_curve_tangent_weights(float t, float data[4], KeyInterpolationType type);
void key_curve_normal_weights(float t, float data[4], KeyInterpolationType type);

float *BKE_key_evaluate_object_ex(
    Object *ob, int *r_totelem, float *arr, size_t arr_size, ID *obdata);
float *BKE_key_evaluate_object(Object *ob, int *r_totelem);

int BKE_keyblock_element_count_from_shape(const Key *key, int shape_index);
int BKE_keyblock_element_count(const Key *key);

size_t BKE_keyblock_element_calc_size_from_shape(const Key *key, int shape_index);
size_t BKE_keyblock_element_calc_size(const Key *key);
 
bool BKE_key_idtype_support(short id_type);
 
Key **BKE_key_from_id_p(ID *id);
Key *BKE_key_from_id(ID *id);
Key **BKE_key_from_object_p(Object *ob);
Key *BKE_key_from_object(Object *ob);
KeyBlock *BKE_keyblock_from_object(Object *ob);
KeyBlock *BKE_keyblock_from_object_reference(Object *ob);
 
KeyBlock *BKE_keyblock_add(Key *key, const char *name);

KeyBlock *BKE_keyblock_duplicate(Key *key, KeyBlock *kb_src);

KeyBlock *BKE_keyblock_add_ctime(Key *key, const char *name, bool do_force);
KeyBlock *BKE_keyblock_find_by_index(Key *key, int index);
KeyBlock *BKE_keyblock_find_name(Key *key, const char name[]);
 
KeyBlock *BKE_keyblock_find_uid(Key *key, int uid);

void BKE_keyblock_copy_settings(KeyBlock *kb_dst, const KeyBlock *kb_src);
std::optional<std::string> BKE_keyblock_curval_rnapath_get(const Key *key, const KeyBlock *kb);
 
/* conversion functions */
/* NOTE: 'update_from' versions do not (re)allocate mem in kb, while 'convert_from' do. */
 
void BKE_keyblock_update_from_lattice(const Lattice *lt, KeyBlock *kb);
void BKE_keyblock_convert_from_lattice(const Lattice *lt, KeyBlock *kb);
void BKE_keyblock_convert_to_lattice(const KeyBlock *kb, Lattice *lt);
 
int BKE_keyblock_curve_element_count(const ListBase *nurb);
void BKE_keyblock_curve_data_transform(const ListBase *nurb,
                                       const float mat[4][4],
                                       const void *src,
                                       void *dst);
void BKE_keyblock_update_from_curve(const Curve *cu, KeyBlock *kb, const ListBase *nurb);
void BKE_keyblock_convert_from_curve(const Curve *cu, KeyBlock *kb, const ListBase *nurb);
void BKE_keyblock_convert_to_curve(KeyBlock *kb, Curve *cu, ListBase *nurb);
 
void BKE_keyblock_update_from_mesh(const Mesh *mesh, KeyBlock *kb);
void BKE_keyblock_convert_from_mesh(const Mesh *mesh, const Key *key, KeyBlock *kb);
void BKE_keyblock_convert_to_mesh(const KeyBlock *kb,
                                  blender::MutableSpan<blender::float3> vert_positions);

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]);
 
/* other management */

bool BKE_keyblock_move(Object *ob, int org_index, int new_index);

bool BKE_keyblock_is_basis(const Key *key, int index);

std::optional<blender::Array<bool>> BKE_keyblock_get_dependent_keys(const Key *key, int index);
 
/* -------------------------------------------------------------------- */

void BKE_keyblock_data_get_from_shape(const Key *key,
                                      blender::MutableSpan<blender::float3> arr,
                                      int shape_index);
void BKE_keyblock_data_get(const Key *key, blender::MutableSpan<blender::float3> arr);

void BKE_keyblock_data_set_with_mat4(Key *key,
                                     int shape_index,
                                     blender::Span<blender::float3> coords,
                                     const blender::float4x4 &transform);
void BKE_keyblock_curve_data_set_with_mat4(Key *key,
                                           const ListBase *nurb,
                                           int shape_index,
                                           const void *data,
                                           const blender::float4x4 &transform);
void BKE_keyblock_data_set(Key *key, int shape_index, const void *data);