Mesh Batch Cache: Fix regression with mesh that have poly mat id > mat_len
[blender.git] / source / blender / blenkernel / BKE_armature.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19 #ifndef __BKE_ARMATURE_H__
20 #define __BKE_ARMATURE_H__
21
22 /** \file
23  * \ingroup bke
24  */
25
26 struct Bone;
27 struct Depsgraph;
28 struct GHash;
29 struct ListBase;
30 struct Main;
31 struct Object;
32 struct PoseTree;
33 struct Scene;
34 struct bArmature;
35 struct bConstraint;
36 struct bPose;
37 struct bPoseChannel;
38
39 typedef struct PoseTarget {
40   struct PoseTarget *next, *prev;
41
42   struct bConstraint *con; /* the constraint of this target */
43   int tip;                 /* index of tip pchan in PoseTree */
44 } PoseTarget;
45
46 typedef struct PoseTree {
47   struct PoseTree *next, *prev;
48
49   int type;       /* type of IK that this serves (CONSTRAINT_TYPE_KINEMATIC or ..._SPLINEIK) */
50   int totchannel; /* number of pose channels */
51
52   struct ListBase targets;     /* list of targets of the tree */
53   struct bPoseChannel **pchan; /* array of pose channels */
54   int *parent;                 /* and their parents */
55
56   float (*basis_change)[3][3]; /* basis change result from solver */
57   int iterations;              /* iterations from the constraint */
58   int stretch;                 /* disable stretching */
59 } PoseTree;
60
61 /*  Core armature functionality */
62 #ifdef __cplusplus
63 extern "C" {
64 #endif
65
66 struct bArmature *BKE_armature_add(struct Main *bmain, const char *name);
67 struct bArmature *BKE_armature_from_object(struct Object *ob);
68 int BKE_armature_bonelist_count(struct ListBase *lb);
69 void BKE_armature_bonelist_free(struct ListBase *lb);
70 void BKE_armature_free(struct bArmature *arm);
71 void BKE_armature_make_local(struct Main *bmain, struct bArmature *arm, const bool lib_local);
72 void BKE_armature_copy_data(struct Main *bmain,
73                             struct bArmature *arm_dst,
74                             const struct bArmature *arm_src,
75                             const int flag);
76 struct bArmature *BKE_armature_copy(struct Main *bmain, const struct bArmature *arm);
77
78 void BKE_armature_copy_bone_transforms(struct bArmature *armature_dst,
79                                        const struct bArmature *armature_src);
80
81 /* Bounding box. */
82 struct BoundBox *BKE_armature_boundbox_get(struct Object *ob);
83
84 bool BKE_pose_minmax(
85     struct Object *ob, float r_min[3], float r_max[3], bool use_hidden, bool use_select);
86
87 int bone_autoside_name(char name[64], int strip_number, short axis, float head, float tail);
88
89 struct Bone *BKE_armature_find_bone_name(struct bArmature *arm, const char *name);
90
91 void BKE_armature_bone_hash_make(struct bArmature *arm);
92 void BKE_armature_bone_hash_free(struct bArmature *arm);
93
94 bool BKE_armature_bone_flag_test_recursive(const struct Bone *bone, int flag);
95
96 void BKE_armature_refresh_layer_used(struct bArmature *arm);
97
98 float distfactor_to_bone(
99     const float vec[3], const float b1[3], const float b2[3], float r1, float r2, float rdist);
100
101 void BKE_armature_where_is(struct bArmature *arm);
102 void BKE_armature_where_is_bone(struct Bone *bone,
103                                 struct Bone *prevbone,
104                                 const bool use_recursion);
105 void BKE_pose_clear_pointers(struct bPose *pose);
106 void BKE_pose_remap_bone_pointers(struct bArmature *armature, struct bPose *pose);
107 void BKE_pchan_rebuild_bbone_handles(struct bPose *pose, struct bPoseChannel *pchan);
108 void BKE_pose_rebuild(struct Main *bmain,
109                       struct Object *ob,
110                       struct bArmature *arm,
111                       const bool do_id_user);
112 void BKE_pose_where_is(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob);
113 void BKE_pose_where_is_bone(struct Depsgraph *depsgraph,
114                             struct Scene *scene,
115                             struct Object *ob,
116                             struct bPoseChannel *pchan,
117                             float ctime,
118                             bool do_extra);
119 void BKE_pose_where_is_bone_tail(struct bPoseChannel *pchan);
120
121 /* get_objectspace_bone_matrix has to be removed still */
122 void get_objectspace_bone_matrix(struct Bone *bone,
123                                  float M_accumulatedMatrix[4][4],
124                                  int root,
125                                  int posed);
126 void vec_roll_to_mat3(const float vec[3], const float roll, float mat[3][3]);
127 void vec_roll_to_mat3_normalized(const float nor[3], const float roll, float mat[3][3]);
128 void mat3_to_vec_roll(const float mat[3][3], float r_vec[3], float *r_roll);
129 void mat3_vec_to_roll(const float mat[3][3], const float vec[3], float *r_roll);
130
131 /* Common Conversions Between Co-ordinate Spaces */
132 void BKE_armature_mat_world_to_pose(struct Object *ob, float inmat[4][4], float outmat[4][4]);
133 void BKE_armature_loc_world_to_pose(struct Object *ob, const float inloc[3], float outloc[3]);
134 void BKE_armature_mat_pose_to_bone(struct bPoseChannel *pchan,
135                                    float inmat[4][4],
136                                    float outmat[4][4]);
137 void BKE_armature_loc_pose_to_bone(struct bPoseChannel *pchan,
138                                    const float inloc[3],
139                                    float outloc[3]);
140 void BKE_armature_mat_bone_to_pose(struct bPoseChannel *pchan,
141                                    float inmat[4][4],
142                                    float outmat[4][4]);
143 void BKE_armature_mat_pose_to_delta(float delta_mat[4][4],
144                                     float pose_mat[4][4],
145                                     float arm_mat[4][4]);
146
147 void BKE_armature_mat_pose_to_bone_ex(struct Depsgraph *depsgraph,
148                                       struct Object *ob,
149                                       struct bPoseChannel *pchan,
150                                       float inmat[4][4],
151                                       float outmat[4][4]);
152
153 void BKE_pchan_mat3_to_rot(struct bPoseChannel *pchan, float mat[3][3], bool use_compat);
154 void BKE_pchan_rot_to_mat3(const struct bPoseChannel *pchan, float mat[3][3]);
155 void BKE_pchan_apply_mat4(struct bPoseChannel *pchan, float mat[4][4], bool use_comat);
156 void BKE_pchan_to_mat4(const struct bPoseChannel *pchan, float chan_mat[4][4]);
157 void BKE_pchan_calc_mat(struct bPoseChannel *pchan);
158
159 /* Simple helper, computes the offset bone matrix. */
160 void BKE_bone_offset_matrix_get(const struct Bone *bone, float offs_bone[4][4]);
161
162 /* Transformation inherited from the parent bone. These matrices apply the effects of
163  * HINGE/NO_SCALE/NO_LOCAL_LOCATION options over the pchan loc/rot/scale transformations. */
164 typedef struct BoneParentTransform {
165   float rotscale_mat[4][4]; /* parent effect on rotation & scale pose channels */
166   float loc_mat[4][4];      /* parent effect on location pose channel */
167 } BoneParentTransform;
168
169 /* Matrix-like algebra operations on the transform */
170 void BKE_bone_parent_transform_clear(struct BoneParentTransform *bpt);
171 void BKE_bone_parent_transform_invert(struct BoneParentTransform *bpt);
172 void BKE_bone_parent_transform_combine(const struct BoneParentTransform *in1,
173                                        const struct BoneParentTransform *in2,
174                                        struct BoneParentTransform *result);
175
176 void BKE_bone_parent_transform_apply(const struct BoneParentTransform *bpt,
177                                      const float inmat[4][4],
178                                      float outmat[4][4]);
179
180 /* Get the current parent transformation for the given pose bone. */
181 void BKE_bone_parent_transform_calc_from_pchan(const struct bPoseChannel *pchan,
182                                                struct BoneParentTransform *r_bpt);
183 void BKE_bone_parent_transform_calc_from_matrices(int bone_flag,
184                                                   const float offs_bone[4][4],
185                                                   const float parent_arm_mat[4][4],
186                                                   const float parent_pose_mat[4][4],
187                                                   struct BoneParentTransform *r_bpt);
188
189 /* Rotation Mode Conversions - Used for PoseChannels + Objects... */
190 void BKE_rotMode_change_values(
191     float quat[4], float eul[3], float axis[3], float *angle, short oldMode, short newMode);
192
193 /* B-Bone support */
194 #define MAX_BBONE_SUBDIV 32
195
196 typedef struct Mat4 {
197   float mat[4][4];
198 } Mat4;
199
200 typedef struct BBoneSplineParameters {
201   int segments;
202   float length;
203
204   /* Non-uniform scale correction. */
205   bool do_scale;
206   float scale[3];
207
208   /* Handle control bone data. */
209   bool use_prev, prev_bbone;
210   bool use_next, next_bbone;
211
212   float prev_h[3], next_h[3];
213   float prev_mat[4][4], next_mat[4][4];
214
215   /* Control values. */
216   float ease1, ease2;
217   float roll1, roll2;
218   float scale_in_x, scale_in_y, scale_out_x, scale_out_y;
219   float curve_in_x, curve_in_y, curve_out_x, curve_out_y;
220 } BBoneSplineParameters;
221
222 void BKE_pchan_bbone_handles_get(struct bPoseChannel *pchan,
223                                  struct bPoseChannel **r_prev,
224                                  struct bPoseChannel **r_next);
225 void BKE_pchan_bbone_spline_params_get(struct bPoseChannel *pchan,
226                                        const bool rest,
227                                        struct BBoneSplineParameters *r_param);
228
229 void BKE_pchan_bbone_spline_setup(struct bPoseChannel *pchan,
230                                   const bool rest,
231                                   const bool for_deform,
232                                   Mat4 *result_array);
233
234 void BKE_pchan_bbone_handles_compute(const BBoneSplineParameters *param,
235                                      float h1[3],
236                                      float *r_roll1,
237                                      float h2[3],
238                                      float *r_roll2,
239                                      bool ease,
240                                      bool offsets);
241 int BKE_pchan_bbone_spline_compute(struct BBoneSplineParameters *param,
242                                    const bool for_deform,
243                                    Mat4 *result_array);
244
245 void BKE_pchan_bbone_segments_cache_compute(struct bPoseChannel *pchan);
246 void BKE_pchan_bbone_segments_cache_copy(struct bPoseChannel *pchan,
247                                          struct bPoseChannel *pchan_from);
248
249 void BKE_pchan_bbone_deform_segment_index(const struct bPoseChannel *pchan,
250                                           float pos,
251                                           int *r_index,
252                                           float *r_blend_next);
253
254 /* like EBONE_VISIBLE */
255 #define PBONE_VISIBLE(arm, bone) \
256   (CHECK_TYPE_INLINE(arm, bArmature *), \
257    CHECK_TYPE_INLINE(bone, Bone *), \
258    (((bone)->layer & (arm)->layer) && !((bone)->flag & BONE_HIDDEN_P)))
259
260 #define PBONE_SELECTABLE(arm, bone) \
261   (PBONE_VISIBLE(arm, bone) && !((bone)->flag & BONE_UNSELECTABLE))
262
263 /* context.selected_pose_bones */
264 #define FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN(_ob, _pchan) \
265   for (bPoseChannel *_pchan = (_ob)->pose->chanbase.first; _pchan; _pchan = _pchan->next) { \
266     if (PBONE_VISIBLE(((bArmature *)(_ob)->data), (_pchan)->bone) && \
267         ((_pchan)->bone->flag & BONE_SELECTED)) {
268 #define FOREACH_PCHAN_SELECTED_IN_OBJECT_END \
269   } \
270   } \
271   ((void)0)
272 /* context.visible_pose_bones */
273 #define FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN(_ob, _pchan) \
274   for (bPoseChannel *_pchan = (_ob)->pose->chanbase.first; _pchan; _pchan = _pchan->next) { \
275     if (PBONE_VISIBLE(((bArmature *)(_ob)->data), (_pchan)->bone)) {
276 #define FOREACH_PCHAN_VISIBLE_IN_OBJECT_END \
277   } \
278   } \
279   ((void)0)
280
281 /* Evaluation helpers */
282 struct bKinematicConstraint;
283 struct bPose;
284 struct bSplineIKConstraint;
285
286 struct bPoseChannel *BKE_armature_ik_solver_find_root(struct bPoseChannel *pchan,
287                                                       struct bKinematicConstraint *data);
288 struct bPoseChannel *BKE_armature_splineik_solver_find_root(struct bPoseChannel *pchan,
289                                                             struct bSplineIKConstraint *data);
290
291 void BKE_pose_splineik_init_tree(struct Scene *scene, struct Object *ob, float ctime);
292 void BKE_splineik_execute_tree(struct Depsgraph *depsgraph,
293                                struct Scene *scene,
294                                struct Object *ob,
295                                struct bPoseChannel *pchan_root,
296                                float ctime);
297
298 void BKE_pose_pchan_index_rebuild(struct bPose *pose);
299
300 void BKE_pose_eval_init(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *object);
301
302 void BKE_pose_eval_init_ik(struct Depsgraph *depsgraph,
303                            struct Scene *scene,
304                            struct Object *object);
305
306 void BKE_pose_eval_bone(struct Depsgraph *depsgraph,
307                         struct Scene *scene,
308                         struct Object *object,
309                         int pchan_index);
310
311 void BKE_pose_constraints_evaluate(struct Depsgraph *depsgraph,
312                                    struct Scene *scene,
313                                    struct Object *object,
314                                    int pchan_index);
315
316 void BKE_pose_bone_done(struct Depsgraph *depsgraph, struct Object *object, int pchan_index);
317
318 void BKE_pose_eval_bbone_segments(struct Depsgraph *depsgraph,
319                                   struct Object *object,
320                                   int pchan_index);
321
322 void BKE_pose_iktree_evaluate(struct Depsgraph *depsgraph,
323                               struct Scene *scene,
324                               struct Object *object,
325                               int rootchan_index);
326
327 void BKE_pose_splineik_evaluate(struct Depsgraph *depsgraph,
328                                 struct Scene *scene,
329                                 struct Object *object,
330                                 int rootchan_index);
331
332 void BKE_pose_eval_done(struct Depsgraph *depsgraph, struct Object *object);
333
334 void BKE_pose_eval_cleanup(struct Depsgraph *depsgraph,
335                            struct Scene *scene,
336                            struct Object *object);
337
338 void BKE_pose_eval_proxy_init(struct Depsgraph *depsgraph, struct Object *object);
339 void BKE_pose_eval_proxy_done(struct Depsgraph *depsgraph, struct Object *object);
340 void BKE_pose_eval_proxy_cleanup(struct Depsgraph *depsgraph, struct Object *object);
341
342 void BKE_pose_eval_proxy_copy_bone(struct Depsgraph *depsgraph,
343                                    struct Object *object,
344                                    int pchan_index);
345
346 #ifdef __cplusplus
347 }
348 #endif
349
350 #endif